(ns eu.dnetlib.dlms.ast
  (:import (eu.dnetlib.dlms.jdbc.ast 
	    Assign BinaryPredicate Call DeclInit Expression Inst Lit IntegerLit NumberLit Predicate Ref RunExpr Select SimplePredicate StringLit Struct 
	    StructKeyValue XPathComponent XPathExpr XPath Parameter CollectionNode DateLit StaticTagExpression RelationPatternTagExpression
	    StarTagExpression SelectOneExpression
	    )))
	    
(defn make-run-expr [e]
  (new RunExpr e))

(defn make-integer-lit [n]
  (new IntegerLit n))

(defn make-string-lit [n]
  (new StringLit n))
  
(defn make-date-lit [n]
  (new DateLit n))

(defn make-reference [n]
  (new Ref n))

(defn make-parameter [n]
  (new Parameter n))

(defn make-collection [values]
  (new CollectionNode values))

(defn make-struct [defs]
  (new Struct defs))

(defn make-struct-def [l v]
  (new StructKeyValue l v))

(defn make-instantiation [set args]
  (new Inst set args))

(defn make-call [target method args]
  (new Call target method args))

(defn make-static-tag-expression [ts]
  (new StaticTagExpression ts))
  
(defn make-relation-pattern [l r]
  (new RelationPatternTagExpression l r))
  
(defn make-star-tag []
  (new StarTagExpression))

(defn make-select [fields xp l]
  (new Select fields xp l))

(defn make-xpath [comps]
  (new XPath comps))

(defn make-tagexp [axis tag pred]
  [tag pred axis])

(defn make-simple-predicate [xp]
  (new SimplePredicate xp))

(defn make-binary-predicate [op xp expr]
  (new BinaryPredicate op xp expr))

(defn make-xpath-expression [ex]
  (new XPathExpr ex))

(defn make-decl-init [typ name e]
  (new DeclInit typ name e))

(defn make-assign [name e]
  (new Assign name e))

(defn make-expression-select [s] 
  (new SelectOneExpression s))

(defn make-qualified-tagexp [q [tag pred axis]]
   (new XPathComponent q tag pred axis))
   
(defn default-tagexp-qualifier [t]
   (let [qual  (make-qualified-tagexp "/" t)
         [tag _ _] t]
   	(if (= (first (.getTagNames tag nil)) ".") ; hack
   	    [qual]
   	    (vector (make-qualified-tagexp "/" [(new StaticTagExpression ["."]) nil nil]) qual))))

(defn rooted-tagexp-qualifier [t]
    [(make-qualified-tagexp "//" t)])