#
# Copyright (c) 2014-2018 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#

"""
System Inventory Interactions
"""

import json
import openstack

from six.moves.urllib import request as urlrequest
from six.moves.urllib.error import URLError
from six.moves.urllib.error import HTTPError

from controllerconfig.common import log
from controllerconfig.common.exceptions import KeystoneFail


LOG = log.get_logger(__name__)

API_VERSION = 1

# Host Personality Constants
HOST_PERSONALITY_NOT_SET = ""
HOST_PERSONALITY_UNKNOWN = "unknown"
HOST_PERSONALITY_CONTROLLER = "controller"
HOST_PERSONALITY_WORKER = "worker"
HOST_PERSONALITY_STORAGE = "storage"

# Host Administrative State Constants
HOST_ADMIN_STATE_NOT_SET = ""
HOST_ADMIN_STATE_UNKNOWN = "unknown"
HOST_ADMIN_STATE_LOCKED = "locked"
HOST_ADMIN_STATE_UNLOCKED = "unlocked"

# Host Operational State Constants
HOST_OPERATIONAL_STATE_NOT_SET = ""
HOST_OPERATIONAL_STATE_UNKNOWN = "unknown"
HOST_OPERATIONAL_STATE_ENABLED = "enabled"
HOST_OPERATIONAL_STATE_DISABLED = "disabled"

# Host Availability State Constants
HOST_AVAIL_STATE_NOT_SET = ""
HOST_AVAIL_STATE_UNKNOWN = "unknown"
HOST_AVAIL_STATE_AVAILABLE = "available"
HOST_AVAIL_STATE_ONLINE = "online"
HOST_AVAIL_STATE_OFFLINE = "offline"
HOST_AVAIL_STATE_POWERED_OFF = "powered-off"
HOST_AVAIL_STATE_POWERED_ON = "powered-on"

# Host Board Management Constants
HOST_BM_TYPE_NOT_SET = ""
HOST_BM_TYPE_UNKNOWN = "unknown"
HOST_BM_TYPE_ILO3 = 'ilo3'
HOST_BM_TYPE_ILO4 = 'ilo4'

# Host invprovision state
HOST_PROVISIONING = "provisioning"
HOST_PROVISIONED = "provisioned"


