<?xml version="1.0" encoding="UTF-8" ?> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
         xmlns:red="http://redfoot.net/2002/10/red#">

<!--

This RDF contains the definition of terms used in rflo.py

TODO: finish creating schema for red elements.
TODO: remove hard coded 'localhost:9090'
TODO: 
  -->

<red:Python rdf:about="http://redfoot.net/2002/10/red#RedHandler">
    <rdfs:label>Define and run RedHandler</rdfs:label>
    <red:codestr>
<![CDATA[

import traceback, sys
import shutil, os

from rdflib.Namespace import Namespace
from rdflib.URIRef import URIRef
from rdflib.BNode import BNode
from rdflib.Literal import Literal
from rdflib.util import first, uniq
from rdflib.const import LABEL, TYPE
from rdflib.TripleStore import TripleStore
from redfootlib.util import encode_URI    

RED = Namespace("http://redfoot.net/2002/10/red#")


def facet_compile(store, facet):
    assert(facet!=None)
    code = first(store.objects(facet, RED["code"]))
    if not code:
        raise Exception("No code predicate found for Facet: ", facet)
    codestr = first(store.objects(code, RED["codestr"]))
    label = "%s (%s)" % (store.label(facet), facet)    
    if codestr:
        return compile(codestr+"\n", label, "exec")
    else:
        raise Exception("No codestr found for: %s" % label)


class RedHandler(object):
    def __init__(self, rednode, next_handler=None):
        self.rednode = rednode
        self.next_handler = next_handler
        self.host = None # If None use host from request, else use specified host
    
    def handle_request(self, request, response):
        host = self.host or request.get_header('Host')
        path_info = request.get_path_info()
        path = URIRef("http://%s%s" % (host, path_info))
        store = self.rednode.neighbourhood        

        facets = []
        facet = first(store.objects(path, RED["facet"]))        
        while facet:
            facets.append(facet)
            outer = first(store.objects(facet, RED["outer"]))        
            facet = outer

        root = dict()
        contexts = []
        def inner():
            if facets:
                facet = facets.pop()
                context = dict(contexts[-1])
                contexts.append(context)
                for param in store.objects(facet, RED["param"]):
                    name = first(store.objects(param, RED["name"]))
                    value = first(store.objects(param, RED["value"]))
                    context[str(name)] = value
                exec facet_compile(store, facet) in context
                contexts.pop()

        def display(facet, **args):
            context = dict(contexts[-1]) # TODO: option for no copy?
            for param in store.objects(facet, RED["param"]):
                name = first(store.objects(param, RED["name"]))
                value = first(store.objects(param, RED["value"]))
                context[str(name)] = value
            context.update(args)
            exec facet_compile(store, facet) in context
        context = {}
        context.update(globals())
        context.update(locals())
        contexts.append(context)

        if facets:
            inner()
        else:
            if self.next_handler:
                self.next_handler.handle_request(request, response)
            else:
                path_info = request.get_path_info()        
                file = path_info[1:]
                if os.path.exists(file) and os.path.isfile(file):
                    if file.endswith(".css"):
                        type = "text/css"
                    else:
                        type = "text/plain"
                    response.set_header("Content-Type", type)
                    source = open(file, 'rb')
                    destination = response
                    shutil.copyfileobj(source, destination)
                    source.close()
                else:
                    response.set_reply_code(404)
                    response.write("404")
        response.close()
]]>
    </red:codestr>
  </red:Python>


  <red:Python rdf:about="http://redfoot.net/2002/10/red#red_exec">
    <rdfs:label>red_exec</rdfs:label>
    <red:codestr>
<![CDATA[

RED = Namespace("http://redfoot.net/2002/10/red#")

redg, redl = globals(), locals()

def red_exec(uri):
    uri = URIRef(uri)
    codestr = first(rednode.neighbourhood.objects(uri, RED["codestr"]))
    if codestr:
        code = compile(codestr+"\n", uri, "exec")      
        exec code in redg, redl      
    else:
        print "codestr not found for: ", uri

]]>
    </red:codestr>
  </red:Python>



  <red:Python rdf:about="http://redfoot.net/2002/10/red#red_import">
    <rdfs:label>red_import</rdfs:label>
    <red:codestr>
