##############################################################################
# Copyright (c) 2018 Sawyer Bergeron, Parker Berberian, and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################


from django.contrib.auth.models import User
from django.db import models
from django.core.exceptions import PermissionDenied, ValidationError
from django.shortcuts import get_object_or_404
from django.contrib.postgres.fields import JSONField
from django.http import HttpResponseNotFound
from django.urls import reverse
from django.utils import timezone

import json
import uuid
import yaml
import re

from booking.models import Booking
from resource_inventory.models import (
    Lab,
    ResourceProfile,
    Image,
    Opsys,
    Interface,
    ResourceOPNFVConfig,
    RemoteInfo,
    OPNFVConfig,
    ConfigState,
    ResourceQuery,
    ResourceConfiguration,
    CloudInitFile
)
from resource_inventory.idf_templater import IDFTemplater
from resource_inventory.pdf_templater import PDFTemplater
from account.models import Downtime, UserProfile
from dashboard.utils import AbstractModelQuery


class JobStatus:
    """
    A poor man's enum for a job's status.

    A job is NEW if it has not been started or recognized by the Lab
    A job is CURRENT if it has been started by the lab but it is not yet completed
    a job is DONE if all the tasks are complete and the booking is ready to use
    """

    NEW = 0
    CURRENT = 100
    DONE = 200
    ERROR = 300


class LabManagerTracker:

    @classmethod
    def get(cls, lab_name, token):
        """
        Get a LabManager.

        Takes in a lab name (from a url path)
        returns a lab manager instance for that lab, if it exists
        Also checks that the given API token is correct
        """
        try:
            lab = Lab.objects.get(name=lab_name)
        except Exception:
            raise PermissionDenied("Lab not found")
        if lab.api_token == token:
            return LabManager(lab)
        raise PermissionDenied("Lab not authorized")