class Host(object):
    def __init__(self, hostname, host_data=None):
        self.name = hostname
        self.personality = HOST_PERSONALITY_NOT_SET
        self.admin_state = HOST_ADMIN_STATE_NOT_SET
        self.operational_state = HOST_OPERATIONAL_STATE_NOT_SET
        self.avail_status = []
        self.bm_type = HOST_BM_TYPE_NOT_SET
        self.uuid = None
        self.config_status = None
        self.invprovision = None
        self.boot_device = None
        self.rootfs_device = None
        self.console = None
        self.tboot = None

        if host_data is not None:
            self.__host_set_state__(host_data)

    def __host_set_state__(self, host_data):
        if host_data is None:
            self.admin_state = HOST_ADMIN_STATE_UNKNOWN
            self.operational_state = HOST_OPERATIONAL_STATE_UNKNOWN
            self.avail_status = []
            self.bm_type = HOST_BM_TYPE_NOT_SET

        # Set personality
        if host_data['personality'] == "controller":
            self.personality = HOST_PERSONALITY_CONTROLLER
        elif host_data['personality'] == "worker":
            self.personality = HOST_PERSONALITY_WORKER
        elif host_data['personality'] == "storage":
            self.personality = HOST_PERSONALITY_STORAGE
        else:
            self.personality = HOST_PERSONALITY_UNKNOWN

        # Set administrative state
        if host_data['administrative'] == "locked":
            self.admin_state = HOST_ADMIN_STATE_LOCKED
        elif host_data['administrative'] == "unlocked":
            self.admin_state = HOST_ADMIN_STATE_UNLOCKED
        else:
            self.admin_state = HOST_ADMIN_STATE_UNKNOWN

        # Set operational state
        if host_data['operational'] == "enabled":
            self.operational_state = HOST_OPERATIONAL_STATE_ENABLED
        elif host_data['operational'] == "disabled":
            self.operational_state = HOST_OPERATIONAL_STATE_DISABLED
        else:
            self.operational_state = HOST_OPERATIONAL_STATE_UNKNOWN

        # Set availability status
        self.avail_status[:] = []
        if host_data['availability'] == "available":
            self.avail_status.append(HOST_AVAIL_STATE_AVAILABLE)
        elif host_data['availability'] == "online":
            self.avail_status.append(HOST_AVAIL_STATE_ONLINE)
        elif host_data['availability'] == "offline":
            self.avail_status.append(HOST_AVAIL_STATE_OFFLINE)
        elif host_data['availability'] == "power-on":
            self.avail_status.append(HOST_AVAIL_STATE_POWERED_ON)
        elif host_data['availability'] == "power-off":
            self.avail_status.append(HOST_AVAIL_STATE_POWERED_OFF)
        else:
            self.avail_status.append(HOST_AVAIL_STATE_AVAILABLE)

        # Set board management type
        if host_data['bm_type'] is None:
            self.bm_type = HOST_BM_TYPE_NOT_SET
        elif host_data['bm_type'] == 'ilo3':
            self.bm_type = HOST_BM_TYPE_ILO3
        elif host_data['bm_type'] == 'ilo4':
            self.bm_type = HOST_BM_TYPE_ILO4
        else:
            self.bm_type = HOST_BM_TYPE_UNKNOWN

        if host_data['invprovision'] == 'provisioned':
            self.invprovision = HOST_PROVISIONED
        else:
            self.invprovision = HOST_PROVISIONING

        self.uuid = host_data['uuid']
        self.config_status = host_data['config_status']
        self.boot_device = host_data['boot_device']
        self.rootfs_device = host_data['rootfs_device']
        self.console = host_data['console']
        self.tboot = host_data['tboot']

    def __host_update__(self, admin_token, region_name):
        try:
            url = admin_token.get_service_admin_url("platform", "sysinv",
                                                    region_name)
            url += "/ihosts/" + self.name

            request_info = urlrequest.Request(url)
            request_info.add_header("X-Auth-Token", admin_token.get_id())
            request_info.add_header("Accept", "application/json")

            request = urlrequest.urlopen(request_info)
            response = json.loads(request.read())
            request.close()
            return response

        except KeystoneFail as e:
            LOG.error("Keystone authentication failed:{} ".format(e))
            return None

        except HTTPError as e:
            LOG.error("%s, %s" % (e.code, e.read()))
            if e.code == 401:
                admin_token.set_expired()
            return None

        except URLError as e:
            LOG.error(e)
            return None

    def __host_action__(self, admin_token, action, region_name):
        try:
            url = admin_token.get_service_admin_url("platform", "sysinv",
                                                    region_name)
            url += "/ihosts/" + self.name

            request_info = urlrequest.Request(url)
            request_info.get_method = lambda: 'PATCH'
            request_info.add_header("X-Auth-Token", admin_token.get_id())
            request_info.add_header("Content-type", "application/json")
            request_info.add_header("Accept", "application/json")
            request_info.add_data(action)

            request = urlrequest.urlopen(request_info)
            request.close()
            return True

        except KeystoneFail as e:
            LOG.error("Keystone authentication failed:{} ".format(e))
            return False

        except HTTPError as e:
            LOG.error("%s, %s" % (e.code, e.read()))
            if e.code == 401:
                admin_token.set_expired()
            return False

        except URLError as e:
            LOG.error(e)
            return False

    def is_unlocked(self):
        return(self.admin_state == HOST_ADMIN_STATE_UNLOCKED)

    def is_locked(self):
        return(not self.is_unlocked())

    def is_enabled(self):
        return(self.admin_state == HOST_ADMIN_STATE_UNLOCKED and
               self.operational_state == HOST_OPERATIONAL_STATE_ENABLED)

    def is_controller_enabled_provisioned(self):
        return(self.admin_state == HOST_ADMIN_STATE_UNLOCKED and
               self.operational_state == HOST_OPERATIONAL_STATE_ENABLED and
               self.personality == HOST_PERSONALITY_CONTROLLER and
               self.invprovision == HOST_PROVISIONED)

    def is_disabled(self):
        return(not self.is_enabled())

    def support_power_off(self):
        return(HOST_BM_TYPE_NOT_SET != self.bm_type)

    def is_powered_off(self):
        for status in self.avail_status:
            if status == HOST_AVAIL_STATE_POWERED_OFF:
                return(self.admin_state == HOST_ADMIN_STATE_LOCKED and
                       self.operational_state ==
                       HOST_OPERATIONAL_STATE_DISABLED)
        return False

    def is_powered_on(self):
        return not self.is_powered_off()

    def refresh_data(self, admin_token, region_name):
        """ Ask the System Inventory for an update view of the host """

        host_data = self.__host_update__(admin_token, region_name)
        self.__host_set_state__(host_data)

    def lock(self, admin_token, region_name):
        """ Asks the Platform to perform a lock against a host """

        if self.is_unlocked():
            action = json.dumps([{"path": "/action",
                                  "value": "lock", "op": "replace"}])

            return self.__host_action__(admin_token, action, region_name)

        return True

    def force_lock(self, admin_token, region_name):
        """ Asks the Platform to perform a force lock against a host """

        if self.is_unlocked():
            action = json.dumps([{"path": "/action",
                                  "value": "force-lock", "op": "replace"}])

            return self.__host_action__(admin_token, action, region_name)

        return True

    def unlock(self, admin_token, region_name):
        """ Asks the Platform to perform an ulock against a host """

        if self.is_locked():
            action = json.dumps([{"path": "/action",
                                  "value": "unlock", "op": "replace"}])

            return self.__host_action__(admin_token, action, region_name)

        return True

    def power_off(self, admin_token, region_name):
        """ Asks the Platform to perform a power-off against a host """

        if self.is_powered_on():
            action = json.dumps([{"path": "/action",
                                  "value": "power-off", "op": "replace"}])

            return self.__host_action__(admin_token, action, region_name)

        return True

    def power_on(self, admin_token, region_name):
        """ Asks the Platform to perform a power-on against a host """

        if self.is_powered_off():
            action = json.dumps([{"path": "/action",
                                  "value": "power-on", "op": "replace"}])

            return self.__host_action__(admin_token, action, region_name)

        return True


