#!/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 os
from optparse import OptionParser, OptionGroup
import sys
import locale
import socket
import re
from proton import Messenger, Message, Timeout

home = os.environ.get("QPID_DISPATCH_HOME", os.path.normpath("${QPID_DISPATCH_HOME_INSTALLED}"))
sys.path.append(os.path.join(home, "python"))

from qpid_dispatch_internal.tools import Display, Header, Sorter, YN, Commas, TimeLong


class Config:
    def __init__(self):
        self._host = "0.0.0.0"
        self._connTimeout = 5
        self._types = ""
        self._limit = 50
        self._increasing = False
        self._sortcol = None

config = Config()
conn_options = {}

def OptionsAndArguments(argv):
    """ Set global variables for options, return arguments """

    global config
    global conn_options

    usage = \
"""%prog -g [options]
       %prog -c [options]
       %prog -l [options]
       %prog -n [options]
       %prog -a [options]
       %prog -m [options]"""

    parser = OptionParser(usage=usage)

    group1 = OptionGroup(parser, "General Options")
    group1.add_option("-b", "--bus",  action="store", type="string", default="0.0.0.0", metavar="<access-url>",
                      help="URL of the messaging bus to connect to")
    group1.add_option("-r", "--router", action="store", type="string", default=None, metavar="<router-id>", help="Router to be queried")
    group1.add_option("-t", "--timeout", action="store", type="int", default=5, metavar="<secs>",
                      help="Maximum time to wait for connection (in seconds)")
    group1.add_option("--sasl-mechanism", action="store", type="string", metavar="<mech>",
                      help="SASL mechanism for authentication (e.g. EXTERNAL, ANONYMOUS, PLAIN, CRAM-MD5, DIGEST-MD5, GSSAPI). SASL automatically picks the most secure available mechanism - use this option to override.")
    group1.add_option("--ssl-certificate", action="store", type="string", metavar="<cert>", help="Client SSL certificate (PEM Format)")
    group1.add_option("--ssl-key", action="store", type="string", metavar="<key>", help="Client SSL private key (PEM Format)")
    parser.add_option_group(group1)

    group2 = OptionGroup(parser, "Command Options")
    group2.add_option("-g", "--general", help="Show General Router Stats",  action="store_const", const="g",   dest="show")
    group2.add_option("-c", "--connections", help="Show Connections",       action="store_const", const="c",   dest="show")
    group2.add_option("-l", "--links", help="Show Router Links",            action="store_const", const="l",   dest="show")
    group2.add_option("-n", "--nodes", help="Show Router Nodes",            action="store_const", const="n",   dest="show")
    group2.add_option("-a", "--address", help="Show Router Addresses",      action="store_const", const="a",   dest="show")
    group2.add_option("-m", "--memory", help="Show Broker Memory Stats",    action="store_const", const="m",   dest="show")
    parser.add_option_group(group2)

    opts, args = parser.parse_args(args=argv)

    if not opts.show:
        parser.error("You must specify one of these options: -g, -c, -l, -n, -a, or -m. For details, try $ qdstat --help")

    config._types = opts.show
    config._host = opts.bus
    config._router = opts.router
    config._connTimeout = opts.timeout

    return args