class LabManager:
    """
    Handles all lab REST calls.

    handles jobs, inventory, status, etc
    may need to create helper classes
    """

    def __init__(self, lab):
        self.lab = lab

    def get_opsyss(self):
        return Opsys.objects.filter(from_lab=self.lab)

    def get_images(self):
        return Image.objects.filter(from_lab=self.lab)

    def get_image(self, image_id):
        return Image.objects.filter(from_lab=self.lab, lab_id=image_id)

    def get_opsys(self, opsys_id):
        return Opsys.objects.filter(from_lab=self.lab, lab_id=opsys_id)

    def get_downtime(self):
        return Downtime.objects.filter(start__lt=timezone.now(), end__gt=timezone.now(), lab=self.lab)

    def get_downtime_json(self):
        downtime = self.get_downtime().first()  # should only be one item in queryset
        if downtime:
            return {
                "is_down": True,
                "start": downtime.start,
                "end": downtime.end,
                "description": downtime.description
            }
        return {"is_down": False}

    def create_downtime(self, form):
        """
        Create a downtime event.

        Takes in a dictionary that describes the model.
        {
          "start": utc timestamp
          "end": utc timestamp
          "description": human text (optional)
        }
        For timestamp structure, https://docs.djangoproject.com/en/2.2/ref/forms/fields/#datetimefield
        """
        Downtime.objects.create(
            start=form.cleaned_data['start'],
            end=form.cleaned_data['end'],
            description=form.cleaned_data['description'],
            lab=self.lab
        )
        return self.get_downtime_json()

    def update_host_remote_info(self, data, res_id):
        resource = ResourceQuery.filter(labid=res_id, lab=self.lab)
        if len(resource) != 1:
            return HttpResponseNotFound("Could not find single host with id " + str(res_id))
        resource = resource[0]
        info = {}
        try:
            info['address'] = data['address']
            info['mac_address'] = data['mac_address']
            info['password'] = data['password']
            info['user'] = data['user']
            info['type'] = data['type']
            info['versions'] = json.dumps(data['versions'])
        except Exception as e:
            return {"error": "invalid arguement: " + str(e)}
        remote_info = resource.remote_management
        if "default" in remote_info.mac_address:
            remote_info = RemoteInfo()
        remote_info.address = info['address']
        remote_info.mac_address = info['mac_address']
        remote_info.password = info['password']
        remote_info.user = info['user']
        remote_info.type = info['type']
        remote_info.versions = info['versions']
        remote_info.save()
        resource.remote_management = remote_info
        resource.save()
        booking = Booking.objects.get(resource=resource.bundle)
        self.update_xdf(booking)
        return {"status": "success"}

    def update_xdf(self, booking):
        booking.pdf = PDFTemplater.makePDF(booking)
        booking.idf = IDFTemplater().makeIDF(booking)
        booking.save()

    def get_pdf(self, booking_id):
        booking = get_object_or_404(Booking, pk=booking_id, lab=self.lab)
        return booking.pdf

    def get_idf(self, booking_id):
        booking = get_object_or_404(Booking, pk=booking_id, lab=self.lab)
        return booking.idf

    def get_profile(self):
        prof = {}
        prof['name'] = self.lab.name
        prof['contact'] = {
            "phone": self.lab.contact_phone,
            "email": self.lab.contact_email
        }
        prof['host_count'] = [{
            "type": profile.name,
            "count": len(profile.get_resources(lab=self.lab))}
            for profile in ResourceProfile.objects.filter(labs=self.lab)]
        return prof

    def format_user(self, userprofile):
        return {
            "id": userprofile.user.id,
            "username": userprofile.user.username,
            "email": userprofile.email_addr,
            "first_name": userprofile.user.first_name,
            "last_name": userprofile.user.last_name,
            "company": userprofile.company
        }

    def get_users(self):
        userlist = [self.format_user(profile) for profile in UserProfile.objects.select_related("user").all()]

        return json.dumps({"users": userlist})

    def get_user(self, user_id):
        user = User.objects.get(pk=user_id)

        profile = get_object_or_404(UserProfile, user=user)

        return json.dumps(self.format_user(profile))

    def get_inventory(self):
        inventory = {}
        resources = ResourceQuery.filter(lab=self.lab)
        images = Image.objects.filter(from_lab=self.lab)
        profiles = ResourceProfile.objects.filter(labs=self.lab)
        inventory['resources'] = self.serialize_resources(resources)
        inventory['images'] = self.serialize_images(images)
        inventory['host_types'] = self.serialize_host_profiles(profiles)
        return inventory

    def get_host(self, hostname):
        resource = ResourceQuery.filter(labid=hostname, lab=self.lab)
        if len(resource) != 1:
            return HttpResponseNotFound("Could not find single host with id " + str(hostname))
        resource = resource[0]
        return {
            "booked": resource.booked,
            "working": resource.working,
            "type": resource.profile.name
        }

    def update_host(self, hostname, data):
        resource = ResourceQuery.filter(labid=hostname, lab=self.lab)
        if len(resource) != 1:
            return HttpResponseNotFound("Could not find single host with id " + str(hostname))
        resource = resource[0]
        if "working" in data:
            working = data['working'] == "true"
            resource.working = working
        resource.save()
        return self.get_host(hostname)

    def get_status(self):
        return {"status": self.lab.status}

    def set_status(self, payload):
        {}

    def get_current_jobs(self):
        jobs = Job.objects.filter(booking__lab=self.lab)

        return self.serialize_jobs(jobs, status=JobStatus.CURRENT)

    def get_new_jobs(self):
        jobs = Job.objects.filter(booking__lab=self.lab)

        return self.serialize_jobs(jobs, status=JobStatus.NEW)

    def get_done_jobs(self):
        jobs = Job.objects.filter(booking__lab=self.lab)

        return self.serialize_jobs(jobs, status=JobStatus.DONE)

    def get_analytics_job(self):
        """ Get analytics job with status new """
        jobs = Job.objects.filter(
            booking__lab=self.lab,
            job_type='DATA'
        )

        return self.serialize_jobs(jobs, status=JobStatus.NEW)

    def get_job(self, jobid):
        return Job.objects.get(pk=jobid).to_dict()

    def update_job(self, jobid, data):
        {}

    def serialize_jobs(self, jobs, status=JobStatus.NEW):
        job_ser = []
        for job in jobs:
            jsonized_job = job.get_delta(status)
            if len(jsonized_job['payload']) < 1:
                continue
            job_ser.append(jsonized_job)

        return job_ser

    def serialize_resources(self, resources):
        # TODO: rewrite for Resource model
        host_ser = []
        for res in resources:
            r = {
                'interfaces': [],
                'hostname': res.name,
                'host_type': res.profile.name
            }
            for iface in res.get_interfaces():
                r['interfaces'].append({
                    'mac': iface.mac_address,
                    'busaddr': iface.bus_address,
                    'name': iface.name,
                    'switchport': {"switch_name": iface.switch_name, "port_name": iface.port_name}
                })
        return host_ser

    def serialize_images(self, images):
        images_ser = []
        for image in images:
            images_ser.append(
                {
                    "name": image.name,
                    "lab_id": image.lab_id,
                    "dashboard_id": image.id
                }
            )
        return images_ser

    def serialize_resource_profiles(self, profiles):
        profile_ser = []
        for profile in profiles:
            p = {}
            p['cpu'] = {
                "cores": profile.cpuprofile.first().cores,
                "arch": profile.cpuprofile.first().architecture,
                "cpus": profile.cpuprofile.first().cpus,
            }
            p['disks'] = []
            for disk in profile.storageprofile.all():
                d = {
                    "size": disk.size,
                    "type": disk.media_type,
                    "name": disk.name
                }
                p['disks'].append(d)
            p['description'] = profile.description
            p['interfaces'] = []
            for iface in profile.interfaceprofile.all():
                p['interfaces'].append(
                    {
                        "speed": iface.speed,
                        "name": iface.name
                    }
                )

            p['ram'] = {"amount": profile.ramprofile.first().amount}
            p['name'] = profile.name
            profile_ser.append(p)
        return profile_ser


