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, create_message

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):
    try:
        return _data_sets[task][0]
    except KeyError:
        raise KeyError("No such task registered in this module: {}".format(task))


def input_data_sets_for_task(task):
    try:
        return _data_sets[task][1]
    except KeyError:
        raise KeyError("No such task registered in this module: {}".format(task))


_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:
                    create_message(output, "Missing required field 'mpn'", "error")
                    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) -> DataSet:
    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")

        dk_part = None

        if style == "digikey":
            dk_parts = [o.get_req("part-number") for o in ds.items() if
                        o.object_type.name == "component-to-part-mapping" and
                        o.has("seller", "ref", "part-number") and
                        o.get("seller") == "digikey" and
                        o.get("ref") == ref]

            # The actual DK part should depend on the price breaks for the different packagings, but we don't have that
            # info here. Luckily the DK store proposes cheaper packagings when ordering so that is something.

            dk_parts = set(dk_parts)

            if len(dk_parts) == 0:
                create_message(out, "No part for component: ref={}, mpn={}".format(ref, mpn), "error")
                continue
            elif len(dk_parts) > 1:
                create_message(out, "Multiple parts for component: ref={}, mpn={}. Don't know which one to select.".
                               format(ref, mpn), "error")
                continue
            else:
                dk_part = next(iter(dk_parts))

            dk_part = dk_part.strip()

            if len(dk_part) == 0:
                raise Exception("Missing digikey part number for ref={}".format(ref))

        if mpn in parts:
            part = parts[mpn]

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

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

    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], out_data_set, data_sets, count: int = 1):
    def action():
        with _dsm.create_rw(out_data_set, clean=True):
            order_csv(count, style, Path(output_file), data_sets)

    return {
        "name": "order-{}".format(count) if not style else "order-{}-{}".format(style, count),
        "actions": [action],
        "file_dep": [_dsm.cookie_for_ds(ds) for ds in data_sets],
        "targets": [_dsm.cookie_for_ds(out_data_set), output_file],
    }