<![CDATA[

def red_import(subject):
    import sys, new
    codestr = first(rednode.neighbourhood.objects(subject, RED["codestr"]))
    
    module_name = subject
    safe_module_name = "subject_%s" % hash(subject)
    
    module = sys.modules.get(module_name, None)
    if module:
        return module

    module = new.module(safe_module_name)
    module.__name__ = module_name # TODO: does this need to be safe_module_name? 
    module.__file__ = subject
    module.__ispkg__ = 0
    sys.modules[module_name] = module
    code = compile(codestr+"\n", subject, "exec")
    #exec code in module.__dict_
    for key, value in globals().items():
        module.__dict__[key] = value
    exec code in module.__dict__
    #exec code in sys.modules["__main__"].__dict__
    return sys.modules[module_name]

]]>
    </red:codestr>
  </red:Python>



  <rdf:Description rdf:about="http://redfoot.net/2002/10/red#Init">
    <rdfs:label>RFLO Init</rdfs:label>
    <rdfs:comment></rdfs:comment>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Resource"/>
  </rdf:Description>

  <rdf:Property rdf:about="http://redfoot.net/2002/10/red#code">
    <rdfs:label>code</rdfs:label>
    <rdfs:domain rdf:resource="http://redfoot.net/2002/10/red#Init"/>
    <rdfs:range rdf:resource="http://redfoot.net/2002/10/red#Python"/>    
  </rdf:Property>

  <rdf:Description rdf:about="http://redfoot.net/2002/10/red#Python">
    <rdfs:label>Python Code</rdfs:label>
    <rdfs:comment></rdfs:comment>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Resource"/>
  </rdf:Description>

  <rdf:Property rdf:about="http://redfoot.net/2002/10/red#codestr">
    <rdfs:label>code string</rdfs:label>
    <rdfs:domain rdf:resource="http://redfoot.net/2002/10/red#Init"/>
    <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/>
  </rdf:Property>

  <rdf:Description rdf:about="http://redfoot.net/2002/10/red#etc">
  </rdf:Description>

<red:Python rdf:about="http://redfoot.net/2002/10/red#XHTMLinRDF">
    <rdfs:label>Define and run RedHandler</rdfs:label>
    <red:codestr>
<![CDATA[

from traceback import print_exc
from xml.sax.saxutils import quoteattr, escape

from rdflib.URIRef import URIRef
from rdflib.Literal import Literal
from rdflib.Namespace import Namespace
from rdflib.BNode import BNode
from rdflib.const import TYPE, LABEL, COMMENT, RDFNS
from rdflib.util import first

RED = Namespace("http://redfoot.net/2002/10/red#")
RED2 = Namespace("http://redfoot.net/2002/08/XHTMLinRDF#")
ELEMENT = Namespace("http://redfoot.net/2002/08/XHTMLinRDF/element#")
ATTRIBUTE = Namespace("http://redfoot.net/2002/08/XHTMLinRDF/attribute#")

class XHTMLinRDF(object):
    def __init__(self, rednode):
        self.rednode = rednode
    
    def handle_request(self, request, response):
        store = self.rednode.neighbourhood
        context = {"request": request, "response": response,
                   "rednode": self.rednode}
        context.update(globals())

        def exec_module(uri, value, c=None):
            try:
                code = compile(value, uri, "exec")
                g = l = c or context
                exec code in g, l
            except:
                print '''\nContext:\n---\n%s\n---\n''' % value
                print_exc()

        def display_item(item, **args):
            element_name = None
            atts = {}
            for p, o in store.predicate_objects(item):
                if p==RED2["facet"] or p==RED["codestr"]:
                    c = dict(context)
                    c.update(args)
                    exec_module(item, "%s\n" % o, c)
                if p.startswith(ELEMENT):
                    element_name = p[len(ELEMENT):]
                    element_value = o
                elif p.startswith(ATTRIBUTE):
                    att_name = p[len(ATTRIBUTE):]
                    atts[att_name] = o
            if element_name:
                response.write("<%s" % element_name)
                for name, value in atts.items():
                    response.write(''' %s=%s''' % (name, quoteattr(value)))
                response.write(">")
                if isinstance(element_value, Literal):
                    response.write("%s" % escape(element_value))
                elif store.exists(element_value, TYPE, RDFNS["List"]):
                    display(element_value)
                response.write("</%s>" % element_name)

        context["display_item"] = display_item

        def display(subject):
            for item in store.items(subject):
                outer_html = first(store.objects(item, RED2["outer_html"]))
                if outer_html:
                    value = first(store.objects(outer_html, RED2["facet"])) or first(store.objects(outer_html, RED["codestr"]))
                    value = "%s\n" % value
                    context["inner_html"] = item
                    exec_module(item, value)
                else:
                    display_item(item)

        context["display"] = display

        path = URIRef("http://%s%s" % (request.get_header('Host'),
                                       request.get_path_info()))
        html = first(store.objects(path, ELEMENT["html"]))
        if html:
            response.write('''\
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
          "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
''')
            display(html)
            response.write('''\
</html>''')
        else:
            response.set_reply_code(404)
            response.write("No XHTML found for %s" % path)
        response.close()

]]>
    </red:codestr>
  </red:Python>

  <red:Python rdf:about="http://redfoot.net/2002/10/red#SpiderStore">
    <rdfs:label>Define and run RedHandler</rdfs:label>
    <red:codestr>