class GeneratedCloudConfig(models.Model):
    resource_id = models.CharField(max_length=200)
    booking = models.ForeignKey(Booking, on_delete=models.CASCADE)
    rconfig = models.ForeignKey(ResourceConfiguration, on_delete=models.CASCADE)
    text = models.TextField(null=True, blank=True)

    def _normalize_username(self, username: str) -> str:
        # TODO: make usernames posix compliant
        s = re.sub(r'\W+', '', username)
        return s

    def _get_ssh_string(self, username: str) -> str:
        user = User.objects.get(username=username)
        uprofile = user.userprofile

        ssh_file = uprofile.ssh_public_key

        escaped_file = ssh_file.open().read().decode(encoding="UTF-8").replace("\n", " ")

        return escaped_file

    def _serialize_users(self):
        """
        returns the dictionary to be placed behind the `users` field of the toplevel c-i dict
        """
        # conserves distro default user
        user_array = ["default"]

        users = list(self.booking.collaborators.all())
        users.append(self.booking.owner)
        for collaborator in users:
            userdict = {}

            # TODO: validate if usernames are valid as linux usernames (and provide an override potentially)
            userdict['name'] = self._normalize_username(collaborator.username)

            userdict['groups'] = "sudo"
            userdict['sudo'] = "ALL=(ALL) NOPASSWD:ALL"

            userdict['ssh_authorized_keys'] = [self._get_ssh_string(collaborator.username)]

            user_array.append(userdict)

        # user_array.append({
        #    "name": "opnfv",
        #    "passwd": "$6$k54L.vim1cLaEc4$5AyUIrufGlbtVBzuCWOlA1yV6QdD7Gr2MzwIs/WhuYR9ebSfh3Qlb7djkqzjwjxpnSAonK1YOabPP6NxUDccu.",
        #    "ssh_redirect_user": True,
        #    "sudo": "ALL=(ALL) NOPASSWD:ALL",
        #    "groups": "sudo",
        #    })

        return user_array

    # TODO: make this configurable
    def _serialize_sysinfo(self):
        defuser = {}
        defuser['name'] = 'opnfv'
        defuser['plain_text_passwd'] = 'OPNFV_HOST'
        defuser['home'] = '/home/opnfv'
        defuser['shell'] = '/bin/bash'
        defuser['lock_passwd'] = True
        defuser['gecos'] = 'Lab Manager User'
        defuser['groups'] = 'sudo'

        return {'default_user': defuser}

    # TODO: make this configurable
    def _serialize_runcmds(self):
        cmdlist = []

        # have hosts run dhcp on boot
        cmdlist.append(['sudo', 'dhclient', '-r'])
        cmdlist.append(['sudo', 'dhclient'])

        return cmdlist

    def _serialize_netconf_v1(self):
        # interfaces = {}  # map from iface_name => dhcp_config
        # vlans = {}  # map from vlan_id => dhcp_config

        config_arr = []

        for interface in self._resource().interfaces.all():
            interface_name = interface.profile.name
            interface_mac = interface.mac_address

            iface_dict_entry = {
                "type": "physical",
                "name": interface_name,
                "mac_address": interface_mac,
            }

            for vlan in interface.config.all():
                if vlan.tagged:
                    vlan_dict_entry = {'type': 'vlan'}
                    vlan_dict_entry['name'] = str(interface_name) + "." + str(vlan.vlan_id)
                    vlan_dict_entry['vlan_link'] = str(interface_name)
                    vlan_dict_entry['vlan_id'] = int(vlan.vlan_id)
                    vlan_dict_entry['mac_address'] = str(interface_mac)
                    if vlan.public:
                        vlan_dict_entry["subnets"] = [{"type": "dhcp"}]
                    config_arr.append(vlan_dict_entry)
                if (not vlan.tagged) and vlan.public:
                    iface_dict_entry["subnets"] = [{"type": "dhcp"}]

                # vlan_dict_entry['mtu'] = # TODO, determine override MTU if needed

            config_arr.append(iface_dict_entry)

        ns_dict = {
            'type': 'nameserver',
            'address': ['10.64.0.1', '8.8.8.8']
        }

        config_arr.append(ns_dict)

        full_dict = {'version': 1, 'config': config_arr}

        return full_dict

    @classmethod
    def get(cls, booking_id: int, resource_lab_id: str, file_id: int):
        return GeneratedCloudConfig.objects.get(resource_id=resource_lab_id, booking__id=booking_id, file_id=file_id)

    def _resource(self):
        return ResourceQuery.get(labid=self.resource_id, lab=self.booking.lab)

    # def _get_facts(self):
        # resource = self._resource()

        # hostname = self.rconfig.name
        # iface_configs = for_config.interface_configs.all()

    def _to_dict(self):
        main_dict = {}

        main_dict['users'] = self._serialize_users()
        main_dict['network'] = self._serialize_netconf_v1()
        main_dict['hostname'] = self.rconfig.name

        # add first startup commands
        main_dict['runcmd'] = self._serialize_runcmds()

        # configure distro default user
        main_dict['system_info'] = self._serialize_sysinfo()

        return main_dict

    def serialize(self) -> str:
        return yaml.dump(self._to_dict(), width=float("inf"))


class APILog(models.Model):
    user = models.ForeignKey(User, on_delete=models.PROTECT)
    call_time = models.DateTimeField(auto_now=True)
    method = models.CharField(null=True, max_length=6)
    endpoint = models.CharField(null=True, max_length=300)
    ip_addr = models.GenericIPAddressField(protocol="both", null=True, unpack_ipv4=False)
    body = JSONField(null=True)

    def __str__(self):
        return "Call to {} at {} by {}".format(
            self.endpoint,
            self.call_time,
            self.user.username
        )


