import os.path

from module import Module

from rdflib import Graph, term
from rdflib.namespace import RDF, OWL
# scrapy api
from twisted.internet import reactor
from scrapy.crawler import Crawler, CrawlerProcess
from scrapy.settings import Settings
import imp

from . import defsettings

class Scrapy(Module):
    def __init__(self, mInstanceIRI, moduleDir):
        Module.__init__(self, "http://topbraid.org/sparqlmotionlib#scrapy", mInstanceIRI, moduleDir)
        self.executable = 'scrapy'

    def spider_closing(spider):
        """Activates on spider closed signal"""
        # log.msg("Closing reactor", level=log.INFO)
        reactor.stop()

    def run(self):
        # log.start(loglevel=log.DEBUG)

        settings = Settings()
        settings.setmodule(defsettings, priority='default')
        settings.set("FEED_URI", "stdout:")
        settings.set("FEED_EXPORTERS", {"turtle": 't_scrapy.turtle_exporter.TurtleExporter'})
        settings.set("FEED_FORMAT", "turtle")

        spiderFile = self.moduleDir + "/" + self.getParameter('spiderFile')
        spiderName = self.getParameter('spiderName')
        # className = "letecky_rejstrik"
        # moduleClassImplementation = pipeline.value(subject=moduleClass,predicate=term.URIRef(DP+"implementation"))
        # moduleName,className = moduleClassImplementation[:moduleClassImplementation.rfind('.')], moduleClassImplementation[moduleClassImplementation.rfind('.')+1:]
        # moduleName = moduleDirs[moduleClass]+"."+moduleName
        # class_ = getattr(importlib.import_module(moduleName), className)
        # instance = class_()
        module_ = imp.load_source(spiderName, spiderFile)
        class_ = getattr(module_, spiderName)
        # crawl responsibly

        process = CrawlerProcess(settings)

        crawler = Crawler(class_, settings)
        process.crawl(crawler)
        process.start()
# --set=HTTPCACHE_DIR=$PAGES_DIR
        self.outputGraph = Graph()
        self.outputGraph.add((term.URIRef(crawler.spider.ONTOLOGY_IRI), RDF.type, OWL.Ontology))
        self.outputGraph.bind(crawler.spider.PREFIX, crawler.spider.ONTOLOGY_IRI+"/")
        self.outputGraph.bind(crawler.spider.PREFIX+"-model",crawler.spider.ONTOLOGY_IRI+"/model/")

        self.outputGraph = self.outputGraph + crawler.extensions.methods['open_spider'][0].im_self.slot.exporter.g;

    #
    # def item_crawled(self, item):
    #     self.outputGraph(item.serialize(self.g, item.self._get_serialized_fields(item)))
    #
    # def _get_serialized_fields(self, item, default_value=None, include_empty=None):
    #     """Return the fields to export as an iterable of tuples
    #     (name, serialized_value)
    #     """
    #     if include_empty is None:
    #         include_empty = self.export_empty_fields
    #     if self.fields_to_export is None:
    #         if include_empty and not isinstance(item, dict):
    #             field_iter = six.iterkeys(item.fields)
    #         else:
    #             field_iter = six.iterkeys(item)
    #     else:
    #         if include_empty:
    #             field_iter = self.fields_to_export
    #         else:
    #             field_iter = (x for x in self.fields_to_export if x in item)
    #
    #     for field_name in field_iter:
    #         if field_name in item:
    #             field = {} if isinstance(item, dict) else item.fields[field_name]
    #             value = self.serialize_field(field, field_name, item[field_name])
    #         else:
    #             value = default_value
    #
    #         yield field_name, value
            # crawler.start()
            # reactor.run()

            # scrapyRoot = self.moduleDir + "/" + self.getParameter('scrapySpider')
            #
            # bashCommand = self.executable + " crawl " \
            #               + scrapySpider \
            #               + " -o "
            #               + " " + path \
            #               + " " + inputFile


            # scrapy
            # crawl
            # lr - o $DATA_DIR / output.csv - -set = HTTPCACHE_DIR =$PAGES_DIR
            # cp - R $DIR /.scrapy /$PAGES_DIR $PAGES_DIR
            #
            # print bashCommand
            #
            # process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
            #
            # self.outputGraph = Graph()
            # self.outputGraph.parse(data=process.stdout.read(), format='n3')
            # self.outputGraph.add((ontology, RDF.type, OWL.Ontology))
            #
            # DATE = `date + % Y - % m - % d_ % H: % M: % S
            #     `
            #     CURR_DIR = `pwd`
            #
            #     cd $DIR / src
            #
            #     PAGES_DIR =$DIR / out /$DATE / pages
            #     DATA_DIR =$DIR / out /$DATE / data
            #
            #     # RUN SCRAPY
            #     echo
            #     "* SCRAPING"
            #     scrapy
            #     crawl
            #     lr - o $DATA_DIR / output.csv - -set = HTTPCACHE_DIR =$PAGES_DIR
            #     cp - R $DIR /.scrapy /$PAGES_DIR $PAGES_DIR
            #
            #     cd $CURR_DIR
            #
            #     g = Graph()
            #     g.parse(inputFile,format="n3")
            #     q = g.query(open(os.path.abspath(os.path.dirname(__file__)+"/void.rq")))















            # self.outputGraph = Graph()
            # self.outputGraph.bind("void",URIRef("http://rdfs.org/ns/void/"))
            # for i in q:
            #     self.outputGraph.add(i)

            # self.outputGraph.parse(data=process.stdout.read(), format='n3')
            # self.outputGraph.add((g.subjects(RDF.type,OWL.Ontology).next(), RDF.type, OWL.Ontology))