module Transform where
import "Utils"
import "XML"
import "N3Parser"
import "Array"
import "LoadTree"
import "TripleData"
import "Observe"
import "GenerateDB"
import "ToN3"

-- Author: G.Naudts. Mail: naudts_vannoten@yahoo.com.


-- transform from the output of generateDB to the format of N3Engine.hs

-- data structure defined in Unify.hs
-- data Triple = Triple (Subject, Predicate, Object) | Rule Rule | TripleNil
--   deriving (Show, Eq)

-- type Subject = Resource
-- type Predicate = Resource
-- type Object = Resource

-- data Resource = URI String | Literal String | TripleSet TripleSet |
--                 Var Vare | ResNil
--                 deriving (Show,Eq)

-- type TripleSet = [Triple]

-- data Vare = UVar String | EVar String | GVar String | GEVar String
--            deriving (Show,Eq)

-- type DB = [TripleSet]
-- type Query = [TripleSet]
 
-- type Rule= (Antecedents, Consequent, Int)
-- type Antecedents = TripleSet
-- type Consequent = Triple

helpTree = Tag("semTree", [], "")

testTrans = transformDB ["authen.axiom.n3", "authen.lemma.n3"]

-- This generates a database. Input is a list of filenames;
-- output is a database and a query as a list of triples.
transformDB :: [String] -> IO()
transformDB filenames = do listF <- sequence (map readFile filenames)
                           putStr (getN3Out listF)

getN3Out inputs = dbToN3 dbo ++ dbToN3 qo
   where (dbo, qo) = transTree (mergeInput inputs helpTree)


-- transform the transTree into two lists of triples: db and query
transTree :: XMLTree -> ([TripleSet], [TripleSet])
transTree tree = (afin, qfin)
        where axioms = getChildByName tree "axioms"
              query = getChildByName tree "query"
              ats = getDirectChildrenByName axioms "TripleSet"
              qts = getDirectChildrenByName query "TripleSet"
              afin = map (defoldTripleSet.transTripleSet) ats 
              qfin = map (defoldTripleSet.transTripleSet) qts 

-- transform a resource that is not a TripleSet
transUri :: XMLTree -> Resource
transUri Empty = ResNil
transUri res@(Tag(name, _, content)) 
          |name == "URI" && s1 == "literal" = Literal content
          |name == "URI" = URI content
          |name == "Var" = Var (UVar content)
          |name == "EVar" = Var (EVar content)
          |name == "GVar" = Var (GVar content)
          |name == "GEVar" = Var (GEVar content)
          where (bool, s1, rest) = parseUntil ' ' content

-- get the resource of the subject, verb, object
-- check for a rule
-- rules recieve all a temporary number 1
-- they are numbered in module Subgraph.hs
transTriple :: XMLTree -> Triple
transTriple t 
        |bool              = (Rule(antecedents, consequent, 1))
        |bv1 && bv2 && bv3 = Triple(subjectOut, verbOut, objectOut)
        |bv2 && bv3        = Triple(subject1, verbOut, objectOut)
        |bv3               = Triple(subject1, verb1, objectOut)
        |bv1 && bv3        = Triple(subjectOut, verb1, objectOut)
        |bv1 && bv2        = Triple(subjectOut, verbOut, object1)
        |bv2               = Triple(subject1, verbOut, object1)
        |bv1               = Triple(subjectOut, verb1, object1)
        |otherwise         = Triple(subject1, verb1, object1)
        where -- first check for rule
              (bool, antecedents, consequent) = checkForRule t
              -- get subject
              subjectOut = transUri (getUriVar t)
              term1 = getDirectChildrenByName t "Subject"
              bv1 = term1 == []
              subject1 = TripleSet (transTripleSet1 term1)
              -- get verb
              verb = getChildByName t "Verb"
              term2 = getDirectChildrenByName verb "Subject"
              bv2 = term2 == []
              verbOut = transUri (getUriVar verb)
              verb1 = TripleSet (transTripleSet1 term2)
              -- get object 
              object = getChildByName verb "Object"
              term3 = getDirectChildrenByName object "Subject"
              bv3 = term3 == []
              objectOut = transUri (getUriVar object)
              object1 = TripleSet (transTripleSet1 term3)