class AutomationAPIManager:
    @staticmethod
    def serialize_booking(booking):
        sbook = {}
        sbook['id'] = booking.pk
        sbook['owner'] = booking.owner.username
        sbook['collaborators'] = [user.username for user in booking.collaborators.all()]
        sbook['start'] = booking.start
        sbook['end'] = booking.end
        sbook['lab'] = AutomationAPIManager.serialize_lab(booking.lab)
        sbook['purpose'] = booking.purpose
        sbook['resourceBundle'] = AutomationAPIManager.serialize_bundle(booking.resource)
        return sbook

    @staticmethod
    def serialize_lab(lab):
        slab = {}
        slab['id'] = lab.pk
        slab['name'] = lab.name
        return slab

    @staticmethod
    def serialize_bundle(bundle):
        sbundle = {}
        sbundle['id'] = bundle.pk
        sbundle['resources'] = [
            AutomationAPIManager.serialize_server(server)
            for server in bundle.get_resources()]
        return sbundle

    @staticmethod
    def serialize_server(server):
        sserver = {}
        sserver['id'] = server.pk
        sserver['name'] = server.name
        return sserver

    @staticmethod
    def serialize_resource_profile(profile):
        sprofile = {}
        sprofile['id'] = profile.pk
        sprofile['name'] = profile.name
        return sprofile

    @staticmethod
    def serialize_template(rec_temp_and_count):
        template = rec_temp_and_count[0]
        count = rec_temp_and_count[1]

        stemplate = {}
        stemplate['id'] = template.pk
        stemplate['name'] = template.name
        stemplate['count_available'] = count
        stemplate['resourceProfiles'] = [
            AutomationAPIManager.serialize_resource_profile(config.profile)
            for config in template.getConfigs()
        ]
        return stemplate

    @staticmethod
    def serialize_image(image):
        simage = {}
        simage['id'] = image.pk
        simage['name'] = image.name
        return simage

    @staticmethod
    def serialize_userprofile(up):
        sup = {}
        sup['id'] = up.pk
        sup['username'] = up.user.username
        return sup


class Job(models.Model):
    """
    A Job to be performed by the Lab.

    The API uses Jobs and Tasks to communicate actions that need to be taken to the Lab
    that is hosting a booking. A booking from a user has an associated Job which tells
    the lab how to configure the hardware, networking, etc to fulfill the booking
    for the user.
    This is the class that is serialized and put into the api
    """

    JOB_TYPES = (
        ('BOOK', 'Booking'),
        ('DATA', 'Analytics')
    )

    booking = models.OneToOneField(Booking, on_delete=models.CASCADE, null=True)
    status = models.IntegerField(default=JobStatus.NEW)
    complete = models.BooleanField(default=False)
    job_type = models.CharField(
        max_length=4,
        choices=JOB_TYPES,
        default='BOOK'
    )

    def to_dict(self):
        d = {}
        for relation in self.get_tasklist():
            if relation.job_key not in d:
                d[relation.job_key] = {}
            d[relation.job_key][relation.task_id] = relation.config.to_dict()

        return {"id": self.id, "payload": d}

    def get_tasklist(self, status="all"):
        if status != "all":
            return JobTaskQuery.filter(job=self, status=status)
        return JobTaskQuery.filter(job=self)

    def is_fulfilled(self):
        """
        If a job has been completed by the lab.

        This method should return true if all of the job's tasks are done,
        and false otherwise
        """
        my_tasks = self.get_tasklist()
        for task in my_tasks:
            if task.status != JobStatus.DONE:
                return False
        return True

    def get_delta(self, status):
        d = {}
        for relation in self.get_tasklist(status=status):
            if relation.job_key not in d:
                d[relation.job_key] = {}
            d[relation.job_key][relation.task_id] = relation.config.get_delta()

        return {"id": self.id, "payload": d}

    def to_json(self):
        return json.dumps(self.to_dict())


class TaskConfig(models.Model):
    state = models.IntegerField(default=ConfigState.NEW)

    keys = set()  # TODO: This needs to be an instance variable, not a class variable
    delta_keys_list = models.CharField(max_length=200, default="[]")

    @property
    def delta_keys(self):
        return list(set(json.loads(self.delta_keys_list)))

    @delta_keys.setter
    def delta_keys(self, keylist):
        self.delta_keys_list = json.dumps(keylist)

    def to_dict(self):
        raise NotImplementedError

    def get_delta(self):
        raise NotImplementedError

    def format_delta(self, config, token):
        delta = {k: config[k] for k in self.delta_keys}
        delta['lab_token'] = token
        return delta

    def to_json(self):
        return json.dumps(self.to_dict())

    def clear_delta(self):
        self.delta_keys = []

    def set(self, *args):
        dkeys = self.delta_keys
        for arg in args:
            if arg in self.keys:
                dkeys.append(arg)
        self.delta_keys = dkeys


