#!/usr/bin/python
"""Notation3 Pretty Printer."""

__author__ = 'Sean B. Palmer'
__license__ = 'Copyright (C) 2002 Sean B. Palmer. GNU GPL 2'

from eep3 import api
import sys, rdfn3

def serialize(store): 
   result = ''
   # print the formulae, and then the triples

   formulae = {}
   for formula in store.formulae(): 
      f = store[formula]
      f = '{  '+' .\n   '.join(['%s %s %s' % (t[0], t[1], t[2]) 
               for t in f])+' }'
      formulae[formula] = f

   predicates = store[None]._triples.keys()
   # predicates.sort()
   # predicates.reverse()
   for p in predicates: 
      subjects = store[None]._triples[p].keys()
      # subjects.sort()
      for s in subjects: 
         objects = store[None]._triples[p][s]
         # objects.sort()
         for o in objects: 
            if s in formulae.keys(): subj = formulae[s]
            else: subj = s[:]
            if p in formulae.keys(): pred = formulae[p]
            else: pred = p[:]
            if o in formulae.keys(): obj = formulae[o]
            else: obj = o[:]
            result += '%s %s %s .\n' % (subj, pred, obj)
   return result.strip()

# N3 Parser for SW API

class N3Parser: 
   def __init__(self, store=None):
      if store is None: store = api.Store()
      self.store = store
      self.bNodes = {}

   def n(self, node): 
      V, T = 0, 1
      if node[T] == rdfn3.URI: return api.Article('<'+node[V]+'>')
      if node[T] == rdfn3.EXI: return api.Article('_:'+node[V])
      if node[T] == rdfn3.UNI: return api.Article('?'+node[V])
      if node[T] == rdfn3.LIT: return api.Article('"'+node[V]+'"')
	
   def startDoc(self): pass
   def endDoc(self): pass
   def bind(self, pfx, val): pass
   def makeComment(self, str): pass

   def makeStatement(self, (subj, pred, obj, scp)): 
      if scp is 'RootFormula': 
         if None not in self.store.formulae(): 
            self.store[None] = api.TripleStore()
         self.store[None].append(
            api.Triple([self.n(subj), self.n(pred), self.n(obj)])
         )
      else: 
         if `self.n(scp)` not in self.store.formulae(): 
            self.store[`self.n(scp)`] = api.TripleStore()
         self.store[`self.n(scp)`].append(
            api.Triple([self.n(subj), self.n(pred), self.n(obj)])
         )
		
def parse(text, baseURI, store=None): 
   sink = N3Parser(store)
   text = rdfn3.preProcess(text)
   p = rdfn3.Parser(rdfn3.scanner(text), sink, baseURI)
   p.document()
   return sink.store

if __name__=="__main__": 
   if len(sys.argv) > 1: 
      try: s = open(sys.argv[1], 'r').read()
      except: 
         import urllib2
         s = urllib2.urlopen(sys.argv[1]).read()
      x = parse(s, '') # sys.argv[1])
      # from eep3 import ntuples
      # print ntuples.serialize(x)
      print serialize(x)
   else: print __doc__