# Copyright 2019 Nokia
#
# Licensed 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 logging
import six
from crl.remotesession.remotesession import RemoteSession
from crl.interactivesessions.shells.bashshell import BashShell
from hostcli import HostCli
from .envcreator import EnvCreator
from .usermanager import UserManager
from .metasingleton import MetaSingleton
from .hosts import (
    MgmtTarget,
    Master,
    NonMaster,
    Profiles,
    HostConfig)


LOGGER = logging.getLogger(__name__)


class ClusterError(Exception):
    pass


@six.add_metaclass(MetaSingleton)
class Cluster(object):
    """Singleton container for NCIR cluster hosts, their service profiles and
    access details.
    """
    def __init__(self):
        self._mgmt_target = None
        self._hosts = None
        self._configprops_cache = None
        self._usermanager = UserManager(hostcli_factory=self.create_hostcli)
        self._envcreator = EnvCreator(remotesession_factory=self.create_remotesession,
                                      usermanager=self._usermanager)

    def clear_cache(self):
        """Clears configprops cache."""
        self._configprops_cache = None

    def get_hosts(self):
        """Return Host containers of cluster.
        """
        return [h for _, h in self._hosts.items()]

    def initialize(self, host, user, password):
        """Initialize Cluster with management VIP

        Arguments:
            host:  Management VIP IP address
            user: Login username
            password: password for the user
        """
        self._mgmt_target = MgmtTarget(host=host, user=user, password=password)
        self._hosts = {hc.name: self._create_host(hc) for hc in self._host_configs()}

    @staticmethod
    def set_profiles(master, worker):
        """Set *service_profile' names of *master* and *worker* nodes
        """
        Profiles.set_profiles(master=master, worker=worker)

    def get_mgmt_shelldicts(self):
        """Return management VIP shelldicts for RemoteRunner.
        """
        return [self._mgmt_target.asdict()]

    def get_host(self, hostname):
        """Get Host container for hostname."""
        return self._hosts[hostname]

    def get_hosts_with_profiles(self, *service_profiles):
        """Get host names matching exactly *service_profiles*.
        """
        return sorted(list(self._get_hosts_with_profs_gen(set(service_profiles))))

    def get_hosts_containing(self, *service_profiles):
        """Get host names containing all  *service_profiles*.
        """
        return sorted(list(self._get_hosts_containing_gen(set(service_profiles))))

    def create_remotesession(self):
        """Create initialized *RemoteSession* instance.
        """
        r = RemoteSession()
        self.initialize_remotesession(r)
        return r

    def initialize_remotesession(self, remotesession):
        """Initialize :class:`crl.remotesession.remotesession.RemoteSession` instance
        with *shelldicts* and *name* of the hosts and sudo-<name> via *set_runner_target*.
        Initialize *default* target with *get_mgmt_shelldicts* return value.
        The sudo-<name> targets are terminals in target after executed roughly *sudo bash*.
        """
        self._set_mgmt_targets(remotesession)
        for host in self.get_hosts():
            remotesession.set_runner_target(shelldicts=host.shelldicts,
                                            name=host.name)
            remotesession.set_runner_target(
                shelldicts=self._get_sudoshelldicts(host.shelldicts),
                name='sudo-{}'.format(host.name))

        remotesession.set_envcreator(self._envcreator)

    def _set_mgmt_targets(self, remotesession):
        remotesession.set_runner_target(self.get_mgmt_shelldicts())
        remotesession.set_runner_target(
            shelldicts=self._get_sudoshelldicts(self.get_mgmt_shelldicts()),
            name='sudo-default')
        remotesession.set_target(host=self._mgmt_target.host,
                                 username=self._mgmt_target.user,
                                 password=self._mgmt_target.password,
                                 name='remotescript-default')

    @staticmethod
    def _get_sudoshelldicts(shelldicts):
        return shelldicts + [{'shellname': BashShell.__name__,
                              'cmd': 'sudo bash'}]

    def create_hostcli(self):
        """Create initialized *HostCli* instance.
        """
        n = HostCli()
        self.initialize_hostcli(n)
        return n

    def initialize_hostcli(self, hostcli):
        """Initialize :class:`crl.hostcli.HostCli` instance
        (or :class:`crl.hostcli.OpenStack`) with
        :class:`crl.remotesession.remotesession.RemoteSession` instance
        initialized with :meth:`.initialize_remotesession`.
        """
        hostcli.initialize(self.create_remotesession())

    def create_user_with_roles(self, *roles):
        """Create according to roles list.

        Special roles:

            all_roles: all roles in the system
            no_roles: empty role list

        Return:
            UserRecord of created user
        """
        return self._usermanager.create_user_with_roles(*roles)

    def delete_users(self):
        """Delete all users created by *Cluster*.
        """
        self._usermanager.delete_users()

    def is_dpdk(self):
        """Return *True* if *dpdk* is used in provider network interfaces.
        More detail, *True* if and only if there is at least one host with
        network profile providing *ovs-dpdk* type interface.
        """
        for _, h in self._hosts.items():
            if h.is_dpdk:
                return True
        return False

    def get_hosts_with_dpdk(self):
        """Returns list of hosts where *dpdk* is in use.
           In more detail, return sorted list of host names in which there is
           at least one network profile containing *dpdk* type interface.
        """
        return sorted([h.name for _, h in self._hosts.items() if h.is_dpdk])

    def _get_hosts_with_profs_gen(self, service_profiles):
        def filt(host):
            mask = Profiles().profiles_mask
            return not (service_profiles ^ set(host.service_profiles)) & mask

        return self._filtered_hostnames(filt)

    def _get_hosts_containing_gen(self, service_profiles):
        def filt(host):
            return service_profiles.issubset(set(host.service_profiles))

        return self._filtered_hostnames(filt)

    def _filtered_hostnames(self, filt):
        for h in self.get_hosts():
            if filt(h):
                yield h.name

    @staticmethod
    def _create_host(host_config):
        LOGGER.debug('host_config: %s', host_config)
        master = Profiles().master
        return (Master(host_config)
                if master in host_config.service_profiles else
                NonMaster(host_config))

    def _host_configs(self):
        LOGGER.debug('cloud_hosts: %s', self._cloud_hosts)
        for hostname, v in self._cloud_hosts.items():
            yield HostConfig(name=hostname,
                             network_domain=v['network_domain'],
                             service_profiles=v['service_profiles'],
                             networking=self._get_networking(hostname),
                             mgmt_target=self._mgmt_target,
                             is_dpdk=self._is_host_dpdk(v))

    def _is_host_dpdk(self, host_prop):
        network_profiles = set(host_prop['network_profiles'])
        return bool(network_profiles.intersection(set(self._dpdk_profiles())))

    def _dpdk_profiles(self):
        profiles = self._get_value_for_prop('cloud.network_profiles')
        for prof_n, prof_v in profiles.items():
            ifaces = prof_v.get('provider_network_interfaces', {})
            for _, iface_v in ifaces.items():
                if iface_v['type'] == 'ovs-dpdk':
                    yield prof_n

    @property
    def _cloud_hosts(self):
        return self._get_value_for_prop('cloud.hosts')

    def _get_networking(self, hostname):
        return self._get_value_for_prop('{}.networking'.format(hostname))

    def _get_value_for_prop(self, prop):
        for pv in self._configprops:
            if pv['property'] == prop:
                return pv['value']
        raise ClusterError('Property not found: {}'.format(prop))

    @property
    def _configprops(self):
        if self._configprops_cache is None:
            self._setup_configprops_cache()
        return self._configprops_cache

    def _setup_configprops_cache(self):
        s = RemoteSession()
        s.set_runner_target(self.get_mgmt_shelldicts())
        n = HostCli()
        n.initialize(s)
        self._configprops_cache = n.run('config-manager list properties')