class BridgeConfig(models.Model):
    """Displays mapping between jumphost interfaces and bridges."""

    interfaces = models.ManyToManyField(Interface)
    opnfv_config = models.ForeignKey(OPNFVConfig, on_delete=models.CASCADE)

    def to_dict(self):
        d = {}
        hid = ResourceQuery.get(interface__pk=self.interfaces.first().pk).labid
        d[hid] = {}
        for interface in self.interfaces.all():
            d[hid][interface.mac_address] = []
            for vlan in interface.config.all():
                network_role = self.opnfv_model.networks().filter(network=vlan.network)
                bridge = IDFTemplater.bridge_names[network_role.name]
                br_config = {
                    "vlan_id": vlan.vlan_id,
                    "tagged": vlan.tagged,
                    "bridge": bridge
                }
                d[hid][interface.mac_address].append(br_config)
        return d

    def to_json(self):
        return json.dumps(self.to_dict())


class ActiveUsersConfig(models.Model):
    """
    Task for getting active VPN users

    StackStorm needs no information to run this job
    so this task is very bare, but neccessary to fit
    job creation convention.
    """

    def clear_delta(self):
        self.delta = '{}'

    def get_delta(self):
        return json.loads(self.to_json())

    def to_json(self):
        return json.dumps(self.to_dict())

    def to_dict(self):
        return {}


class OpnfvApiConfig(models.Model):

    installer = models.CharField(max_length=200)
    scenario = models.CharField(max_length=300)
    roles = models.ManyToManyField(ResourceOPNFVConfig)
    # pdf and idf are url endpoints, not the actual file
    pdf = models.CharField(max_length=100)
    idf = models.CharField(max_length=100)
    bridge_config = models.OneToOneField(BridgeConfig, on_delete=models.CASCADE, null=True)
    delta = models.TextField()
    opnfv_config = models.ForeignKey(OPNFVConfig, null=True, on_delete=models.SET_NULL)

    def to_dict(self):
        d = {}
        if not self.opnfv_config:
            return d
        if self.installer:
            d['installer'] = self.installer
        if self.scenario:
            d['scenario'] = self.scenario
        if self.pdf:
            d['pdf'] = self.pdf
        if self.idf:
            d['idf'] = self.idf
        if self.bridge_config:
            d['bridged_interfaces'] = self.bridge_config.to_dict()

        hosts = self.roles.all()
        if hosts.exists():
            d['roles'] = []
            for host in hosts:
                d['roles'].append({
                    host.labid: self.opnfv_config.host_opnfv_config.get(
                        host_config__pk=host.config.pk
                    ).role.name
                })

        return d

    def to_json(self):
        return json.dumps(self.to_dict())

    def set_installer(self, installer):
        self.installer = installer
        d = json.loads(self.delta)
        d['installer'] = installer
        self.delta = json.dumps(d)

    def set_scenario(self, scenario):
        self.scenario = scenario
        d = json.loads(self.delta)
        d['scenario'] = scenario
        self.delta = json.dumps(d)

    def set_xdf(self, booking, update_delta=True):
        kwargs = {'lab_name': booking.lab.name, 'booking_id': booking.id}
        self.pdf = reverse('get-pdf', kwargs=kwargs)
        self.idf = reverse('get-idf', kwargs=kwargs)
        if update_delta:
            d = json.loads(self.delta)
            d['pdf'] = self.pdf
            d['idf'] = self.idf
            self.delta = json.dumps(d)

    def add_role(self, host):
        self.roles.add(host)
        d = json.loads(self.delta)
        if 'role' not in d:
            d['role'] = []
        d['roles'].append({host.labid: host.config.opnfvRole.name})
        self.delta = json.dumps(d)

    def clear_delta(self):
        self.delta = '{}'

    def get_delta(self):
        return json.loads(self.to_json())


class AccessConfig(TaskConfig):
    access_type = models.CharField(max_length=50)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    revoke = models.BooleanField(default=False)
    context = models.TextField(default="")
    delta = models.TextField(default="{}")

    def to_dict(self):
        d = {}
        d['access_type'] = self.access_type
        d['user'] = self.user.id
        d['revoke'] = self.revoke
        try:
            d['context'] = json.loads(self.context)
        except Exception:
            pass
        return d

    def get_delta(self):
        d = json.loads(self.to_json())
        d["lab_token"] = self.accessrelation.lab_token

        return d

    def to_json(self):
        return json.dumps(self.to_dict())

    def clear_delta(self):
        d = {}
        d["lab_token"] = self.accessrelation.lab_token
        self.delta = json.dumps(d)

    def set_access_type(self, access_type):
        self.access_type = access_type
        d = json.loads(self.delta)
        d['access_type'] = access_type
        self.delta = json.dumps(d)

    def set_user(self, user):
        self.user = user
        d = json.loads(self.delta)
        d['user'] = self.user.id
        self.delta = json.dumps(d)

    def set_revoke(self, revoke):
        self.revoke = revoke
        d = json.loads(self.delta)
        d['revoke'] = revoke
        self.delta = json.dumps(d)

    def set_context(self, context):
        self.context = json.dumps(context)
        d = json.loads(self.delta)
        d['context'] = context
        self.delta = json.dumps(d)