-- gets uri, literal or variable
getUriVar :: XMLTree -> XMLTree
getUriVar t
        |bv1 = c1
        |bv2 = c2
        |bv3 = c3
        |bv4 = c4
        |bv5 = c5
        |otherwise = Empty
        where c1 = getChildByName t "URI"
              bv1 = not (c1 == Empty)
              c2 = getChildByName t "Var"
              bv2 = not (c2 == Empty)
              c3 = getChildByName t "EVar"
              bv3 = not (c3 == Empty)
              c4 = getChildByName t "GVar"
              bv4 = not (c4 == Empty)
              c5 = getChildByName t "GEVar"
              bv5 = not (c5 == Empty)

transTripleSet :: XMLTree -> TripleSet
transTripleSet ts = triplesOut
        where triples = getDirectChildrenByName ts "Subject"
              triplesOut = defoldTripleSet [transTriple (x)|x <- triples]

transTripleSet1 :: [XMLTree] -> TripleSet
transTripleSet1 ts = triplesOut
        where triplesOut = [transTriple x|x <- ts]

testCheckForRule = show (checkForRule testRule)

-- checks whether this triple is a rule
-- and returns a boolean, the antecedents and the consequent.
checkForRule :: XMLTree -> (Bool, Antecedents, Consequent)
checkForRule tree = searchLogImplies subjects
        where subjects = getChildrenByName tree "Subject"
              -- search the subject with verb logImplies
              -- and return a boolean, the antecedents and the consequent
              searchLogImplies :: [XMLTree] -> (Bool, Antecedents, Consequent)
              searchLogImplies [] = (False, [], [])
              searchLogImplies subjects@(x:xs)
                 |bool = (True, antecedents, consequent)
                 |otherwise = searchLogImplies xs 
                 where verbs = getDirectChildrenByName x "Verb"
                       -- the consequent is the subject child of v
                       (bool, v) = checkImplies verbs
                       o = getChildByName v "Object"
                       c = Tag ("TripleSet", getDirectChildrenByName o "Subject", "")
                       consequent = transTripleSet c
                       ants = Tag("TripleSet", getDirectChildrenByName x "Subject", "")
                       antecedents = transTripleSet ants
                       -- checkImplies test if the verb is logImplies
                       -- and returns it
                       checkImplies [] = (False, Empty)
                       checkImplies (x:xs)
                           |getFullUri x == logImplies = (True, x)
                           |otherwise = checkImplies xs

-- get the string describing an Uri
getUri :: XMLTree -> String
getUri Empty = ""
getUri t = content
        where uri@(Tag(_, _, content)) = getChildByName t "URI"
getUri any = ""

-- get the string describing an Uri
getFullUri :: XMLTree -> String
getFullUri Empty = ""
getFullUri t
        |bv1 = ""
        |otherwise = r
        where u = getChildByName t "URI"
              bv1 = u == Empty
              uri@(Tag(_, _, content)) = u
              (bool, s ,r) = parseUntil ' ' content
getFullUri any = ""

testDefoldTriple = show (defoldTriple tripleC)

defoldTriple :: Triple -> TripleSet
defoldTriple (Triple(s, p, o)) =
      ts1 ++ [Triple (s1, p, o1)] ++ ts2
      where (s1, ts1) = defoldSubject s
            (o1, ts2) = defoldObject o
defoldTriple (Rule (ants, seq, nr)) = [Rule (defoldTripleSet ants, seq, nr)]
defoldTriple t = [t]

defoldSubject :: Resource -> (Resource, TripleSet)
defoldSubject (TripleSet []) = (ResNil, [])
defoldSubject (TripleSet (x:xs)) =
    (o, defoldTripleSet (xs))
    where Triple (s, p, o) = last (x:xs)
defoldSubject s = (s, [])

defoldObject :: Resource -> (Resource, TripleSet)
defoldObject (TripleSet []) = (ResNil, [])
defoldObject (TripleSet (x:xs)) =
    (s, defoldTripleSet (x:xs))
    where Triple(s, p, o) = x