def get_hosts(admin_token, region_name, personality=None,
              exclude_hostnames=None):
    """ Asks System Inventory for a list of hosts """

    if exclude_hostnames is None:
        exclude_hostnames = []

    try:
        url = admin_token.get_service_admin_url("platform", "sysinv",
                                                region_name)
        url += "/ihosts/"

        request_info = urlrequest.Request(url)
        request_info.add_header("X-Auth-Token", admin_token.get_id())
        request_info.add_header("Accept", "application/json")

        request = urlrequest.urlopen(request_info)
        response = json.loads(request.read())
        request.close()

        host_list = []
        if personality is None:
            for host in response['ihosts']:
                if host['hostname'] not in exclude_hostnames:
                    host_list.append(Host(host['hostname'], host))
        else:
            for host in response['ihosts']:
                if host['hostname'] not in exclude_hostnames:
                    if (host['personality'] == "controller" and
                            personality == HOST_PERSONALITY_CONTROLLER):
                        host_list.append(Host(host['hostname'], host))

                    elif (host['personality'] == "worker" and
                          personality == HOST_PERSONALITY_WORKER):
                        host_list.append(Host(host['hostname'], host))

                    elif (host['personality'] == "storage" and
                          personality == HOST_PERSONALITY_STORAGE):
                        host_list.append(Host(host['hostname'], host))

        return host_list

    except KeystoneFail as e:
        LOG.error("Keystone authentication failed:{} ".format(e))
        return []

    except HTTPError as e:
        LOG.error("%s, %s" % (e.code, e.read()))
        if e.code == 401:
            admin_token.set_expired()
        return []

    except URLError as e:
        LOG.error(e)
        return []


def dict_to_patch(values, install_action=False):
    # install default action
    if install_action:
        values.update({'action': 'install'})
    patch = []
    for key, value in values.items():
        path = '/' + key
        patch.append({'op': 'replace', 'path': path, 'value': value})
    return patch


def get_shared_services():
    try:
        services = ""
        with openstack.OpenStack() as client:
            systems = client.sysinv.isystem.list()
            if systems:
                services = systems[0].capabilities.get("shared_services", "")
    except Exception as e:
        LOG.exception("failed to get shared services")
        raise e

    return services