class SoftwareConfig(TaskConfig):
    """Handles software installations, such as OPNFV or ONAP."""

    opnfv = models.ForeignKey(OpnfvApiConfig, on_delete=models.CASCADE)

    def to_dict(self):
        d = {}
        if self.opnfv:
            d['opnfv'] = self.opnfv.to_dict()

        d["lab_token"] = self.softwarerelation.lab_token
        self.delta = json.dumps(d)

        return d

    def get_delta(self):
        d = {}
        d['opnfv'] = self.opnfv.get_delta()
        d['lab_token'] = self.softwarerelation.lab_token

        return d

    def clear_delta(self):
        self.opnfv.clear_delta()

    def to_json(self):
        return json.dumps(self.to_dict())


class HardwareConfig(TaskConfig):
    """Describes the desired configuration of the hardware."""

    image = models.CharField(max_length=100, default="defimage")
    power = models.CharField(max_length=100, default="off")
    hostname = models.CharField(max_length=100, default="hostname")
    ipmi_create = models.BooleanField(default=False)
    delta = models.TextField()

    keys = set(["id", "image", "power", "hostname", "ipmi_create"])

    def to_dict(self):
        return self.get_delta()

    def get_delta(self):
        # TODO: grab the GeneratedCloudConfig urls from self.hosthardwarerelation.get_resource()
        return self.format_delta(
            self.hosthardwarerelation.get_resource().get_configuration(self.state),
            self.hosthardwarerelation.lab_token)


class NetworkConfig(TaskConfig):
    """Handles network configuration."""

    interfaces = models.ManyToManyField(Interface)
    delta = models.TextField()

    def to_dict(self):
        d = {}
        hid = self.hostnetworkrelation.resource_id
        d[hid] = {}
        for interface in self.interfaces.all():
            d[hid][interface.mac_address] = []
            if self.state != ConfigState.CLEAN:
                for vlan in interface.config.all():
                    # TODO: should this come from the interface?
                    # e.g. will different interfaces for different resources need different configs?
                    d[hid][interface.mac_address].append({"vlan_id": vlan.vlan_id, "tagged": vlan.tagged})

        return d

    def to_json(self):
        return json.dumps(self.to_dict())

    def get_delta(self):
        d = json.loads(self.to_json())
        d['lab_token'] = self.hostnetworkrelation.lab_token
        return d

    def clear_delta(self):
        self.delta = json.dumps(self.to_dict())
        self.save()

    def add_interface(self, interface):
        self.interfaces.add(interface)
        d = json.loads(self.delta)
        hid = self.hostnetworkrelation.resource_id
        if hid not in d:
            d[hid] = {}
        d[hid][interface.mac_address] = []
        for vlan in interface.config.all():
            d[hid][interface.mac_address].append({"vlan_id": vlan.vlan_id, "tagged": vlan.tagged})
        self.delta = json.dumps(d)


class SnapshotConfig(TaskConfig):

    resource_id = models.CharField(max_length=200, default="default_id")
    image = models.CharField(max_length=200, null=True)  # cobbler ID
    dashboard_id = models.IntegerField()
    delta = models.TextField(default="{}")

    def to_dict(self):
        d = {}
        if self.host:
            d['host'] = self.host.labid
        if self.image:
            d['image'] = self.image
        d['dashboard_id'] = self.dashboard_id
        return d

    def to_json(self):
        return json.dumps(self.to_dict())

    def get_delta(self):
        d = json.loads(self.to_json())
        return d

    def clear_delta(self):
        self.delta = json.dumps(self.to_dict())
        self.save()

    def set_host(self, host):
        self.host = host
        d = json.loads(self.delta)
        d['host'] = host.labid
        self.delta = json.dumps(d)

    def set_image(self, image):
        self.image = image
        d = json.loads(self.delta)
        d['image'] = self.image
        self.delta = json.dumps(d)

    def clear_image(self):
        self.image = None
        d = json.loads(self.delta)
        d.pop("image", None)
        self.delta = json.dumps(d)

    def set_dashboard_id(self, dash):
        self.dashboard_id = dash
        d = json.loads(self.delta)
        d['dashboard_id'] = self.dashboard_id
        self.delta = json.dumps(d)

    def save(self, *args, **kwargs):
        if len(ResourceQuery.filter(labid=self.resource_id)) != 1:
            raise ValidationError("resource_id " + str(self.resource_id) + " does not refer to a single resource")
        super().save(*args, **kwargs)


def get_task(task_id):
    for taskclass in [AccessRelation, SoftwareRelation, HostHardwareRelation, HostNetworkRelation, SnapshotRelation]:
        try:
            ret = taskclass.objects.get(task_id=task_id)
            return ret
        except taskclass.DoesNotExist:
            pass
    from django.core.exceptions import ObjectDoesNotExist
    raise ObjectDoesNotExist("Could not find matching TaskRelation instance")


def get_task_uuid():
    return str(uuid.uuid4())


class TaskRelation(models.Model):
    """
    Relates a Job to a TaskConfig.

    superclass that relates a Job to tasks anc maintains information
    like status and messages from the lab
    """

    status = models.IntegerField(default=JobStatus.NEW)
    job = models.ForeignKey(Job, on_delete=models.CASCADE)
    config = models.OneToOneField(TaskConfig, on_delete=models.CASCADE)
    task_id = models.CharField(default=get_task_uuid, max_length=37)
    lab_token = models.CharField(default="null", max_length=50)
    message = models.TextField(default="")

    job_key = None

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)

    def type_str(self):
        return "Generic Task"

    class Meta:
        abstract = True


