import sys
import logging
from genericpath import isfile

from rdflib import store, ConjunctiveGraph, Graph, RDF, RDFS
from rdflib.plugins.sparql import prepareQuery
import rdflib.plugins.stores.sparqlstore as sparqlstore
import configparser

from ..digikey import rdf as digikey_rdf
from ..kicad import rdf as kicad_rdf


class CliException(Exception):
    pass


def initialize():
    logging.basicConfig(level=logging.DEBUG)
    pass


def info(msg=None):
    if msg is not None:
        sys.stderr.write(msg)
    sys.stderr.write("\n")


def do_exit(msg=None):
    sys.exit(msg)


def with_database(tx):
    config = read_config()

    db_type = config['db']['type']
    if db_type is None or db_type == 'local':
        path = ".eda-rdf/db"
        g = ConjunctiveGraph('Sleepycat')
        rt = g.open(path, create=False)
        if rt == store.NO_STORE:
            info("Creating store in %s" % path)
            g.open(path, create=True)
        elif rt != store.VALID_STORE:
            raise CliException("The database is corrupt: %s" % path)
    elif db_type == 'sparql':
        g = sparqlstore.SPARQLStore()
        g.open(config["db"]["url"])
    else:
        raise CliException("Unknown db.type: %s" % db_type)

    try:
        print("g=%s" % g)
        tx(g)
    finally:
        g.close()


def create_graph(digikey=False, kicad=False):
    g = Graph()

    if digikey:
        g.bind("dk", digikey_rdf.DIGIKEY)
        g.bind("dk-part", digikey_rdf.DIGIKEY_PART)
        g.bind("dk-attr-type", digikey_rdf.DIGIKEY_ATTRIBUTE_TYPE)
        g.bind("dk-attr-value", digikey_rdf.DIGIKEY_ATTRIBUTE_VALUE)
        g.bind("dk-product-category", digikey_rdf.DIGIKEY_PRODUCT_CATEGORY)

    if kicad:
        g.bind("kicad", kicad_rdf.KICAD)
        g.bind("kicad-type", kicad_rdf.KICAD_TYPE)
    return g


def write_graph(gen_g, filename: str = None, force_write: bool = False):
    if filename is not None:
        if force_write or not isfile(filename):
            g = gen_g()

            if g is None:
                raise CliException("internal error: graph generator returned None")

            bs = g.serialize(encoding='utf-8', format='turtle')
            with open(filename, "wb") as f:
                f.write(bs)
            info("Wrote %s" % filename)
        else:
            info("Skipped writing %s, already exists" % filename)
    else:
        g = gen_g()
        bs = g.serialize(encoding='utf-8', format='turtle')
        sys.stdout.buffer.write(bs)


_initNs = {
    "rdf": RDF,
    "rdfs": RDFS,
    "dk": digikey_rdf.DIGIKEY,
    "dk-attr-type": digikey_rdf.DIGIKEY_ATTRIBUTE_TYPE,
    "dk-attr-value": digikey_rdf.DIGIKEY_ATTRIBUTE_VALUE,
    "dk-part": digikey_rdf.DIGIKEY_PART,
    "dk-p-c": digikey_rdf.DIGIKEY_PRODUCT_CATEGORY,
    "kicad": kicad_rdf.KICAD,
    "kicad-type": kicad_rdf.KICAD_TYPE}


def sparql(g: Graph, query: str, init_bindings=None):
    if isinstance(g, sparqlstore.SPARQLStore):
        return g.query(query, initNs=_initNs, initBindings=init_bindings)
    else:
        q = prepareQuery(query, initNs=_initNs)
        return g.query(q, initBindings=init_bindings)


def write_config(config: configparser.ConfigParser):
    with open('.eda-rdf/config.ini', 'w') as configfile:
        config.write(configfile)


def read_config():
    try:
        with open('.eda-rdf/config.ini', 'r') as f:
            config = configparser.ConfigParser()
            config.read_file(f)
            return config
    except FileNotFoundError:
        raise CliException("Not a EDA-RDF project. Run eda-rdf init first.")