#!/usr/bin/python

__author__ = "Mykola Yakovliev"
__credits__ = ["Mykola Yakovliev"]
__license__ = "GPLv3"
__version__ = "1.0"
__maintainer__ = "Mykola Yakovliev"
__email__ = "vegasq@gmail.com"
__status__ = "Production"

import argparse
from pprint import pprint
import requests
import json
from simplejson.scanner import JSONDecodeError

from prettytable import PrettyTable
from keystoneclient.v2_0 import client


class ContrailAPIWrap(object):
    """Generic wrapper that handles requests to Contrail VIP.

    Requires working keystone v2
    """
    def __init__(self, contrail_ep, keystone_ep, user, password, tenant):
        self.contrail_ep = contrail_ep
        self.keystone_ep = keystone_ep
        self.user = user
        self.password = password
        self.tenant = tenant

    def _get_token(self):
        kc = client.Client(
            username=self.user, password=self.password,
            auth_url=self.keystone_ep, tenant_name=self.tenant)

        k = kc.service_catalog.get_token()
        return k['id']

    def get(self, cmd=""):
        token = self._get_token()
        data = requests.get(
            "%s%s" % (self.contrail_ep, cmd),
            headers={'X-Auth-Token': token})
        try:
            return data.json()
        except JSONDecodeError:
            print(data.text)


class PyContrailBackend(object):
    def __init__(self, contrail_ep, keystone_ep, user, password, tenant):
        self.conn = ContrailAPIWrap(
                contrail_ep, keystone_ep, user, password, tenant)

        self.multiple_key = None
        self.single_key = None

    def prnt(self, t):
        print(self.header)
        print(t)

    def display(self):
        t = PrettyTable(['Name', 'IP', 'UUID'])
        for node in self.get_nodes():
            t.add_row(node)
        self.prnt(t)

    def get_nodes(self):
        nodes = []

        nodes_resp = self.conn.get(self.multiple_key)
        for n in nodes_resp[self.multiple_key]:
            # Remove full path since we handle it on higher level
            item_href = n['href'].replace(self.conn.contrail_ep, '')
            info = self.conn.get(item_href)[self.single_key]

            ip = None
            if 'virtual_router_ip_address' in info:
                ip = info['virtual_router_ip_address']
            elif 'analytics_node_ip_address' in info:
                ip = info['analytics_node_ip_address']
            elif 'config_node_ip_address' in info:
                ip = info['config_node_ip_address']
            elif 'database_node_ip_address' in info:
                ip = info['database_node_ip_address']
            else:
                for k in info.keys():
                    if "_ip_" in k:
                        ip = info[k]
            if ip is None:
                ip = json.dumps(info['fq_name'])

            nodes.append((info['display_name'], ip, info['uuid']))
        return nodes


class AnalyticsNodes(PyContrailBackend):
    def __init__(self, *args, **kwargs):
        super(AnalyticsNodes, self).__init__(*args, **kwargs)

        self.header = "Analytics nodes"
        self.multiple_key = 'analytics-nodes'
        self.single_key = 'analytics-node'


class ConfigNodes(PyContrailBackend):
    def __init__(self, *args, **kwargs):
        super(ConfigNodes, self).__init__(*args, **kwargs)

        self.header = "Config nodes"
        self.multiple_key = 'config-nodes'
        self.single_key = 'config-node'


class DatabaseNodes(PyContrailBackend):
    def __init__(self, *args, **kwargs):
        super(DatabaseNodes, self).__init__(*args, **kwargs)

        self.header = "Database nodes"
        self.multiple_key = 'database-nodes'
        self.single_key = 'database-node'


class PhysicalRouters(PyContrailBackend):
    def __init__(self, *args, **kwargs):
        super(PhysicalRouters, self).__init__(*args, **kwargs)

        self.header = "Physical Routers"
        self.multiple_key = 'physical-routers'
        self.single_key = 'physical-router'


class VirtualRouters(PyContrailBackend):
    def __init__(self, *args, **kwargs):
        super(VirtualRouters, self).__init__(*args, **kwargs)

        self.header = "Virtual routers"
        self.multiple_key = 'virtual-routers'
        self.single_key = 'virtual-router'


class NodesFacade(object):
    def __init__(self):
        parser = argparse.ArgumentParser(description='Display Contrail nodes')
        parser.add_argument(
            '--username', type=str, metavar='USERNAME',
            help="Username", required=True)
        parser.add_argument(
            '--password', type=str, metavar='PASSWORD',
            help="Password", required=True)
        parser.add_argument(
            '--tenant', type=str, metavar='tenant',
            help="tenant", required=True)
        parser.add_argument(
            '--contrail-ep', type=str, metavar='CONTRAILEP',
            help="Contrail endpoint", required=True)
        parser.add_argument(
            '--keystone-ep', type=str, metavar='KEYSTONEEP',
            help="Keystone endpoint", required=True)
        parser.add_argument(
            '--get', type=str, metavar="HREF", help="Get object")

        parsed_args = parser.parse_args()

        if parsed_args.get:
            if parsed_args.get == '/':
                parsed_args.get = ''
            v = ContrailAPIWrap(
                parsed_args.contrail_ep, parsed_args.keystone_ep,
                parsed_args.username, parsed_args.password,
                parsed_args.tenant).get(parsed_args.get)
            pprint(v)
        else:
            monitor = [ConfigNodes, DatabaseNodes, AnalyticsNodes,
                       VirtualRouters, PhysicalRouters]
            for object_type in monitor:
                object_type(
                    parsed_args.contrail_ep, parsed_args.keystone_ep,
                    parsed_args.username, parsed_args.password,
                    parsed_args.tenant).display()


if __name__ == '__main__':
    NodesFacade()