class AccessRelation(TaskRelation):
    config = models.OneToOneField(AccessConfig, on_delete=models.CASCADE)
    job_key = "access"

    def type_str(self):
        return "Access Task"

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)


class SoftwareRelation(TaskRelation):
    config = models.OneToOneField(SoftwareConfig, on_delete=models.CASCADE)
    job_key = "software"

    def type_str(self):
        return "Software Configuration Task"

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)


class HostHardwareRelation(TaskRelation):
    resource_id = models.CharField(max_length=200, default="default_id")
    config = models.OneToOneField(HardwareConfig, on_delete=models.CASCADE)
    job_key = "hardware"

    def type_str(self):
        return "Hardware Configuration Task"

    def get_delta(self):
        return self.config.to_dict()

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)

    def save(self, *args, **kwargs):
        if len(ResourceQuery.filter(labid=self.resource_id)) != 1:
            raise ValidationError("resource_id " + str(self.resource_id) + " does not refer to a single resource")
        super().save(*args, **kwargs)

    def get_resource(self):
        return ResourceQuery.get(labid=self.resource_id)


class HostNetworkRelation(TaskRelation):
    resource_id = models.CharField(max_length=200, default="default_id")
    config = models.OneToOneField(NetworkConfig, on_delete=models.CASCADE)
    job_key = "network"

    def type_str(self):
        return "Network Configuration Task"

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)

    def save(self, *args, **kwargs):
        if len(ResourceQuery.filter(labid=self.resource_id)) != 1:
            raise ValidationError("resource_id " + str(self.resource_id) + " does not refer to a single resource")
        super().save(*args, **kwargs)

    def get_resource(self):
        return ResourceQuery.get(labid=self.resource_id)


class SnapshotRelation(TaskRelation):
    snapshot = models.ForeignKey(Image, on_delete=models.CASCADE)
    config = models.OneToOneField(SnapshotConfig, on_delete=models.CASCADE)
    job_key = "snapshot"

    def type_str(self):
        return "Snapshot Task"

    def get_delta(self):
        return self.config.to_dict()

    def delete(self, *args, **kwargs):
        self.config.delete()
        return super(self.__class__, self).delete(*args, **kwargs)


class ActiveUsersRelation(TaskRelation):
    config = models.OneToOneField(ActiveUsersConfig, on_delete=models.CASCADE)
    job_key = "active users task"

    def type_str(self):
        return "Active Users Task"


