#!/usr/bin/env python3
import asyncio
import functools

import logging
import n2vc.vnf
import pylxd
import pytest
import os
import shlex
import shutil
import subprocess
import tempfile
import time
import uuid
import yaml

from juju.controller import Controller

# Disable InsecureRequestWarning w/LXD
import urllib3
urllib3.disable_warnings()
logging.getLogger("urllib3").setLevel(logging.WARNING)

here = os.path.dirname(os.path.realpath(__file__))


def is_bootstrapped():
    result = subprocess.run(['juju', 'switch'], stdout=subprocess.PIPE)
    return (
        result.returncode == 0 and
        len(result.stdout.decode().strip()) > 0)


bootstrapped = pytest.mark.skipif(
    not is_bootstrapped(),
    reason='bootstrapped Juju environment required')


class CleanController():
    """
    Context manager that automatically connects and disconnects from
    the currently active controller.

    Note: Unlike CleanModel, this will not create a new controller for you,
    and an active controller must already be available.
    """
    def __init__(self):
        self._controller = None

    async def __aenter__(self):
        self._controller = Controller()
        await self._controller.connect()
        return self._controller

    async def __aexit__(self, exc_type, exc, tb):
        await self._controller.disconnect()


def get_charm_path():
    return "{}/charms".format(here)


def get_layer_path():
    return "{}/charms/layers".format(here)


def parse_metrics(application, results):
    """Parse the returned metrics into a dict."""

    # We'll receive the results for all units, to look for the one we want
    # Caveat: we're grabbing results from the first unit of the application,
    # which is enough for testing, since we're only deploying a single unit.
    retval = {}
    for unit in results:
        if unit.startswith(application):
            for result in results[unit]:
                retval[result['key']] = result['value']
    return retval


def collect_metrics(application):
    """Invoke Juju's metrics collector.

    Caveat: this shells out to the `juju collect-metrics` command, rather than
    making an API call. At the time of writing, that API is not exposed through
    the client library.
    """

    try:
        subprocess.check_call(['juju', 'collect-metrics', application])
    except subprocess.CalledProcessError as e:
        raise Exception("Unable to collect metrics: {}".format(e))


def has_metrics(charm):
    """Check if a charm has metrics defined."""
    metricsyaml = "{}/{}/metrics.yaml".format(
        get_layer_path(),
        charm,
    )
    if os.path.exists(metricsyaml):
        return True
    return False


def get_descriptor(descriptor):
    desc = None
    try:
        tmp = yaml.load(descriptor)

        # Remove the envelope
        root = list(tmp.keys())[0]
        if root == "nsd:nsd-catalog":
            desc = tmp['nsd:nsd-catalog']['nsd'][0]
        elif root == "vnfd:vnfd-catalog":
            desc = tmp['vnfd:vnfd-catalog']['vnfd'][0]
    except ValueError:
        assert False
    return desc


def get_n2vc(loop=None):
    """Return an instance of N2VC.VNF."""
    log = logging.getLogger()
    log.level = logging.DEBUG

    # Running under tox/pytest makes getting env variables harder.

    # Extract parameters from the environment in order to run our test
    vca_host = os.getenv('VCA_HOST', '127.0.0.1')
    vca_port = os.getenv('VCA_PORT', 17070)
    vca_user = os.getenv('VCA_USER', 'admin')
    vca_charms = os.getenv('VCA_CHARMS', None)
    vca_secret = os.getenv('VCA_SECRET', None)

    client = n2vc.vnf.N2VC(
        log=log,
        server=vca_host,
        port=vca_port,
        user=vca_user,
        secret=vca_secret,
        artifacts=vca_charms,
        loop=loop
    )
    return client