defoldObject o = (o, [])

defoldTripleSet :: TripleSet -> TripleSet
defoldTripleSet ts = concat (map defoldTriple ts)
                               
tt1 = transformDB ["animal.n3", "animal-simple.n3"]         -- ok      
tt2 = transformDB ["authen.axiom.n3","authen.lemma.n3"]     -- ok
tt3 = transformDB ["danb.n3", "danb-query.n3"]              -- ok
tt4 = transformDB ["danc.n3", "danc-query.n3"]              -- ok
tt5 = transformDB ["gedcom-facts.n3", "gedcom-relations.n3", "gedcom-query.n3"]  -- ok   
tt6 = transformDB ["graph.axiom.n3", "graph.lemma.n3"]      -- ok
tt7 = transformDB ["lists.n3", "lists-query.n3"]            -- ok
tt8 = transformDB ["rdf-facts.n3", "rdf-rules.n3", "rdf-query.n3"]  -- ok
tt9 = transformDB ["rdfc25May-test.n3", "rdfc25May.n3"]
tt10 = transformDB ["rdfs-rules.n3", "rdfs-query.n3"]        -- ok
tt11 = transformDB ["russell.axiom.n3", "russell.lemma.n3"]  
tt12 = transformDB ["subclass.n3", "subclass-query.n3"]      -- ok
tt13 = transformDB ["subprop.n3", "subprop-query.n3"]        -- ok
tt14 = transformDB ["test-test.n3", "test.n3"]               -- ok
tt15 = transformDB ["tpoint-all.n3", "tpoint-facts.n3", "tpoint.n3", "tpoint-query.n3"] 
tt16 = transformDB ["varprop.n3", "varprop-query.n3"]           -- ok
tt17 = transformDB ["ziv.n3", "ziv-query.n3"]                   -- ok
tt18 = transformDB ["wol-facts.n3", "wol-rules.n3", "wol-query.n3"] -- ok
tt19 = transformDB ["vogel.l.n3", "vogel.q.n3"]   -- ok
tt20 = transformDB ["boole.axiom.n3", "boole.lemma.n3"]         -- ok
tt21 = transformDB ["induction.axiom.n3", "induction.query.n3"] -- ok
tt22 = transformDB ["Owls.n3", "owls.query.n3"]                 -- ok
tt23 = transformDB ["logic.a.n3", "logic.q.n3"]                 -- ok
tt24 = transformDB ["unif.n3","unif.q.n3"]                      -- ok
tt25 = transformDB ["ontology.axiom.n3", "ontology.query.n3"]   -- ok
tt26 = transformDB ["ontology1.axiom.n3", "ontology1.query.n3"] -- ok
tt27 = transformDB ["gedcom-simple.n3", "gedcom-qsimple.n3"]
tt28 = transformDB ["owns.n3", "owns.q.n3"]
tt29 = transformDB ["ontology2.axiom.n3", "ontology.query.n3"]
tt30 = transformDB ["eq.a.n3", "eq.q.n3"]
tt31 = transformDB ["schedRDF.a.n3", "hosts.a.n3", "schedRDF.q.n3"]

-- testdata
testTestTreeT = putStr (printXml testTreeT "")

testTreeT = loadDB ppa7

testTestQuery = putStr (printXml testQuery "")

testQuery = loadDB ppa8

testTestDB = putStr (printTreeList testDB "")

testTestQueryDB = putStr (printTreeList testQueryDB "")

queryTriple = x                                      
   where (x:xs) = testQueryDB

-- build a query for testing.
testQueryDB :: [XMLTree]
testQueryDB = getChildrenByName (markAllVariables db [] False) "TripleSet"  
   where db = testQuery

-- build a database for testing.
-- testDB :: [XMLTree]
testDB = getChildrenByName (markAllVariables db varList True) "TripleSet" 
   where db = testTreeT
         varList = (getVariables db)

testTestRule = putStr (printXml testRule "")

testRule = x
   where (x:xs) = reverse testDB