import os.path
from doit.exceptions import TaskFailed
from doit.tools import check_timestamp_unchanged
from configclass import Config
from typing import List
from ee.fact import DataSetManager
import logging

logger = logging.getLogger(__name__)

class KicadDoitTasks(object):
    config = Config({
        "sch": None,
        "kicad_pcb": None,
        "gerber_dir": None,
        "gerber_zip": None,
        "data_set_dir": None,
        })

    def __init__(self, *args, **kwargs):
        self.config = self.config.make(kwargs)

    def echo(*args, **kwargs):
        logger.info("_task: args={}, kwars={}".format(args, kwargs))

    def tasks(self, *args, **kwargs):
        import ee.kicad
        kicad_pcb = self.config["kicad_pcb"]
        sch = self.config["sch"]
        tasks = []

        dsm = DataSetManager(self.config["data_set_dir"])

        gerber_dir = self.config["gerber_dir"]
        if gerber_dir:
            tasks.append(task_kicad_gerber())

        sch_ds = task_kicad_sch_to_data_set(dsm, sch, \
                in_data_sets=[], \
                out_data_set="kicad-sch-data-set") \
                if sch else None

        component_ds = task_kicad_create_component_data_set(dsm, \
                in_data_sets=sch_ds["targets"], \
                out_data_set="raw-component") \
                if sch_ds else None

        return (t for t in [sch_ds, component_ds] if t is not None)

def task_kicad_gerber(name="kicad-gerber"):
    gerber_zip = self.config["gerber_zip"] or "{}.zip".format(gerber_dir)
    #logger.info("gerber_zip={}".format(gerber_zip))

    eg = next((p for p in (os.path.join(p, "export_gerber.py") for p in ee.kicad.__path__) if os.path.isfile(p)), None)
    if not eg:
        raise Exception("Could not find export_gerber.py")

    # TODO: replace with python
    mkdir = "mkdir -p {}".format(gerber_dir)
    export_gerber = " ".join([
        eg,
        "--pcb", kicad_pcb,
        "--output-directory", gerber_dir,
        "--protel-extensions",
    ])
    def make_zip():
        import zipfile
        from pathlib import Path
        with zipfile.ZipFile(gerber_zip, "w") as z:
            for p in Path(gerber_dir).iterdir():
                if not p.is_file():
                    continue
                z.write(p, arcname=p.relative_to(gerber_dir))

    return {
        "name": name,
        "targets": [gerber_zip],
        "actions": [mkdir, export_gerber, make_zip],
        "file_dep": [kicad_pcb],
    }

def task_kicad_sch_to_data_set(dsm: DataSetManager, sch, in_data_sets: List[str], out_data_set, name="kicad-sch-to-data-set"):
    def action():
        import ee.kicad
        from ee.kicad.model import Component, ComponentField
        import csv
        import configparser

        with dsm.create_rw(out_data_set, inputs=in_data_sets) as ds:
            schematics = ee.kicad.read_schematics(sch)
            for c in [c for c in schematics.components]:
                o = ds.get_object("kicad-schematic-component", c.timestamp)
                o.set("ref", c.ref)
                o.set("ref-type", c.ref_type)
                if c.has_ref_num:
                    o.set("ref-num", str(c.ref_num))
                o.set("value", c.value)
                if c.footprint:
                    o.set("footprint", c.footprint)

                for f in c.fields:
                    if f.value and f.name not in ComponentField.names:
                        o.set(f.name, str(f.value))

    return {
        "name": name,
        "file_dep": [sch] + [dsm.metafile_for_ds(ds) for ds in in_data_sets],
        "actions": [action],
        "targets": [dsm.metafile_for_ds(out_data_set)],
    }

def task_kicad_create_component_data_set(dsm: DataSetManager, in_data_sets: List[str], out_data_set, name="kicad-create-component-data-set"):
    def action(*args, **kwargs):
        logger.info("args={}, kwargs={}".format(args, kwargs))
        import ee.fact as fact

        with dsm.create_rw(out_data_set, inputs=in_data_sets) as ds:
            items = ds.items()
            logger.info("Got {} objects".format(len(items)))
            for o in items:
                logger.info("processing {}".format(o.key))

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