#!/usr/bin/python
import json

import sys
import getopt
import ConfigParser
import threading
import time
from gmshelper import GmsHelper
from portalhelper import PortalHelper
from vxoahelper import VxoaHelper

# this script is run when a lab instance is created from the blueprint.


class Main:
    def __init__(self, argv):
        self.argv = argv
        self.configfile = ""
        self.opts = None
        self.args = None
        self.config = None
        self.portal_url = "cloudportal.silver-peak.com"
        self.portal_account_name = "foo"
        self.portal_account_key = "bar"
        self.gms_url = ""
        self.gms_user = "admin"
        self.gms_password = "admin"
        self.lan_labels = []
        self.wan_labels = []
        self.lan_label_ids = {}
        self.wan_label_ids = {}
        self.reverse_lan_label_map = {}
        self.reverse_wan_label_map = {}
        self.appliance_list = []

    def run(self):
        try:
            self.opts, self.args = getopt.getopt(self.argv, "",
                                                 ["help", "config="])
        except getopt.GetoptError:
            self.usage()
            sys.exit(2)

        for opt, arg in self.opts:
            if opt == '--help':
                self.usage()
                sys.exit(0)
            elif opt == "--config":
                self.configfile = arg

        if self.configfile == "":
            self.usage()
            sys.exit(1)

        print 'Config file: ', self.configfile

        self.config = ConfigParser.RawConfigParser()
        self.config.read(self.configfile)

        portal_api = PortalHelper(self.portal_url, "", "")
        response = portal_api.create_account()
        if response is None:
            print "Unable to create portal account"
            return
        self.portal_account_key = response['key']
        self.portal_account_name = response['name']

        self.gms_url = self.config.get('gms', 'ip_address')

        self.lan_labels = json.loads(self.config.get('gms', 'lan_labels'))
               self.wan_labels = json.loads(self.config.get('gms', 'wan_labels'))
               self.lan_label_ids = {}
               self.wan_label_ids = {}
               count = 1
               for item in self.wan_labels:
                   self.wan_label_ids[str(count)] = item
                   self.reverse_wan_label_map[item] = str(count)
                   count += 1

               for item in self.lan_labels:
                   self.lan_label_ids[str(count)] = item
                   self.reverse_lan_label_map[item] = str(count)
                   count += 1

        print "Setting up Orchestrator"
        if not self.setup_orchestrator():
            print "Failed to set up Orchestrator"
            return

        self.appliance_list = json.loads(self.config.get('gms', 'appliances'))
        appliance_setup_workers = []
        for appliance in self.appliance_list:
            t = threading.Thread(target=self.setup_appliance, args=[appliance])
            appliance_setup_workers.append(t)
            t.start()

        for worker in appliance_setup_workers:
            worker.join()

        # wait till portal and orchestrator get the appliances discovered - otherwise, approval
        # will fail.
        self.wait_for_discovery()

        # now approve all the appliances on the Orchestrator
        # wait till all appliances are discovered
        # each appliance has to go in the group configured for that appliance
        for appliance in self.appliance_list:
            group = self.config.get(appliance, 'group')
            self.approve_appliances(appliance, group)

        # wait for orchestrator to sync with appliances
        self.wait_for_sync()

        # create overlays on the Orchestrator
        self.create_overlays()

        # assign appliances to overlays
        self.associate_appliances_to_overlays()

        # save changes on appliances
        self.save_changes()

    def save_changes(self):
        for appliance in self.appliance_list:
            vxoaapi = VxoaHelper(appliance, self.config.get(appliance, 'ip_address'))
            vxoaapi.login()
            vxoaapi.save_changes()
            vxoaapi.logout()

    def wait_for_sync(self):
        count = 0
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()
        while True:
            alist = gmsapi.get_appliances()
            total_count = len(self.appliance_list)
            sync_count = 0
            for item in alist:
                if item["softwareVersion"] is not None:
                    if item["softwareVersion"].startswith("8."):
                        sync_count += 1

            if total_count <= sync_count:
                print "Everything is in sync"
                break

            print "Waiting for appliances to get synced"
            time.sleep(10)
            count += 10
            if count > 300:
                print "Giving up on syncing - proceeding"
                break

        gmsapi.logout()

    def wait_for_discovery(self):
        count = 0
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()
        while True:
            alist = gmsapi.get_discovered_appliances()
            if len(alist) >= len(self.appliance_list):
                # let us make sure all of them are reachable
                reachable_count = 0
                for item in alist:
                    if item["applianceInfo"]["reachabilityStatus"] == 1:
                        reachable_count += 1
                        print "Appliance {0} is reachable".format(item["applianceInfo"]["hostname"])
                    else:
                        print "Appliance {0} is UNREACHABLE".format(item["applianceInfo"]["hostname"])

                if reachable_count >= len(self.appliance_list):
                    print "Discovered all the appliances"
                    break

            print "Waiting for appliances to get discovered: currently discovered: {0}".format(len(alist))
            time.sleep(10)
            count += 10
            if count > 300:
                print "Giving up on discovery. Check network connectivity of appliances/Orchestrator to the Portal"
                break
            # trigger a reachability update
            gmsapi.put("/appliance/discovered/update", "")
            time.sleep(10)

        gmsapi.logout()

    def associate_appliances_to_overlays(self):
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()
        data = {}
        orch_appl_list = gmsapi.get_appliances()

        r = gmsapi.get("/gms/overlays/config")
        overlay_config = r.json()

        overlay_list = json.loads(self.config.get('gms', 'overlays'))
        for overlay_name in overlay_list:
            overlay_id = ""
            found = False
            for item in overlay_config:
                if item['name'] == overlay_name:
                    overlay_id = item['id']
                    found = True
                    print "Found overlay {0} and its id is {1}".format(overlay_name, overlay_id)
                    break

            if not found:
                print "Unable to find overlay {0} on Orchestrator".format(overlay_name)
                sys.exit(1)

            data[overlay_id] = list()
            appliance_list = json.loads(self.config.get(overlay_name, 'appliances'))
            for appliance in appliance_list:
                for orch_appliance in orch_appl_list:
                    if orch_appliance['hostName'] == appliance:
                        data[overlay_id].append(orch_appliance['id'])

        try:
            r = gmsapi.post("/gms/overlays/association", data)
            if r.status_code != 200 and r.status_code != 204:
                print "Unable to associate overlays to appliances on Orchestrator: {0}".format(r.text)
                sys.exit(1)
        except Exception as e:
            print "Unable to associate overlays to appliances on Orchestrator: {0}".format(e)
            sys.exit(1)

        gmsapi.logout()
        return True

    def create_overlays(self):
        overlay_list = json.loads(self.config.get('gms', 'overlays'))
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()
        for overlay_name in overlay_list:
            bonding_policy = self.config.get(overlay_name, 'bonding_policy')
            bonding_policy_enum = 1
            if bonding_policy == 'HQ':
                bonding_policy_enum = 2
            elif bonding_policy == 'HT':
                bonding_policy_enum = 3
            elif bonding_policy == 'HE':
                bonding_policy_enum = 4
            data = {
                "name": overlay_name,
                "topology": {
                    "topologyType": 2 if (self.config.get(overlay_name, 'topology') == "hub") else 1,
                    "hubs": []
                },
                "match": {
                },
                "brownoutThresholds": {
                    "loss": float(self.config.get(overlay_name, 'loss')),
                    "latency": int(self.config.get(overlay_name, 'latency')),
                    "jitter": int(self.config.get(overlay_name, 'jitter'))
                },
                "wanPorts": {
                    "primary": [],
                    "backup": []
                },
                "bondingPolicy": bonding_policy_enum,
                "crossConnect": bool(self.config.get(overlay_name, 'cross_connect')),
                "useBackupOnBrownout": bool(self.config.get(overlay_name, 'use_backup_on_brownout')),
                "trafficClass": self.config.get(overlay_name, 'traffic_class'),
                "boostTraffic": bool(self.config.get(overlay_name, 'boost')),
                "overlayFallbackOption": 2 if (self.config.get(overlay_name, 'fallback') == 'Drop') else 1
            }
            match_condition = self.config.get(overlay_name, 'match')
            match_info = match_condition.split(':')
            if match_info[0] == 'acl':
                data['match'] = {"acl": match_info[1]}
            else:
                data['match'] = {'interfaceLabel': self.reverse_lan_label_map[match_info[1]]}
            wan_port_list = json.loads(self.config.get(overlay_name, 'primary_ports'))
            backup_port_list = json.loads(self.config.get(overlay_name, 'backup_ports'))
            for item in wan_port_list:
                data['wanPorts']['primary'].extend(self.reverse_wan_label_map[item])
            for item in backup_port_list:
                data['wanPorts']['backup'].extend(self.reverse_wan_label_map[item])

            hub_list = json.loads(self.config.get(overlay_name, 'hubs'))
            # find the nepk for this hub
            appliance_list = gmsapi.get_appliances()
            nepk_list = list()
            for item in hub_list:
                for appl in appliance_list:
                    if appl['hostName'] == item:
                        nepk_list.append(appl['id'])

            if len(nepk_list) > 0:
                data['topology']['hubs'] = nepk_list

            try:
                print "Overlay JSON to be posted: {0}".format(json.dumps(data))
                print "Creating overlay {0}".format(overlay_name)
                r = gmsapi.post('/gms/overlays/config', data)
                if r.status_code != 200:
                    print "Unable to create overlay {1} on Orchestrator: {0}".format(r.text, overlay_name)
                    sys.exit(1)

            except Exception as e:
                print "Unable to create overlay {1} on Orchestrator: {0}".format(e, overlay_name)
                sys.exit(1)

        gmsapi.logout()

    def setup_appliance(self, cfg_name):
        print "Setting up appliance: {0}".format(cfg_name)
        vxoaapi = VxoaHelper(cfg_name, self.config.get(cfg_name, 'ip_address'))
        vxoaapi.wait_for_webserver_restart()
        vxoaapi.login()

        try:
            print "Setting up portal configuration on :{0}".format(cfg_name)
            vxoaapi.set_portal(self.portal_url, True, self.portal_account_key,
                               self.portal_account_name, self.config.get(cfg_name, 'tag'))
            print "Setting up EdgeConnect licensing on :{0}".format(cfg_name)
            vxoaapi.set_eclicense(True, self.config.get(cfg_name, 'boost_bw'))

            vxoaapi.save_changes()
            time.sleep(5)
        finally:
            vxoaapi.logout()

        return True

    def setup_orchestrator(self):
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()

        # set account name and key
        print "Setting Orchestrator Portal Config"
        try:
            r = gmsapi.get("/spPortal/config")
            if r.status_code != 200:
                print "Unable to get current Portal configuration for Orchestrator: {0}".format(r.text)
                sys.exit(1)

            data = r.json()
            data["registration"]["account"] = self.portal_account_name
            data["registration"]["key"] = self.portal_account_key

            r = gmsapi.post("/spPortal/config", data)
            if r.status_code != 200 and r.status_code != 204:
                print "Unable to POST Portal configuration for Orchestrator: {0}".format(r.text)
                sys.exit(1)

            # trigger registration
            gmsapi.post("/spPortal/registration", data)

        except Exception as e:
            print "Unable to apply account name and key for Orchestrator: {0}".format(e)
            sys.exit(1)

        gmsapi.logout()
        return True

    def approve_appliances(self, appliance, group):
        print "Approving appliance on Orchestrator: {0}".format(appliance)
        gmsapi = GmsHelper(self.gms_url, self.gms_user, self.gms_password)
        gmsapi.login()
        try:
            appliance_list = gmsapi.get_discovered_appliances()
            r = gmsapi.get("/gms/group")
            group_list = r.json()
            group_pk = None
            for item in group_list:
                if item['name'] == group:
                    group_pk = item['id']
                    print "Found group primary key {0} for group {1}".format(group_pk, group)
                    break

            found = False
            for discovered_item in appliance_list:
                if discovered_item['applianceInfo']['hostname'] == appliance:
                    print "Found appliance: {0}. Trying to approve".format(appliance)
                    gmsapi.approve_appliance(discovered_item['id'], group_pk)
                    return True

            if not found:
                print "Could not find appliance {0} in discovered table. Check if appliances can connect to Portal".format(appliance)
                return False

        except Exception as e:
            print "Unable to approve appliance {0}. Error: {1}".format(appliance, e)
            return False
        finally:
            gmsapi.logout()

    @staticmethod
    def usage():
        print "USAGE: main.py -c <configfile>"

if __name__ == "__main__":
    main_obj = Main(sys.argv[1:])
    main_obj.run()