# Copyright 2020 ArctosLabs Scandinavia AB
#
# 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 datetime
import platform
import itertools

import pymzn
from jinja2 import Environment
from jinja2.loaders import FileSystemLoader, PackageLoader, ChoiceLoader


class MznPlacementConductor(object):
    """
    Knows how to process placement req using minizinc
    """

    if platform.system() == "Windows":
        default_mzn_path = "C:\\Program Files\\MiniZinc IDE (bundled)\\minizinc.exe"
    else:
        default_mzn_path = "/minizinc/bin/minizinc"

    def __init__(self, log, mzn_path=default_mzn_path):
        pymzn.config["minizinc"] = mzn_path
        self.log = (
            log  # FIXME what to log (besides forwarding it to MznModelGenerator) here?
        )

    def _run_placement_model(self, mzn_model, ns_desc, mzn_model_data={}):
        """
        Runs the minizinc placement model and post process the result
        Note: in this revision we use the 'item' output mode from pymzn.minizinc since it ease
        post processing of the solutions when we use enumerations in mzn_model
        Note: minizinc does not support '-' in identifiers and therefore we convert back from use of '_' when we
        process the result
        Note: minizinc does not support identifiers starting with numbers and therefore we skip the leading 'vim_'
        when we process the result

        :param mzn_model: a minizinc model as str (note: may also be path to .mzn file)
        :param ns_desc: network service descriptor, carries information about pinned VNFs so those can be included in
         the result
        :param mzn_model_data: minizinc model data dictionary (typically not used with our models)
        :return: list of dicts formatted as {'vimAccountId': '<account id>', 'member-vnf-index': <'index'>}
        or formatted as [{}] if unsatisfiable model
        """
        solns = pymzn.minizinc(mzn_model, data=mzn_model_data, output_mode="item")

        if "UNSATISFIABLE" in str(solns):
            return [{}]

        solns_as_str = str(solns[0])

        # make it easier to extract the desired information by cleaning from newline, whitespace etc.
        solns_as_str = solns_as_str.replace("\n", "").replace(" ", "").rstrip(";")

        vnf_vim_mapping = (e.split("=") for e in solns_as_str.split(";"))

        res = [
            {"vimAccountId": e[1][3:].replace("_", "-"), "member-vnf-index": e[0][3:]}
            for e in vnf_vim_mapping
        ]
        # add any pinned VNFs
        pinned = [
            {
                "vimAccountId": e["vim_account"][3:].replace("_", "-"),
                "member-vnf-index": e["vnf_id"],
            }
            for e in ns_desc
            if "vim_account" in e.keys()
        ]

        return res + pinned

    def do_placement_computation(self, nspd):
        """
        Orchestrates the placement computation

        :param nspd: placement data
        :return: see _run_placement_model
        """
        mzn_model = MznModelGenerator(self.log).create_model(nspd)
        return self._run_placement_model(mzn_model, nspd["ns_desc"])


class MznModelGenerator(object):
    """
    Has the capability to generate minizinc models from information contained in
    NsPlacementData objects. Uses jinja2 as templating language for the model
    """

    default_j2_template = "osm_pla_dynamic_template.j2"
    template_search_path = [
        "osm_pla/placement",
        "../placement",
        "/pla/osm_pla/placement",
        "./",
        "/usr/lib/python3/dist-packages/osm_pla/placement",
    ]

    def __init__(self, log):
        """
        Constructor
        """
        self.log = log  # FIXME we do not log anything so far

    def create_model(self, ns_placement_data):
        """
        Creates a minizinc model according to the content of nspd
        nspd - NSPlacementData
        return MZNModel
        """
        self.log.info("ns_desc: {}".format(ns_placement_data["ns_desc"]))
        self.log.info("vld_desc: {}".format(ns_placement_data["vld_desc"]))
        mzn_model_template = self._load_jinja_template()
        mzn_model = mzn_model_template.render(ns_placement_data)
        self.log.info("Minizinc model: {}".format(mzn_model))
        return mzn_model

    def _load_jinja_template(self, template_name=default_j2_template):
        """loads the jinja template used for model generation"""
        loader1 = FileSystemLoader(MznModelGenerator.template_search_path)
        loader2 = PackageLoader("osm_pla", ".")
        env = Environment(loader=ChoiceLoader([loader1, loader2]), autoescape=True)
        return env.get_template(template_name)