def get_alarms():
    """ get all alarms """
    alarm_list = []
    try:
        with openstack.OpenStack() as client:
            alarm_list = client.sysinv.ialarm.list()
    except Exception as e:
        LOG.exception("failed to get alarms")
        raise e
    return alarm_list


def controller_enabled_provisioned(hostname):
    """ check if host is enabled """
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if (hostname == host.name and
                        host.is_controller_enabled_provisioned()):
                    LOG.info("host %s is enabled/provisioned" % host.name)
                    return True
    except Exception as e:
        LOG.exception("failed to check if host is enabled/provisioned")
        raise e
    return False


def get_system_uuid():
    """ get system uuid """
    try:
        sysuuid = ""
        with openstack.OpenStack() as client:
            systems = client.sysinv.isystem.list()
            if systems:
                sysuuid = systems[0].uuid
    except Exception as e:
        LOG.exception("failed to get system uuid")
        raise e
    return sysuuid


def get_oam_ip():
    """ get OAM ip details """
    try:
        with openstack.OpenStack() as client:
            oam_list = client.sysinv.iextoam.list()
            if oam_list:
                return oam_list[0]
    except Exception as e:
        LOG.exception("failed to get OAM IP")
        raise e
    return None


def get_mac_addresses(hostname):
    """ get MAC addresses for the host """
    macs = {}
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    port_list = client.sysinv.ethernet_port.list(host.uuid)
                    macs = {port.name: port.mac for port in port_list}
    except Exception as e:
        LOG.exception("failed to get MAC addresses")
        raise e
    return macs


def get_disk_serial_ids(hostname):
    """ get disk serial ids for the host """
    disk_serial_ids = {}
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    disk_list = client.sysinv.idisk.list(host.uuid)
                    disk_serial_ids = {
                        disk.device_node: disk.serial_id for disk in disk_list}
    except Exception as e:
        LOG.exception("failed to get disks")
        raise e
    return disk_serial_ids


def update_clone_system(descr, hostname):
    """ update system parameters on clone installation """
    try:
        with openstack.OpenStack() as client:
            systems = client.sysinv.isystem.list()
            if not systems:
                return False
            values = {
                'name': "Cloned_system",
                'description': descr
            }
            patch = dict_to_patch(values)
            LOG.info("Updating system: {} [{}]".format(systems[0].name, patch))
            client.sysinv.isystem.update(systems[0].uuid, patch)

            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    values = {
                        'location': {},
                        'serialid': ""
                    }
                    patch = dict_to_patch(values)
                    client.sysinv.ihost.update(host.uuid, patch)
                    LOG.info("Updating host: {} [{}]".format(host, patch))
    except Exception as e:
        LOG.exception("failed to update system parameters")
        raise e
    return True


def get_config_status(hostname):
    """ get config status of the host """
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    return host.config_status
    except Exception as e:
        LOG.exception("failed to get config status")
        raise e
    return None


def get_host_data(hostname):
    """ get data for the specified host """
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    return host
    except Exception as e:
        LOG.exception("failed to get host data")
        raise e
    return None


def do_worker_config_complete(hostname):
    """ enable worker functionality """
    try:
        with openstack.OpenStack() as client:
            hosts = get_hosts(client.admin_token,
                              client.conf['region_name'])
            for host in hosts:
                if hostname == host.name:
                    # Create/apply worker manifests
                    values = {
                        'action': "subfunction_config"
                    }
                    patch = dict_to_patch(values)
                    LOG.info("Applying worker manifests: {} [{}]"
                             .format(host, patch))
                    client.sysinv.ihost.update(host.uuid, patch)
    except Exception as e:
        LOG.exception("worker_config_complete failed")
        raise e


def get_storage_backend_services():
    """ get all storage backends and their assigned services """
    backend_service_dict = {}
    try:
        with openstack.OpenStack() as client:
            backend_list = client.sysinv.storage_backend.list()
            for backend in backend_list:
                backend_service_dict.update(
                    {backend.backend: backend.services})

    except Exception as e:
        LOG.exception("failed to get storage backend services")
        raise e

    return backend_service_dict