def create_lxd_container(public_key=None, name="test_name"):
    """
    Returns a container object

    If public_key isn't set, we'll use the Juju ssh key

    :param public_key: The public key to inject into the container
    :param name: The name of the test being run
    """
    container = None

    # Format name so it's valid
    name = name.replace("_", "-").replace(".", "")

    client = get_lxd_client()
    test_machine = "test-{}-{}".format(
        uuid.uuid4().hex[-4:],
        name,
    )

    private_key_path, public_key_path = find_juju_ssh_keys()

    # create profile w/cloud-init and juju ssh key
    if not public_key:
        public_key = ""
        with open(public_key_path, "r") as f:
            public_key = f.readline()

    client.profiles.create(
        test_machine,
        config={
            'user.user-data': '#cloud-config\nssh_authorized_keys:\n- {}'.format(public_key)},
        devices={
            'root': {'path': '/', 'pool': 'default', 'type': 'disk'},
            'eth0': {
                'nictype': 'bridged',
                'parent': 'lxdbr0',
                'type': 'nic'
            }
        }
    )

    # create lxc machine
    config = {
        'name': test_machine,
        'source': {
            'type': 'image',
            'alias': 'xenial',
            'mode': 'pull',
            'protocol': 'simplestreams',
            'server': 'https://cloud-images.ubuntu.com/releases',
        },
        'profiles': [test_machine],
    }
    container = client.containers.create(config, wait=True)
    container.start(wait=True)

    def wait_for_network(container, timeout=30):
        """Wait for eth0 to have an ipv4 address."""
        starttime = time.time()
        while(time.time() < starttime + timeout):
            time.sleep(1)
            if 'eth0' in container.state().network:
                addresses = container.state().network['eth0']['addresses']
                if len(addresses) > 0:
                    if addresses[0]['family'] == 'inet':
                        return addresses[0]
        return None

    wait_for_network(container)

    # HACK: We need to give sshd a chance to bind to the interface,
    # and pylxd's container.execute seems to be broken and fails and/or
    # hangs trying to properly check if the service is up.
    time.sleep(5)
    client = None

    return container


def destroy_lxd_container(container):
    """Stop and delete a LXD container."""
    name = container.name
    client = get_lxd_client()

    def wait_for_stop(timeout=30):
        """Wait for eth0 to have an ipv4 address."""
        starttime = time.time()
        while(time.time() < starttime + timeout):
            time.sleep(1)
            if container.state == "Stopped":
                return

    def wait_for_delete(timeout=30):
        starttime = time.time()
        while(time.time() < starttime + timeout):
            time.sleep(1)
            if client.containers.exists(name) is False:
                return

    container.stop(wait=False)
    wait_for_stop()

    container.delete(wait=False)
    wait_for_delete()

    # Delete the profile created for this container
    profile = client.profiles.get(name)
    if profile:
        profile.delete()


def find_lxd_config():
    """Find the LXD configuration directory."""
    paths = []
    paths.append(os.path.expanduser("~/.config/lxc"))
    paths.append(os.path.expanduser("~/snap/lxd/current/.config/lxc"))

    for path in paths:
        if os.path.exists(path):
            crt = os.path.expanduser("{}/client.crt".format(path))
            key = os.path.expanduser("{}/client.key".format(path))
            if os.path.exists(crt) and os.path.exists(key):
                return (crt, key)
    return (None, None)


def find_juju_ssh_keys():
    """Find the Juju ssh keys."""

    paths = []
    paths.append(os.path.expanduser("~/.local/share/juju/ssh/"))

    for path in paths:
        if os.path.exists(path):
            private = os.path.expanduser("{}/juju_id_rsa".format(path))
            public = os.path.expanduser("{}/juju_id_rsa.pub".format(path))
            if os.path.exists(private) and os.path.exists(public):
                return (private, public)
    return (None, None)


def get_juju_private_key():
    keys = find_juju_ssh_keys()
    return keys[0]


def get_lxd_client(host="127.0.0.1", port="8443", verify=False):
    """ Get the LXD client."""
    client = None
    (crt, key) = find_lxd_config()

    if crt and key:
        client = pylxd.Client(
            endpoint="https://{}:{}".format(host, port),
            cert=(crt, key),
            verify=verify,
        )

    return client