class NsPlacementDataFactory(object):
    """
    process information an network service and applicable network infrastructure resources in order to produce
    information tailored for the minizinc model code generator
    """

    def __init__(
        self,
        vim_accounts_info,
        vnf_prices,
        nsd,
        pil_info,
        pinning=None,
        order_constraints=None,
    ):
        """
        :param vim_accounts_info: a dictionary with vim url as key and id as value, we add a unique index to it for use
        in the mzn array constructs and adjust the value of the id to minizinc acceptable identifier syntax
        :param vnf_prices: a dictionary with 'vnfd-id-ref' as key and a dictionary with vim_urls: cost as value
        :param nsd: the network service descriptor
        :param pil_info: price list and metrics for PoP interconnection links
        :param pinning: list of {'member-vnf-index': '<idx>', 'vim_account': '<vim-account>'}
        :param order_constraints: any constraints provided at instantiation time
        """
        next_idx = itertools.count()
        self._vim_accounts_info = {
            k: {"id": "vim" + v.replace("-", "_"), "idx": next(next_idx)}
            for k, v in vim_accounts_info.items()
        }
        self._vnf_prices = vnf_prices
        self._nsd = nsd
        self._pil_info = pil_info
        self._pinning = pinning
        self._order_constraints = order_constraints

    def _produce_trp_link_characteristics_data(self, characteristics):
        """
        :param characteristics: one of  {pil_latency, pil_price, pil_jitter}
        :return: 2d array of requested trp_link characteristics data
        """
        if characteristics not in {"pil_latency", "pil_price", "pil_jitter"}:
            raise Exception("characteristic '{}' not supported".format(characteristics))
        num_vims = len(self._vim_accounts_info)
        trp_link_characteristics = [
            [0 if col == row else 0x7FFF for col in range(num_vims)]
            for row in range(num_vims)
        ]
        for pil in self._pil_info["pil"]:
            if characteristics in pil.keys():
                ep1 = pil["pil_endpoints"][0]
                ep2 = pil["pil_endpoints"][1]
                # only consider links between applicable vims
                if ep1 in self._vim_accounts_info and ep2 in self._vim_accounts_info:
                    idx1 = self._vim_accounts_info[ep1]["idx"]
                    idx2 = self._vim_accounts_info[ep2]["idx"]
                    trp_link_characteristics[idx1][idx2] = pil[characteristics]
                    trp_link_characteristics[idx2][idx1] = pil[characteristics]

        return trp_link_characteristics

    # TODO: Review if we should adapt this method with SOL006 /nsd/vnfd/int-virtual-link-desc/df/qos fields.
    def _produce_vld_desc(self):
        """
        Creates the expected vlds from the nsd. Includes constraints if part of nsd.
        Overrides constraints with any syntactically correct instantiation parameters
        :return:
        """

        all_vld_member_vnf_index_refs = {}
        # TODO: Change for multiple DF support
        ns_df = self._nsd.get("df", [{}])[0]
        for vnf_profile in ns_df.get("vnf-profile", []):
            for vlc in vnf_profile.get("virtual-link-connectivity", []):
                vld_id = vlc.get("virtual-link-profile-id")
                vld_member_vnf_index_ref = vnf_profile.get("id")
                if vld_id in all_vld_member_vnf_index_refs:
                    all_vld_member_vnf_index_refs[vld_id].append(
                        vld_member_vnf_index_ref
                    )
                else:
                    all_vld_member_vnf_index_refs[vld_id] = [vld_member_vnf_index_ref]

        vld_desc = []
        for vld in self._nsd.get("virtual-link-desc", ()):
            if vld.get("mgmt-network", False) is True:
                continue
            vld_desc_entry = {}
            cp_refs = all_vld_member_vnf_index_refs[vld.get("id")]
            if len(cp_refs) == 2:
                vld_desc_entry["cp_refs"] = cp_refs
                # TODO: Change for multiple DF support
                vld_df = vld.get("df", [{}])[0]
                for constraint in vld_df.get("qos", {}):
                    if constraint == "latency":
                        vld_desc_entry["latency"] = vld_df["qos"][constraint]
                    elif constraint == "packet-delay-variation":
                        vld_desc_entry["jitter"] = vld_df["qos"][constraint]
                vld_desc.append(vld_desc_entry)

        # create candidates from instantiate params
        if self._order_constraints is not None:
            candidate_vld_desc = []
            # use id to find the endpoints in the nsd
            for entry in self._order_constraints.get("vld-constraints"):
                for vld in self._nsd.get("virtual-link-desc", ()):
                    if entry["id"] == vld.get("id"):
                        vld_desc_instantiate_entry = {}
                        cp_refs = all_vld_member_vnf_index_refs[vld.get("id")]
                        vld_desc_instantiate_entry["cp_refs"] = cp_refs
                        # add whatever constraints that are provided to the vld_desc_entry
                        # misspelled 'link-constraints' => empty dict
                        # lack (or misspelling) of one or both supported constraints => entry not appended
                        for constraint, value in entry.get(
                            "link-constraints", {}
                        ).items():
                            if constraint == "latency":
                                vld_desc_instantiate_entry["latency"] = value
                            elif constraint == "jitter":
                                vld_desc_instantiate_entry["jitter"] = value
                        if {"latency", "jitter"}.intersection(
                            vld_desc_instantiate_entry.keys()
                        ):
                            candidate_vld_desc.append(vld_desc_instantiate_entry)
            # merge with nsd originated, FIXME log any deviations?
            for vld_d in vld_desc:
                for vld_d_i in candidate_vld_desc:
                    if set(vld_d["cp_refs"]) == set(vld_d_i["cp_refs"]):
                        if vld_d_i.get("jitter"):
                            vld_d["jitter"] = vld_d_i["jitter"]
                        if vld_d_i.get("latency"):
                            vld_d["latency"] = vld_d_i["latency"]

        return vld_desc

    def _produce_ns_desc(self):
        """
        collect information for the ns_desc part of the placement data
        for the vim_accounts that are applicable, collect the vnf_price
        """
        ns_desc = []
        # TODO: Change for multiple DF support
        ns_df = self._nsd.get("df", [{}])[0]
        for vnf_profile in ns_df.get("vnf-profile", []):
            vnf_info = {"vnf_id": vnf_profile["id"]}
            # prices
            prices_for_vnfd = self._vnf_prices[vnf_profile["vnfd-id"]]
            # the list of prices must be ordered according to the indexing of the vim_accounts
            price_list = [_ for _ in range(len(self._vim_accounts_info))]
            for k in prices_for_vnfd.keys():
                if k in self._vim_accounts_info.keys():
                    price_list[self._vim_accounts_info[k]["idx"]] = prices_for_vnfd[k]
            vnf_info["vnf_price_per_vim"] = price_list

            # pinning to dc
            if self._pinning is not None:
                for pinned_vnf in self._pinning:
                    if vnf_profile["id"] == pinned_vnf["member-vnf-index"]:
                        vnf_info["vim_account"] = "vim" + pinned_vnf[
                            "vimAccountId"
                        ].replace("-", "_")

            ns_desc.append(vnf_info)
        return ns_desc

    def create_ns_placement_data(self):
        """populate NsPlacmentData object"""
        ns_placement_data = {
            "vim_accounts": [
                vim_data["id"]
                for _, vim_data in sorted(
                    self._vim_accounts_info.items(), key=lambda item: item[1]["idx"]
                )
            ],
            "trp_link_latency": self._produce_trp_link_characteristics_data(
                "pil_latency"
            ),
            "trp_link_jitter": self._produce_trp_link_characteristics_data(
                "pil_jitter"
            ),
            "trp_link_price_list": self._produce_trp_link_characteristics_data(
                "pil_price"
            ),
            "ns_desc": self._produce_ns_desc(),
            "vld_desc": self._produce_vld_desc(),
            "generator_data": {"file": __file__, "time": datetime.datetime.now()},
        }

        return ns_placement_data