import logging
from pathlib import Path
from typing import Mapping, Union

from configclass import Config
from namedlist import namedlist

from ee.ds import DataSetManager, DataSet

logger = logging.getLogger(__name__)

_dsm = None  # type: DataSetManager

_data_sets = {}


def change_data_sets_for_task(task, _callable):
    _data_sets[task][1] = _callable(_data_sets[task][1])


def output_data_set_for_task(task):
    return _data_sets[task][0]


def input_data_sets_for_task(task):
    return _data_sets[task][1]


_config_template = Config({
})

_config = None  # type: Mapping[str, str]


def init(data_set_manager: DataSetManager, **kwargs):
    global _config
    _config = _config_template.make(kwargs)

    global _dsm
    _dsm = data_set_manager


class BomComponent(object):
    def __init__(self, ref, mpn):
        self.ref = ref
        self.mpn = mpn

    def to_object(self, ds):
        return ds.create_object("bom-component", self.ref). \
            set("ref", self.ref). \
            set("mpn", self.mpn)


def task_bom():
    """
    Creates 'bom-component' from 'component'.

    Takes all schematic components, filters out all virtual/non-
    physical components (like power flags and ground components) and
    creates 'bom-component' objects.
    """

    out_data_set = _data_sets[task_bom][0]
    in_data_sets = _data_sets[task_bom][1]

    def action():
        in_ds = _dsm.load_data_sets(in_data_sets)

        with _dsm.create_rw(out_data_set, clean=True) as output:
            components = [o for o in in_ds.items() if o.object_type.name == "component"]

            bom_components = {}

            for c in components:
                ref = c.get("ref")
                mpn = c.get("mpn")

                if not ref:
                    raise Exception("Missing ref")

                if not mpn:
                    output.create_object("message", "bom-{}".format(ref)). \
                        set("level", "error"). \
                        set("message", "Missing required field 'mpn'")
                    continue

                if ref in bom_components:
                    raise Exception("Duplicate ref '{}'".format("ref"))

                bom_components[ref] = BomComponent(ref, mpn)

            [c.to_object(output) for c in bom_components.values()]

    return {
        "file_dep": [_dsm.cookie_for_ds(ds) for ds in in_data_sets],
        "actions": [action],
        "targets": [_dsm.cookie_for_ds(out_data_set)],
    }


_data_sets[task_bom] = ["bom", ["components"]]


def order_csv(count: int, style: str, output_file: Path, data_sets):
    ds = _dsm.load_data_sets(data_sets)

    out = DataSet()

    parts = {}

    # noinspection PyPep8Naming
    Part = namedlist("Part", "mpn, cnt, refs, digikey_pn")

    for c in [o for o in ds.items() if o.object_type.name == "bom-component"]:
        ref = c.get("ref")
        mpn = c.get("mpn")
        digikey_pn = c.get("digikey-pn")

        if style == "digikey":
            dpn = digikey_pn.strip() if digikey_pn else ""

            # TODO: implement part resolution
            # if len(dpn) == 0:
            #     raise Exception("Missing digikey-pn for ref={}".format(ref))

        if mpn in parts:
            part = parts[mpn]

            if part.digikey_pn != digikey_pn:
                raise Exception("Bad data, inconsistent digikey-pn for mpn '{}'. Original digikey-pn='{}', new "
                                "digikey-pn='{}'".format(mpn, part.digikey_pn, digikey_pn))

            part.cnt += 1
            part.refs.append(ref)
        else:
            parts[mpn] = Part(mpn=mpn, cnt=1, refs=[ref], digikey_pn=digikey_pn)

    mpn_field = "MPN"
    count_field = "Count"
    refs_field = "References"

    if style == "digikey":
        count_field = "Quantity"
        refs_field = "Customer Reference"

    for part in sorted(parts.values(), key=lambda p: p.mpn):
        o = out.create_object("row", part.mpn). \
            set(mpn_field, part.mpn). \
            set(count_field, part.cnt * count). \
            set(refs_field, ",".join(part.refs))

        if style == "digikey":
            o.set("Digi-Key Part Number", part.digikey_pn)

    fields = None
    include_extra_fields = True

    if style == "digikey":
        fields = ["Digi-Key Part Number", refs_field, count_field, mpn_field]
        include_extra_fields = False

    _dsm.store_csv(output_file, out, "row", order_by=mpn_field, fields=fields,
                   include_extra_fields=include_extra_fields)


def create_task_order_csv(*, style: str = None, output_file: Union[str, Path], data_sets, count: int = 1):
    return {
        "name": "order-{}".format(count) if not style else "order-{}-{}".format(style, count),
        "actions": [(order_csv, [count, style, Path(output_file), data_sets])],
        "file_dep": [_dsm.cookie_for_ds(ds) for ds in data_sets],
        "targets": [output_file],
    }