# TODO: This is marked serial but can be run in parallel with work, including:
# - Fixing an event loop issue; seems that all tests stop when one test stops?


@pytest.mark.serial
class TestN2VC(object):
    """TODO:
    1. Validator Validation

    Automatically validate the descriptors we're using here, unless the test author explicitly wants to skip them. Useful to make sure tests aren't being run against invalid descriptors, validating functionality that may fail against a properly written descriptor.

    We need to have a flag (instance variable) that controls this behavior. It may be necessary to skip validation and run against a descriptor implementing features that have not yet been released in the Information Model.
    """

    @classmethod
    def setup_class(self):
        """ setup any state specific to the execution of the given class (which
        usually contains tests).
        """
        # Initialize instance variable(s)
        self.container = None

        # Parse the test's descriptors
        self.nsd = get_descriptor(self.NSD_YAML)
        self.vnfd = get_descriptor(self.VNFD_YAML)

        self.ns_name = self.nsd['name']
        self.vnf_name = self.vnfd['name']

        self.charms = {}
        self.parse_vnf_descriptor()
        assert self.charms is not {}

        # Track artifacts, like compiled charms, that will need to be removed
        self.artifacts = {}

        # Build the charm(s) needed for this test
        for charm in self.get_charm_names():
            self.get_charm(charm)

        # A bit of a hack, in order to allow the N2VC callback to run parallel
        # to pytest. Test(s) should wait for this flag to change to False
        # before returning.
        self._running = True

    @classmethod
    def teardown_class(self):
        """ teardown any state that was previously setup with a call to
        setup_class.
        """
        if self.container:
            destroy_lxd_container(self.container)

        # Clean up any artifacts created during the test
        logging.debug("Artifacts: {}".format(self.artifacts))
        for charm in self.artifacts:
            artifact = self.artifacts[charm]
            if os.path.exists(artifact['tmpdir']):
                logging.debug("Removing directory '{}'".format(artifact))
                shutil.rmtree(artifact['tmpdir'])

        # Logout of N2VC
        asyncio.ensure_future(self.n2vc.logout())

    @classmethod
    def running(self, timeout=600):
        """Returns if the test is still running.

        @param timeout The time, in seconds, to wait for the test to complete.
        """

        # if start + now > start > timeout:
        # self.stop_test()
        return self._running

    @classmethod
    def get_charm(self, charm):
        """Build and return the path to the test charm.

        Builds one of the charms in tests/charms/layers and returns the path
        to the compiled charm. The charm will automatically be removed when
        when the test is complete.

        Returns: The path to the built charm or None if `charm build` failed.
        """

        # Make sure the charm snap is installed
        try:
            subprocess.check_call(['which', 'charm'])
        except subprocess.CalledProcessError as e:
            raise Exception("charm snap not installed.")

        if charm not in self.artifacts:
            try:
                # Note: This builds the charm under N2VC/tests/charms/
                # The snap-installed command only has write access to the users $HOME
                # so writing to /tmp isn't possible at the moment.
                builds = tempfile.mkdtemp(dir=get_charm_path())

                cmd = "charm build {}/{} -o {}/".format(
                    get_layer_path(),
                    charm,
                    builds,
                )
                logging.debug(cmd)

                subprocess.check_call(shlex.split(cmd))

                self.artifacts[charm] = {
                    'tmpdir': builds,
                    'charm': "{}/builds/{}".format(builds, charm),
                }
            except subprocess.CalledProcessError as e:
                raise Exception("charm build failed: {}.".format(e))

        return self.artifacts[charm]['charm']

    @classmethod
    async def deploy(self, vnf_index, charm, params, loop):
        """An inner function to do the deployment of a charm from
        either a vdu or vnf.
        """

        self.n2vc = get_n2vc(loop=loop)

        vnf_name = self.n2vc.FormatApplicationName(
            self.ns_name,
            self.vnf_name,
            str(vnf_index),
        )
        logging.debug("Deploying charm at {}".format(self.artifacts[charm]))

        await self.n2vc.DeployCharms(
            self.ns_name,
            vnf_name,
            self.vnfd,
            self.get_charm(charm),
            params,
            {},
            self.n2vc_callback
        )

    @classmethod
    def parse_vnf_descriptor(self):
        """Parse the VNF descriptor to make running tests easier.

        Parse the charm information in the descriptor to make it easy to write
        tests to run again it.

        Each charm becomes a dictionary in a list:
        [
            'is-proxy': True,
            'vnf-member-index': 1,
            'vnf-name': '',
            'charm-name': '',

            'initial-config-primitive': {},
            'config-primitive': {}
        ]
        - charm name
        - is this a proxy charm?
        - what are the initial-config-primitives (day 1)?
        - what are the config primitives (day 2)?

        """
        charms = {}

        # You'd think this would be explicit, but it's just an incremental
        # value that should be consistent.
        vnf_member_index = 0

        """Get all vdu and/or vdu config in a descriptor."""
        config = self.get_config()
        for cfg in config:
            if 'juju' in cfg:

                # Get the name to be used for the deployed application
                application_name = n2vc.vnf.N2VC().FormatApplicationName(
                    self.ns_name,
                    self.vnf_name,
                    str(vnf_member_index),
                )

                charm = {
                    'application-name': application_name,
                    'proxy': True,
                    'vnf-member-index': vnf_member_index,
                    'vnf-name': self.vnf_name,
                    'name': None,
                    'initial-config-primitive': {},
                    'config-primitive': {},
                }

                juju = cfg['juju']
                charm['name'] = juju['charm']

                if 'proxy' in juju:
                    charm['proxy'] = juju['proxy']

                if 'initial-config-primitive' in cfg:
                    charm['initial-config-primitive'] = \
                        cfg['initial-config-primitive']

                if 'config-primitive' in cfg:
                    charm['config-primitive'] = cfg['config-primitive']

                charms[application_name] = charm

            # Increment the vnf-member-index
            vnf_member_index += 1

        self.charms = charms

    @classmethod
    def isproxy(self, application_name):

        assert application_name in self.charms
        assert 'proxy' in self.charms[application_name]
        assert type(self.charms[application_name]['proxy']) is bool

        # logging.debug(self.charms[application_name])
        return self.charms[application_name]['proxy']

    @classmethod
    def get_config(self):
        """Return an iterable list of config items (vdu and vnf).

        As far as N2VC is concerned, the config section for vdu and vnf are
        identical. This joins them together so tests only need to iterate
        through one list.
        """
        configs = []

        """Get all vdu and/or vdu config in a descriptor."""
        vnf_config = self.vnfd.get("vnf-configuration")
        if vnf_config:
            juju = vnf_config['juju']
            if juju:
                configs.append(vnf_config)

        for vdu in self.vnfd['vdu']:
            vdu_config = vdu.get('vdu-configuration')
            if vdu_config:
                juju = vdu_config['juju']
                if juju:
                    configs.append(vdu_config)

        return configs

    @classmethod
    def get_charm_names(self):
        """Return a list of charms used by the test descriptor."""

        charms = {}

        # Check if the VDUs in this VNF have a charm
        for config in self.get_config():
            juju = config['juju']

            name = juju['charm']
            if name not in charms:
                charms[name] = 1

        return charms.keys()

    @classmethod
    async def CreateContainer(self, *args):
        """Create a LXD container for use with a proxy charm.abs

        1. Get the public key from the charm via `get-ssh-public-key` action
        2. Create container with said key injected for the ubuntu user
        """
        if self.container is None:
            # logging.debug("CreateContainer called.")

            # HACK: Set this so the n2vc_callback knows
            # there's a container being created
            self.container = True

            # Create and configure a LXD container for use with a proxy charm.
            (model_name, application_name, _, _) = args

            # Execute 'get-ssh-public-key' primitive and get returned value
            uuid = await self.n2vc.ExecutePrimitive(
                model_name,
                application_name,
                "get-ssh-public-key",
                None,
            )
            # logging.debug("Action UUID: {}".format(uuid))
            result = await self.n2vc.GetPrimitiveOutput(model_name, uuid)
            # logging.debug("Action result: {}".format(result))
            pubkey = result['pubkey']

            self.container = create_lxd_container(
                public_key=pubkey,
                name=os.path.basename(__file__)
            )

        return self.container

    @classmethod
    def get_container_ip(self):
        """Return the IPv4 address of container's eth0 interface."""
        ipaddr = None
        if self.container:
            addresses = self.container.state().network['eth0']['addresses']
            # The interface may have more than one address, but we only need
            # the first one for testing purposes.
            ipaddr = addresses[0]['address']

        return ipaddr

    @classmethod
    def n2vc_callback(self, *args, **kwargs):
        """Monitor and react to changes in the charm state.

        This is where we will monitor the state of the charm:
        - is it active?
        - is it in error?
        - is it waiting on input to continue?

        When the state changes, we respond appropriately:
        - configuring ssh credentials for a proxy charm
        - running a service primitive

        Lastly, when the test has finished we begin the teardown, removing the
        charm and associated LXD container, and notify pytest that this test
        is over.

        Args are expected to contain four values, received from N2VC:
        - str, the name of the model
        - str, the name of the application
        - str, the workload status as reported by Juju
        - str, the workload message as reported by Juju
        """
        (model, application, status, message) = args
        # logging.debug("Callback for {}/{} - {} ({})".format(
        #     model,
        #     application,
        #     status,
        #     message
        # ))

        # Make sure we're only receiving valid status. This will catch charms
        # that aren't setting their workload state and appear as "unknown"
        # assert status not in ["active", "blocked", "waiting", "maintenance"]

        task = None
        if kwargs and 'task' in kwargs:
            task = kwargs['task']
            # logging.debug("Got task: {}".format(task))

        # Closures and inner functions, oh my.
        def is_active():
            """Is the charm in an active state?"""
            if status in ["active"]:
                return True
            return False

        def is_blocked():
            """Is the charm waiting for us?"""
            if status in ["blocked"]:
                return True
            return False

        def configure_ssh_proxy(task):
            """Configure the proxy charm to use the lxd container."""
            logging.debug("configure_ssh_proxy({})".format(task))

            mgmtaddr = self.get_container_ip()

            logging.debug(
                "Setting config ssh-hostname={}".format(mgmtaddr)
            )

            task = asyncio.ensure_future(
                self.n2vc.ExecutePrimitive(
                    model,
                    application,
                    "config",
                    None,
                    params={
                        'ssh-hostname': mgmtaddr,
                        'ssh-username': 'ubuntu',
                    }
                )
            )

            # Execute the VNFD's 'initial-config-primitive'
            task.add_done_callback(functools.partial(
                execute_initial_config_primitives,
            ))

        def execute_initial_config_primitives(task=None):
            logging.debug("execute_initial_config_primitives({})".format(task))

            init_config = self.charms[application]

            """
            The initial-config-primitive is run during deploy but may fail
             on some steps because proxy charm access isn't configured.

            At this stage, we'll re-run those actions.
            """

            task = asyncio.ensure_future(
                self.n2vc.ExecuteInitialPrimitives(
                    model,
                    application,
                    init_config,
                )
            )

            """
            ExecutePrimitives will return a list of uuids. We need to check the
             status of each. The test continues if all Actions succeed, and
             fails if any of them fail.
            """
            task.add_done_callback(functools.partial(wait_for_uuids))

        def check_metrics():
            task = asyncio.ensure_future(
                self.n2vc.GetMetrics(
                    model,
                    application,
                )
            )

            task.add_done_callback(
                functools.partial(
                    verify_metrics,
                )
            )

        def verify_metrics(task):
            logging.debug("Verifying metrics!")
            # Check if task returned metrics
            results = task.result()

            metrics = parse_metrics(application, results)
            logging.debug(metrics)

            if len(metrics):
                task = asyncio.ensure_future(
                    self.n2vc.RemoveCharms(model, application)
                )

                task.add_done_callback(functools.partial(stop_test))

            else:
                # TODO: Ran into a case where it took 9 attempts before metrics
                # were available; the controller is slow sometimes.
                time.sleep(60)
                check_metrics()

        def wait_for_uuids(task):
            logging.debug("wait_for_uuids({})".format(task))
            uuids = task.result()

            waitfor = len(uuids)
            finished = 0

            def get_primitive_result(uuid, task):
                logging.debug("Got result from action")
                # completed, failed, or running
                result = task.result()

                if status in result and result['status'] \
                   in ["completed", "failed"]:

                    # It's over
                    logging.debug("Action {} is {}".format(
                        uuid,
                        task.result['status'])
                    )
                    pass
                else:
                    logging.debug("action is still running")

            def get_primitive_status(uuid, task):
                result = task.result()

                if result == "completed":
                    # Make sure all primitives are finished
                    global finished
                    finished += 1

                    if waitfor == finished:
                        # logging.debug("Action complete; removing charm")
                        task = asyncio.ensure_future(
                            self.n2vc.RemoveCharms(model, application)
                        )

                        task.add_done_callback(functools.partial(stop_test))
                elif result == "failed":
                    # logging.debug("Action failed; removing charm")
                    assert False
                    self._running = False
                    return
                else:
                    # logging.debug("action is still running: {}".format(result))
                    # logging.debug(result)
                    # pass
                    # The primitive is running; try again.
                    task = asyncio.ensure_future(
                        self.n2vc.GetPrimitiveStatus(model, uuid)
                    )
                    task.add_done_callback(functools.partial(
                        get_primitive_result,
                        uuid,
                    ))

            for actionid in uuids:
                task = asyncio.ensure_future(
                    self.n2vc.GetPrimitiveStatus(model, actionid)
                )
                task.add_done_callback(functools.partial(
                    get_primitive_result,
                    actionid,
                ))

        def stop_test(task):
            """Stop the test.

            When the test has either succeeded or reached a failing state,
            begin the process of removing the test fixtures.
            """
            asyncio.ensure_future(
                self.n2vc.RemoveCharms(model, application)
            )

            self._running = False

        if is_blocked():
            # logging.debug("Charm is in a blocked state!")

            # Container only applies to proxy charms.
            if self.isproxy(application):

                if self.container is None:
                    # logging.debug(
                    #     "Ensuring CreateContainer: status is {}".format(status)
                    # )

                    # Create the new LXD container
                    task = asyncio.ensure_future(self.CreateContainer(*args))

                    # Configure the proxy charm to use the container when ready
                    task.add_done_callback(functools.partial(
                        configure_ssh_proxy,
                    ))

                    # task.add_done_callback(functools.partial(
                    #     stop_test,
                    # ))
                    # create_lxd_container()
                    # self.container = True
            else:
                # A charm may validly be in a blocked state if it's waiting for
                # relations or some other kind of manual intervention
                # logging.debug("This is not a proxy charm.")
                # TODO: needs testing
                task = asyncio.ensure_future(
                    execute_initial_config_primitives()
                )

                task.add_done_callback(functools.partial(stop_test))

        elif is_active():
            # Does the charm have metrics defined?
            if has_metrics(self.charms[application]['name']):
                # logging.debug("metrics.yaml defined in the layer!")

                # Force a run of the metric collector, so we don't have
                # to wait for it's normal 5 minute interval run.
                # NOTE: this shouldn't be done outside of CI
                collect_metrics(application)

                # get the current metrics
                check_metrics()
            else:
                # When the charm reaches an active state and hasn't been
                # handled (metrics collection, etc)., the test has succeded.
                # logging.debug("Charm is active! Removing charm...")
                task = asyncio.ensure_future(
                    self.n2vc.RemoveCharms(model, application)
                )

                task.add_done_callback(functools.partial(stop_test))