<![CDATA[
from __future__ import generators

import os
import threading

from time import sleep, time, gmtime, mktime

from rdflib.URIRef import URIRef
from rdflib.Literal import Literal
from rdflib.Namespace import Namespace
from rdflib.store.abstract import AbstractStore
from rdflib.TripleStore import TripleStore
from rdflib.util import first
from rdflib.const import TYPE

from date_time import date_time, parse_date_time

SECONDS_IN_DAY = 60*60*24


def _mkdir(newdir):
    # from: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/82465
    """works the way a good mkdir should :)
    - already exists, silently complete
    - regular file in the way, raise an exception
    - parent directory(ies) does not exist, make them as well
    """
    if os.path.isdir(newdir):
        pass
    elif os.path.isfile(newdir):
        raise OSError("a file with the same name as the desired " \
                      "dir, '%s', already exists." % newdir)
    else:
        head, tail = os.path.split(newdir)
        if head and not os.path.isdir(head):
            _mkdir(head)
        if tail:
            os.mkdir(newdir)

SPIDER = Namespace("http://redfoot.net/2002/07/examples/spider#")

class SpiderStore(AbstractStore):
    """
    A store that is the composition of a list of stores.
    """
    
    def __init__(self, directory="spider"):
        super(AbstractStore, self).__init__()
        self.__stores = {}        
        _mkdir(directory)
        self.directory = directory
        self.index = TripleStore()
        self.index.load(self.path("index.rdf"), None, 1)
        self.cache = TripleStore()

    def run(self):
        t = threading.Thread(target = self._run, args = ())
        t.setDaemon(1)
        t.start()

    def path(self, filename):
        return os.path.join(self.directory, filename)

    def _run(self):
        for url in self.index.subjects(TYPE, SPIDER["URL"]):
            if not (url, SPIDER["ignore"], Literal("YES")) in self.index:
                if not url in self.__stores:
                    filename = self.path(str(hash(url)))
                    if os.path.isfile(filename):
                        ts = TripleStore()
                        try:
                            ts.load(filename)
                            self.__stores[url] = ts
                            self.cache = None
                        except Exception, e:
                            print e
        while 1:
            for url in self.__stores.keys():
                if self.stale(url):
                    t = threading.Thread(target=self.update, args=(url,))
                    t.setDaemon(1)
                    t.start()
                    t.join(60)
                    # if t is still active t.stop()
            sleep(5)

    def stale(self, url):
        every = int(first(self.index.objects(SPIDER["every"])) or
                 str(SECONDS_IN_DAY))
        cached_on = first(self.index.objects(url, SPIDER["cached_on"]))
        if not cached_on or (time() - parse_date_time(cached_on)) > every:
            return 1
        else:
            return 0
            
    def update(self, url):
        if not isinstance(url, URIRef):
            url = URIRef(url)
        print "    updating: %s" % url
        if not url in self.__stores:
            self.index.add(url, TYPE, SPIDER["URL"])
        ts = TripleStore()
        ts.strict = 0
        try:
            self.index.remove_triples(url, SPIDER["exception"], None)            
            ts.load(url)
            if url.startswith("http://redfoot.net/") or url.startswith("http://eikeon.com/"):
                safe = 1
            else:
                safe = 0
            if not safe:
                FACET = URIRef("http://redfoot.net/2002/08/XHTMLinRDF#facet")
                CODESTR = URIRef("http://redfoot.net/2002/10/red#codestr")
                for s, p, o in ts:
                    if p==FACET or p==CODESTR:
                        ts.remove(s, p, o)
            self.__stores[url] = ts
            self.cache = None
            ts.save(self.path(str(hash(url))))            
        except Exception, e:
            print e
            self.index.add(url, SPIDER["exception"], Literal("%s" % e))
        self.index.remove_triples(url, SPIDER["cached_on"], None)
        self.index.add(url, SPIDER["cached_on"], Literal(date_time()))
        
    def remove(self, url):
        if not isinstance(url, URIRef):
            url = URIRef(url)
        if url in self.__stores:
            del self.__stores[url]
            self.cache = None

    def triples(self, subject, predicate, object):
        if self.cache==None:
            self.cache = cache = TripleStore()
            for s, p, o in self.index.triples(None, None, None):
                cache.add(s, p, o)
            for store in self.__stores.values():
                for s, p, o in store.triples(None, None, None):
                    cache.add(s, p, o)
        for triple in self.cache.triples(subject, predicate, object):
            yield triple

    def save(self, location=None, uri=None):
        self.index.save(location, uri)

]]>
    </red:codestr>
  </red:Python>

</rdf:RDF>