class JobFactory(object):
    """This class creates all the API models (jobs, tasks, etc) needed to fulfill a booking."""

    @classmethod
    def reimageHost(cls, new_image, booking, host):
        """Modify an existing job to reimage the given host."""
        job = Job.objects.get(booking=booking)
        # make hardware task new
        hardware_relation = HostHardwareRelation.objects.get(resource_id=host, job=job)
        hardware_relation.config.image = new_image.lab_id
        hardware_relation.config.save()
        hardware_relation.status = JobStatus.NEW

        # re-apply networking after host is reset
        net_relation = HostNetworkRelation.objects.get(resource_id=host, job=job)
        net_relation.status = JobStatus.NEW

        # re-apply ssh access after host is reset
        for relation in AccessRelation.objects.filter(job=job, config__access_type="ssh"):
            relation.status = JobStatus.NEW
            relation.save()

        hardware_relation.save()
        net_relation.save()

    @classmethod
    def makeSnapshotTask(cls, image, booking, host):
        relation = SnapshotRelation()
        job = Job.objects.get(booking=booking)
        config = SnapshotConfig.objects.create(dashboard_id=image.id)

        relation.job = job
        relation.config = config
        relation.config.save()
        relation.config = relation.config
        relation.snapshot = image
        relation.save()

        config.clear_delta()
        config.set_host(host)
        config.save()

    @classmethod
    def makeActiveUsersTask(cls):
        """ Append active users task to analytics job """
        config = ActiveUsersConfig()
        relation = ActiveUsersRelation()
        job = Job.objects.get(job_type='DATA')

        job.status = JobStatus.NEW

        relation.job = job
        relation.config = config
        relation.config.save()
        relation.config = relation.config
        relation.save()
        config.save()

    @classmethod
    def makeAnalyticsJob(cls, booking):
        """
        Create the analytics job

        This will only run once since there will only be one analytics job.
        All analytics tasks get appended to analytics job.
        """

        if len(Job.objects.filter(job_type='DATA')) > 0:
            raise Exception("Cannot have more than one analytics job")

        if booking.resource:
            raise Exception("Booking is not marker for analytics job, has resoure")

        job = Job()
        job.booking = booking
        job.job_type = 'DATA'
        job.save()

        cls.makeActiveUsersTask()

    @classmethod
    def makeCompleteJob(cls, booking):
        """Create everything that is needed to fulfill the given booking."""
        resources = booking.resource.get_resources()
        job = None
        try:
            job = Job.objects.get(booking=booking)
        except Exception:
            job = Job.objects.create(status=JobStatus.NEW, booking=booking)
        cls.makeHardwareConfigs(
            resources=resources,
            job=job
        )
        cls.makeNetworkConfigs(
            resources=resources,
            job=job
        )
        cls.makeSoftware(
            booking=booking,
            job=job
        )
        cls.makeGeneratedCloudConfigs(
            resources=resources,
            job=job
        )
        all_users = list(booking.collaborators.all())
        all_users.append(booking.owner)
        cls.makeAccessConfig(
            users=all_users,
            access_type="vpn",
            revoke=False,
            job=job
        )
        for user in all_users:
            try:
                cls.makeAccessConfig(
                    users=[user],
                    access_type="ssh",
                    revoke=False,
                    job=job,
                    context={
                        "key": user.userprofile.ssh_public_key.open().read().decode(encoding="UTF-8"),
                        "hosts": [r.labid for r in resources]
                    }
                )
            except Exception:
                continue

    @classmethod
    def makeGeneratedCloudConfigs(cls, resources=[], job=Job()):
        for res in resources:
            cif = GeneratedCloudConfig.objects.create(resource_id=res.labid, booking=job.booking, rconfig=res.config)
            cif.save()

            cif = CloudInitFile.create(priority=0, text=cif.serialize())
            cif.save()

            res.config.cloud_init_files.add(cif)
            res.config.save()

    @classmethod
    def makeHardwareConfigs(cls, resources=[], job=Job()):
        """
        Create and save HardwareConfig.

        Helper function to create the tasks related to
        configuring the hardware
        """
        for res in resources:
            hardware_config = None
            try:
                hardware_config = HardwareConfig.objects.get(relation__resource_id=res.labid)
            except Exception:
                hardware_config = HardwareConfig()

            relation = HostHardwareRelation()
            relation.resource_id = res.labid
            relation.job = job
            relation.config = hardware_config
            relation.config.save()
            relation.config = relation.config
            relation.save()

            hardware_config.set("id", "image", "hostname", "power", "ipmi_create")
            hardware_config.save()

    @classmethod
    def makeAccessConfig(cls, users, access_type, revoke=False, job=Job(), context=False):
        """
        Create and save AccessConfig.

        Helper function to create the tasks related to
        configuring the VPN, SSH, etc access for users
        """
        for user in users:
            relation = AccessRelation()
            relation.job = job
            config = AccessConfig()
            config.access_type = access_type
            config.user = user
            config.save()
            relation.config = config
            relation.save()
            config.clear_delta()
            if context:
                config.set_context(context)
            config.set_access_type(access_type)
            config.set_revoke(revoke)
            config.set_user(user)
            config.save()

    @classmethod
    def makeNetworkConfigs(cls, resources=[], job=Job()):
        """
        Create and save NetworkConfig.

        Helper function to create the tasks related to
        configuring the networking
        """
        for res in resources:
            network_config = None
            try:
                network_config = NetworkConfig.objects.get(relation__host=res)
            except Exception:
                network_config = NetworkConfig.objects.create()

            relation = HostNetworkRelation()
            relation.resource_id = res.labid
            relation.job = job
            network_config.save()
            relation.config = network_config
            relation.save()
            network_config.clear_delta()

            # TODO: use get_interfaces() on resource
            for interface in res.interfaces.all():
                network_config.add_interface(interface)
            network_config.save()

    @classmethod
    def make_bridge_config(cls, booking):
        if len(booking.resource.get_resources()) < 2:
            return None
        try:
            jumphost_config = ResourceOPNFVConfig.objects.filter(
                role__name__iexact="jumphost"
            )
            jumphost = ResourceQuery.filter(
                bundle=booking.resource,
                config=jumphost_config.resource_config
            )[0]
        except Exception:
            return None
        br_config = BridgeConfig.objects.create(opnfv_config=booking.opnfv_config)
        for iface in jumphost.interfaces.all():
            br_config.interfaces.add(iface)
        return br_config

    @classmethod
    def makeSoftware(cls, booking=None, job=Job()):
        """
        Create and save SoftwareConfig.

        Helper function to create the tasks related to
        configuring the desired software, e.g. an OPNFV deployment
        """
        if not booking.opnfv_config:
            return None

        opnfv_api_config = OpnfvApiConfig.objects.create(
            opnfv_config=booking.opnfv_config,
            installer=booking.opnfv_config.installer.name,
            scenario=booking.opnfv_config.scenario.name,
            bridge_config=cls.make_bridge_config(booking)
        )

        opnfv_api_config.set_xdf(booking, False)
        opnfv_api_config.save()

        for host in booking.resource.get_resources():
            opnfv_api_config.roles.add(host)
        software_config = SoftwareConfig.objects.create(opnfv=opnfv_api_config)
        software_relation = SoftwareRelation.objects.create(job=job, config=software_config)
        return software_relation


JOB_TASK_CLASSLIST = [
    HostHardwareRelation,
    AccessRelation,
    HostNetworkRelation,
    SoftwareRelation,
    SnapshotRelation,
    ActiveUsersRelation
]


class JobTaskQuery(AbstractModelQuery):
    model_list = JOB_TASK_CLASSLIST