class BusManager:
    def __init__(self):
        pass

    def SetHost(self, host, router):
        self.M = Messenger()
        self.M.start()
        self.M.timeout = config._connTimeout
        self.M.route("amqp:/*", "amqp://%s/$1" % host)
        if router:
            self.address = "amqp:/_topo/0/%s/$management" % router
        else:
            self.address = "amqp:/_local/$management"
        self.subscription = self.M.subscribe("amqp:/#")
        self.reply = self.subscription.address

    def Disconnect(self):
        self.M.stop()

    def _get_object(self, cls):
        request = Message()
        response = Message()

        request.address = self.address
        request.reply_to = self.reply
        request.correlation_id = 1
        request.properties = {u'operation':u'GET', u'type':cls}

        self.M.put(request)
        self.M.send()
        self.M.recv()
        self.M.get(response)

        return response.body
        

    def displayConnections(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("state"))
        heads.append(Header("host"))
        heads.append(Header("container"))
        heads.append(Header("sasl-mechanisms"))
        heads.append(Header("role"))
        heads.append(Header("dir"))

        rows = []

        objects = self._get_object('org.apache.qpid.dispatch.connection')

        for conn in objects:
            row = []
            row.append(conn['state'])
            row.append(conn['host'])
            row.append(conn['container'])
            row.append(conn['sasl'])
            row.append(conn['role'])
            row.append(conn['dir'])
            rows.append(row)
        title = "Connections"
        dispRows = rows
        disp.formattedTable(title, heads, dispRows)

    def _addr_class(self, addr):
        if not addr:
            return "-"
        if addr[0] == 'M' : return "mobile"
        if addr[0] == 'R' : return "router"
        if addr[0] == 'A' : return "area"
        if addr[0] == 'L' : return "local"
        return "unknown: %s" % addr[0]

    def _addr_text(self, addr):
        if not addr:
            return "-"
        return addr[1:]

    def displayGeneral(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("attr"))
        heads.append(Header("value"))
        rows = []

        objects = self._get_object('org.apache.qpid.dispatch.router')

        router = objects[0]
        rows.append(('Mode',          router['mode']))
        rows.append(('Area',          router['area']))
        rows.append(('Router Id',     router['router_id']))
        rows.append(('Address Count', router['addr_count']))
        rows.append(('Link Count',    router['link_count']))
        rows.append(('Node Count',    router['node_count']))

        title = "Router Statistics"
        dispRows = rows
        disp.formattedTable(title, heads, dispRows)

    def displayRouterLinks(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("type"))
        heads.append(Header("dir"))
        heads.append(Header("rindex"))
        heads.append(Header("class"))
        heads.append(Header("addr"))
        rows = []

        objects = self._get_object('org.apache.qpid.dispatch.router.link')

        for link in objects:
            row = []
            row.append(link['link-type'])
            row.append(link['link-dir'])
            if link['link-type'] == "inter-router":
                row.append(link['index'])
            else:
                row.append('-')
            row.append(self._addr_class(link['owning-addr']))
            row.append(self._addr_text(link['owning-addr']))
            rows.append(row)
        title = "Router Links"
        dispRows = rows
        disp.formattedTable(title, heads, dispRows)

    def displayRouterNodes(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("router-id"))
        heads.append(Header("next-hop"))
        heads.append(Header("link"))
        heads.append(Header("valid-origins"))
        rows = []

        objects  = self._get_object('org.apache.qpid.dispatch.router.node')
        attached = self._get_object('org.apache.qpid.dispatch.router')[0]

        nodes = {}
        for node in objects:
            nodes[node['index']] = node
            node['addr'] = self._addr_text(node['addr'])

        rows.append([attached['router_id'], '-', '(self)', ''])
        for node in objects:
            row = []
            row.append(node['addr'])
            if node['next-hop'] != None:
                row.append(nodes[node['next-hop']]['addr'])
            else:
                row.append('-')
            if node['router-link'] != None:
                row.append(node['router-link'])
            else:
                row.append('-')
            vo = None
            for i in node['valid-origins']:
                if not vo:
                    vo = ""
                else:
                    vo += ", "
                vo += nodes[i]['addr']
            row.append(vo)
            rows.append(row)
        title = "Router Nodes"
        sort = Sorter(heads, rows, 'router-id')
        dispRows = sort.getSorted()
        disp.formattedTable(title, heads, dispRows)

    def displayAddresses(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("class"))
        heads.append(Header("address"))
        heads.append(Header("in-proc", Header.Y))
        heads.append(Header("local", Header.COMMAS))
        heads.append(Header("remote", Header.COMMAS))
        heads.append(Header("in", Header.COMMAS))
        heads.append(Header("out", Header.COMMAS))
        heads.append(Header("thru", Header.COMMAS))
        heads.append(Header("to-proc", Header.COMMAS))
        heads.append(Header("from-proc", Header.COMMAS))
        rows = []

        objects = self._get_object('org.apache.qpid.dispatch.router.address')

        for addr in objects:
            row = []
            row.append(self._addr_class(addr['addr']))
            row.append(self._addr_text(addr['addr']))
            row.append(addr['in-process'])
            row.append(addr['subscriber-count'])
            row.append(addr['remote-count'])
            row.append(addr['deliveries-ingress'])
            row.append(addr['deliveries-egress'])
            row.append(addr['deliveries-transit'])
            row.append(addr['deliveries-to-container'])
            row.append(addr['deliveries-from-container'])
            rows.append(row)
        title = "Router Addresses"
        sorter = Sorter(heads, rows, 'address', 0, True)
        dispRows = sorter.getSorted()
        disp.formattedTable(title, heads, dispRows)

    def displayMemory(self):
        disp = Display(prefix="  ")
        heads = []
        heads.append(Header("type"))
        heads.append(Header("size", Header.COMMAS))
        heads.append(Header("batch"))
        heads.append(Header("thread-max", Header.COMMAS))
        heads.append(Header("total", Header.COMMAS))
        heads.append(Header("in-threads", Header.COMMAS))
        heads.append(Header("rebal-in", Header.COMMAS))
        heads.append(Header("rebal-out", Header.COMMAS))
        rows = []

        objects = self._get_object('org.apache.qpid.dispatch.allocator')

        for t in objects:
            row = []
            row.append(t['name'])
            row.append(t['type_size'])
            row.append(t['transfer_batch_size'])
            row.append(t['local_free_list_max'])
            row.append(t['total_alloc_from_heap'])
            row.append(t['held_by_threads'])
            row.append(t['batches_rebalanced_to_threads'])
            row.append(t['batches_rebalanced_to_global'])
            rows.append(row)
        title = "Types"
        sorter = Sorter(heads, rows, 'type', 0, True)
        dispRows = sorter.getSorted()
        disp.formattedTable(title, heads, dispRows)

    def displayMain(self, names, main):
        if   main == 'l': self.displayRouterLinks()
        elif main == 'n': self.displayRouterNodes()
        elif main == 'a': self.displayAddresses()
        elif main == 'm': self.displayMemory()
        elif main == 'g': self.displayGeneral()
        elif main == 'c': self.displayConnections()

    def display(self, names):
        self.displayMain(names, config._types)


def main(argv=None):

    args = OptionsAndArguments(argv)
    bm   = BusManager()

    try:
        bm.SetHost(config._host, config._router)
        bm.display(args)
        bm.Disconnect()
        return 0
    except KeyboardInterrupt:
        print
    except Timeout:
        if config._router:
            print "No response from router %s after timeout" % config._router
        else:
            print "No response after timeout"
    except Exception,e:
        print "Failed: %s - %s" % (e.__class__.__name__, e)

    bm.Disconnect()
    return 1

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