#!python

import sys, getopt

try:
    import rdflib
    import rdf.sir # To check that rdflib >= 1.1.x is installed
except:
    print """\
RDFLib 1.1.x must be installed for Redfoot to run.
See, http://rdflib.net/ for information on RDFLib."""
    
from rdf.sir import URIRef, Literal, BNode, Namespace
from rdf.sir import TYPE, LITERAL, RESOURCE, RANGE

from rdflib import __version__
from rdflib.util import first
from rdflib.TripleStore import TripleStore
from rdflib.store.Resources import Resource

RED = Namespace("http://redfoot.net/2002/10/red#")
CODE = RED["code"]
CODESTR = RED["codestr"]

REDFOOT = Namespace("http://redfoot.net/2002/11/redfoot#")
RELEASE = REDFOOT["Release"]
CONFIG = REDFOOT["config"]
REDFOOT_LOCATION = REDFOOT["redfoot_location"]
REDNODE_LOCATION = REDFOOT["rednode_location"]
REDNODE_MAIN = REDFOOT["rednode_main"]

class Redfoot(TripleStore):
    def __init__(self):
        super(Redfoot, self).__init__()
        self.context = dict(globals())
        self.context['__name__'] = "Redfoot_Context"
        self.context["redfoot"] = self
        self[CODESTR][RANGE] = LITERAL                    

    def execute(self, resource):
        if not isinstance(resource, Resource):
            resource = Resource(URIRef(resource), self)
        codestr = resource[CODESTR]
        if codestr==None:
            if isinstance(resource.id, URIRef):
               #url, frag = urldefrag(uri)
               self.load(resource.id)
               codestr = resource[CODESTR]
        if isinstance(codestr, Literal):
            label = "exec_code: %s (%s)" % (self.label(resource.id), resource)
            code = compile(codestr+"\n", label, "exec")
            exec code in self.context
        elif isinstance(codestr, BNode):
            assert self[CODESTR][RANGE] == LITERAL            
        else:
            print "No codestr found for: ", resource

def usage(msg):
    print msg, """

USAGE: redfoot.py [--install]
                  [--redfoot <file_name>]
                  [--rednode <file_name>]
                  [--main <uri>]

    options:
           [--redfoot <file_name>] defaults to redfoot.rdf
           [--rednode <file_name>] defaults to redfoot.fs

           [--main <uri>] Sets the uri Redfoot will exec upon startup
                          (should be of type red:Init).

           [-h,--help]

"""    
 
print """Redfoot found RDFLib version: %s""" % __version__    


def main(optlist, args):
    redfoot = Redfoot()
    redfoot[REDFOOT_LOCATION][RANGE] = LITERAL
    redfoot[REDNODE_LOCATION][RANGE] = LITERAL
    redfoot[REDNODE_MAIN][RANGE] = RESOURCE    
    config = redfoot[CONFIG] # ask the store for the config resource
    install = None
    for opt, value in optlist:
        if opt=="--install":
            install = value
        elif opt=="--redfoot":
            config[REDFOOT_LOCATION] = Literal(value)
        elif opt=="--rednode":
            config[REDNODE_LOCATION] = Literal(value)            
        elif opt=="--main":
            config[REDNODE_MAIN] = URIRef(value)            
        elif opt=="--releases":            
            # TODO: load list from RDF file and display                
            #redfoot.load("http://redfoot.net/versions")
            # TODO: remove hard coded list
            print """\

See http://redfoot.net/2002/releases for a list of available version.

Then use python2.2 redfoot.py --install=http://redfoot.net/2002/xx/xx/redfoot-1.x.x.rdf

    """
            return
    uri = config[REDFOOT_LOCATION] or "redfoot.rdf"
    redfoot.location = uri    
    if install:
        print "loading:", value
        redfoot.load(install)
        redfoot.save()
    else:
        redfoot.load(uri, None, 1)        
    
    releases = list(redfoot.subjects(TYPE, RELEASE))
    if not releases:
        # TODO: probably better to just dump out a list of available
        # versions to install... along with a --install-latest option
        RELEASES = Namespace("http://redfoot.net/2002/releases#")                
        store = TripleStore()
        store.load(RELEASES)
        latest = store[RELEASES["Releases"]][RELEASES["latest"]]
        print "Installing: %s" % latest.id
        redfoot.load(latest.id)
    release = first(redfoot.subjects(TYPE, RELEASE))
    # TODO: warn or allow choice when more than one release installed.
    redfoot.execute(redfoot[release][CODE])


try:
    optlist, args = getopt.getopt(sys.argv[1:], 'h:', ["help", "install=", "releases", "redfoot=", "rednode=", "main="])
    main(optlist, args)
except getopt.GetoptError, msg:
    usage(msg)
    sys.exit(-1)