import argparse
import csv
from pathlib import Path

import ee.tools
from ee import tools
from ee.part import Part, load_db
from ee.tools import mk_dirs


def write_csvs(print_header, in_parts, part_f, part_pn_f, fact_f):
    dialect = "excel-tab"
    part_csv = csv.writer(part_f, dialect=dialect)
    if print_header:
        part_csv.writerow(["uri", "ref"])

    part_pn_csv = csv.writer(part_pn_f, dialect=dialect)
    if print_header:
        part_pn_csv.writerow(["part_uri", "spn", "mpn"])

    fact_csv = csv.writer(fact_f, dialect=dialect)
    if print_header:
        fact_csv.writerow(["part_uri", "key", "value"])

    part_count = 0
    fact_count = 0

    for xml in in_parts.iterparts():
        p = Part(xml)
        sch_ref = p.get_only_schematic_reference()
        part_csv.writerow([p.uri, sch_ref.referenceProp if sch_ref else None])

        spn = p.get_only_spn()
        mpn = p.get_only_mpn()
        if spn is not None or mpn is not None:
            part_pn_csv.writerow([p.uri, spn.valueProp if spn else None, mpn.valueProp if mpn else None])

        part_count += 1

        for fact in p.get_facts():
            fact_csv.writerow([p.uri, fact.keyProp, fact.valueProp])
            fact_count += 1

    return part_count, fact_count


def work(in_path: Path, work_dir: Path):
    in_parts = load_db(in_path)

    print_header = False

    tools.mk_dirs(work_dir)
    with (work_dir / "facts.dl").open("w") as f:
        print("""
.decl part(uri:symbol, ref:symbol)
.input part

.decl fact(part_uri:symbol, key:symbol, value:symbol)
.input fact

.decl part_pn(part_uri:symbol, spn:symbol, mpn:symbol)
.input part_pn
""".strip(), file=f)

    in_dir = work_dir / "in"
    mk_dirs(in_dir)
    with (in_dir / "part.facts").open("w") as part_f:
        with (in_dir / "part_pn.facts").open("w") as part_pn_f:
            with (in_dir / "fact.facts").open("w") as fact_f:
                part_count, fact_count = write_csvs(print_header, in_parts, part_f, part_pn_f, fact_f)

    print("Loaded clauses: {} parts, {} facts".format(part_count, fact_count))


parser = argparse.ArgumentParser()
ee.tools.add_default_argparse_group(parser)

parser.add_argument("--in",
                    dest="in_path",
                    required=True,
                    metavar="PART DB")

parser.add_argument("--work",
                    required=True,
                    metavar="DIR")

args = parser.parse_args()
ee.tools.process_default_argparse_group(args)

work(Path(args.in_path), Path(args.work))