import sys
import logging
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


_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():
    with open('.eda-rdf/config.ini', 'r') as f:
        config = configparser.ConfigParser()
        config.read_file(f)
        return config