#!/usr/bin/env python

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

import sys, json, re
import  qpid_dispatch_site
from qpid_dispatch.management.client import Node, Url
from collections import Mapping, Sequence
from optparse import OptionGroup
from qpid_dispatch_internal.tools.command import OptionParser, Option, UsageError, connection_options, check_args, main, opts_ssl_domain, opts_url

def attr_split(attrstr):
    """Split an attribute string of the form name=value or name to indicate None"""
    nv = attrstr.split("=", 1)
    if len(nv) == 1: return [nv[0], None]
    else:
        if nv[1] == "true": nv[1] = True
        if nv[1] == "false": nv[1] = False
        return nv

class QdManage():

    def __init__(self):

        self.operations = ['QUERY', 'CREATE', 'READ', 'UPDATE', 'DELETE',
                           'GET-TYPES', 'GET-OPERATIONS', 'GET-ATTRIBUTES', 'GET-ANNOTATIONS',
                           'GET-MGMT-NODES', 'GET-SCHEMA', 'GET-LOG']

        usage = "%prog <operation> [options...] [arguments...]"
        description = "Standard operations: %s. Use GET-OPERATIONS to find additional operations." \
                      % (", ".join(self.operations))

        op = OptionParser(usage=usage, option_class=Option, description=description)
        op.add_option('--type', help='Type of entity to operate on.')
        op.add_option('--name', help='Name of entity to operate on.')
        op.add_option('--identity', help='Identity of entity to operate on.', metavar="ID")
        op.add_option("--indent", type="int", default=2,
                     help="Pretty-printing indent. -1 means don't pretty-print (default %default)")
        op.add_option('--stdin', action='store_true',
                      help='Read attributes as JSON map or list of maps from stdin.')
        op.add_option('--body', help='JSON value to use as body of a non-standard operation call.')
        op.add_option('--properties', help='JSON map to use as properties for a non-standard operation call.')
        op.add_option_group(connection_options(op))
        self.op = op

    def run(self, argv):
        # Make all args unicode to avoid encoding arg values as AMQP bytes.
        self.opts, self.args = self.op.parse_args([unicode(x) for x in argv[1:]])
        if self.opts.indent == -1: self.opts.indent = None
        if len(self.args) == 0: raise UsageError("No operation specified")
        self.node = Node.connect(
            opts_url(self.opts), self.opts.router, self.opts.timeout, opts_ssl_domain(self.opts))
        operation = self.args.pop(0)
        method = operation.lower().replace('-','_')
        if operation.upper() in self.operations and hasattr(self, method):
            getattr(self, method)() # Built-in operation
        else:
            self.operation(operation) # Custom operation

    def main(self, argv):
        return main(self.run, argv, self.op)

    def print_json(self, data):
        """Print data as JSON"""
        print json.dumps(data, indent=self.opts.indent)

    def print_result(self, result):
        """Print a string result as-is, else try json dump, else print as-is"""
        if not result: return
        if isinstance(result, basestring):
            print result
        else:
            try:
                self.print_json(result)
            except ValueError:
                print result

    def call_node(self, method, *argnames, **kwargs):
        """Call method on node, use opts named in argnames"""
        names = set(argnames)
        for k in self.opts.__dict__:
            if k in names and hasattr(self.opts, k):
                kwargs[k] = getattr(self.opts, k)
        return getattr(self.node, method)(**kwargs)

    def call_bulk(self, func):
        """Call function for attributes from stdin or --attributes option"""
        if self.opts.stdin:
            data = json.load(sys.stdin)
            if isinstance(data, Mapping):
                self.print_json(func(data).attributes)
            elif isinstance(data, Sequence):
                self.print_json([func(attrs).attributes for attrs in data])
            else: raise ValueError("stdin is not a JSON map or list")
        else:
            self.print_json(func(self.opts.attributes).attributes)

    def query(self):
        """query [ATTR...]          Print attributes of entities."""
        if self.args:  self.opts.attribute_names = self.args
        result = self.call_node('query', 'type', 'attribute_names')
        self.print_json(result.get_dicts(clean=True))

    def create(self):
        """create [ATTR=VALUE...]   Create a new entity."""
        if self.args:
            self.opts.attributes = dict(attr_split(arg) for arg in self.args)
        self.call_bulk(lambda attrs: self.call_node('create', 'type', 'name', attributes=attrs))

    def read(self):
        """read                     Print attributes of selected entity."""
        check_args(self.args, 0)
        self.print_json(self.call_node('read', 'type', 'name', 'identity').attributes)

    def update(self):
        """update [ATTR=VALUE...]   Update an entity."""
        if self.args:
            self.opts.attributes = dict(attr_split(arg) for arg in self.args)
        self.call_bulk(
            lambda attrs: self.call_node('update', 'type', 'name', 'identity', attributes=attrs))

    def delete(self):
        """delete                   Delete an entity"""
        check_args(self.args, 0)
        self.call_node('delete', 'type', 'name', 'identity')

    def get_types(self):
        """get-types [TYPE]         List entity types with their base types."""
        self.opts.type = check_args(self.args, 1)[0]
        self.print_json(self.call_node('get_types', 'type'))

    def get_annotations(self):
        """get-annotations [TYPE]   List entity types with the annotations they implement."""
        self.opts.type = check_args(self.args, 1)[0]
        self.print_json(self.call_node('get_annotations', 'type'))

    def get_attributes(self):
        """get-attributes [TYPE]    List entity types with their attributes."""
        self.opts.type = check_args(self.args, 1)[0]
        self.print_json(self.call_node('get_attributes', 'type'))

    def get_operations(self):
        """get-operations [TYPE]    List entity types with their operations."""
        self.opts.type = check_args(self.args, 1)[0]
        self.print_json(self.call_node('get_operations', 'type'))

    def get_mgmt_nodes(self):
        """get-mgmt-nodes           List of other known management nodes"""
        check_args(self.args, 0)
        self.print_json(self.call_node('get_mgmt_nodes'))

    def json_arg(self, value):
        try:
            return json.loads(value)
        except ValueError, e:
            if not re.search(r'["{}\[\]]', value): # Doesn't look like attempted JSON.
                return value    # Just treat as plain string
            raise ValueError("Invalid JSON '%s': %s" % (value, e))

    def operation(self, operation):
        """operation [ATTR=VALUE...]   Call custom operation with ATTR=VALUE as request properties. Use --body and --properties if specified."""
        properties = dict(attr_split(arg) for arg in self.args or [])
        if self.opts.properties:
            properties.update(self.json_arg(self.opts.properties))
        body = None
        if self.opts.body:
            body = self.json_arg(self.opts.body)
        request = self.call_node('request', 'type', 'name', 'identity', operation=operation, body=body, **properties)
        self.print_result(self.node.call(request).body)

if __name__ == "__main__":
    sys.exit(QdManage().main(sys.argv))