require 'configatron'
require 'json'

class Tripleizer
  def initialize output=nil
    @object_properties = configatron.objectProperties.to_hash
    @object_namespaces = configatron.namespaces.to_hash
    @class_map = configatron.classMap.to_hash
    @output=output
    @version="0.0.1"
    @json_hash = Hash.new
    @output_json = nil;
    @base_uri = "www.base_uri"
  end

  attr_accessor :output
  attr_reader :version
  attr_accessor :output_json
  attr_accessor :base_uri


#  def all request,headers
#    #get all models
#    #render all models
#    ret=""
#    t = Tripleizer.new
#    $base_uri= t.uri request.env['REQUEST_URI'].to_s[0..-5]
#    #t.output_json = request.content_type.try(:to_sym)==:json
#    #content_type =   t.output_json   ? 'application/json' :  'text/plain'
#    ret << t.write_rdf_head
#    model_groups =  eval("configatron.query").to_hash
#    model_groups.each do |model_group_name,model_group|
#      model_group.each do |model_name,model_attributes|
#        if model_name.to_s =="sql_query"
#          ret<<t.write_sql(model_group_name,model_attributes,t.output)
#        else
#          ret<<t.write_model(model_name,model_group_name)
#        end
#      end
#    end
#    t_metadata = TriplifyMetadata.new
#    ret<<t_metadata.write_metadata(t).to_s
#    ret
#  end
  
  def rdf rdf_start_class , var=[]
    class_map = Hash.new
    var.each do  |c|
      class_map[c[0].class.to_s]= c
    end
    rdf_string =""
    #get configuration start ->classes
    m = search_models(rdf_start_class)

    m.values[0].each do |mod,attributes|
      unless mod.eql?("sql_query")
        t_mod = Model.new(mod, rdf_start_class, class_map[mod.to_s])
        #if sql...
        key = t_mod.get_key
        t_mod.get_rows.each do |item|
          rdf_string<<rdf_by_id(mod,rdf_start_class,eval("item.#{key}"))
        end
      end
    end
    rdf_string
  end

  #
  def rdf_by_id model_name, class_name, id
    puts model_name
    ret=""
    #TODO...mehrere Models

    model = Model.new(model_name,class_name)   
    data_types= model.get_datatypes
    #build hash
    item=model.get_row_by_id(id).first
    line = Hash.new
    subline = Hash.new
    remove =Array.new

    model.model_attributes.each do |k,v|
      if v.to_s.include?("*") || v.to_s[0..9]=="new_model("
        remove.push(k.to_s) unless remove.index(k.to_s)
        m_class,field=v.to_s.split("*")
        ref_pred,ref_model=k.to_s.split"->"
        if  v.to_s[0..5]=="MODEL("
          m_class.gsub!("MODEL(","Model.new(")
          submodel= eval(m_class.to_s)
          sub_rows= submodel.get_rows
        else
          submodel= eval("item.#{m_class.to_s.downcase}")
          sub_rows= submodel
        end
        sub_rows.each do |subitem|          
          sub_id=eval("subitem.#{field}")  
          ret<< make_triples({:id=>id,k=>sub_id  },class_name,"",Array.new,false)
          ret<<rdf_by_id( submodel.model_name ? submodel.model_name : m_class , ref_model,sub_id).to_s
        end
      else    
        write_line = true;
        #FIXME: use last "." split
        if k.to_s.include? "->"
          line[k.to_s]=eval("item."+v.to_s)
          #write key ref 
          ref_pred,ref_model=k.to_s.split"->"   
          #write referenced model
          #ret<< make_triples({:id=>id,k=>sub_id  },class_name,"",Array.new,false)
          m= search_models(ref_model)
          m.values[0].each do |mod,val|
            ret<<(rdf_by_id mod, ref_model, eval("item."+v.to_s)).to_s
          end
        else        
          if v.to_s.include? "."
            write_line = nil unless eval("item."+v.to_s.downcase.split(".")[0])
          end
          begin
            if v.to_s[0..5]=="CONST("
              line[k.to_s],data_types[k.to_s]= model.get_const(v)
              #datatype to uri format
              if data_types[k.to_s]=="LINK"
                line[k.to_s] =uri line[k.to_s]
                data_types.delete k.to_s
                @object_properties[k.to_s]="t"
              else
                data_types[k.to_s] = uri(data_types[k.to_s])
              end
            else
              line[k.to_s]=eval("item."+v.to_s) if write_line

            end
          rescue Exception => ex
            line[k.to_s]=v.to_s if write_line
          end
        end
      end
      # end
    end
    extract_id_line(model.model_attributes, line, item,data_types)
    remove.each { |rem_attrib|  line.delete(rem_attrib) }
    #get triples of row
    ret<<make_triples(line, class_name , "", data_types)
    #render :text =>  t.make_triples(c1, controller , "", t.dbd_types)
    ret
  end

  # rdfa generation starts here
  def get_rdfa rdf_start_class , var=[]
    #write namespace
    "<div #{@object_namespaces.collect {|pre,ns| "xmlns:"<<pre.to_s<<"=\""<<ns.to_s<<"\" " }}>\n #{get_rdfa_root(rdf_start_class,var)} </div>"
  end

  # the root rdf node
  def get_rdfa_root rdf_start_class , var=[]
    #map each var on its classname
    rdfa_string = ""
    class_map = Hash.new
    var.each do  |c|
      class_map[c[0].class.to_s]= c
    end

    #get configuration start ->classes
    m = search_models(rdf_start_class)

    m.values[0].each do |mod,attributes|
      unless mod.eql?("sql_query")
        t_mod = Model.new(mod, rdf_start_class, class_map[mod.to_s])
        #if sql...
        key = t_mod.get_key
        t_mod.get_rows.each do |item|
          rdfa_string<<get_rdfa_by_id(rdf_start_class,eval("item.#{key}"))
        end
      end
    end
    rdfa_string
  end

  # generate RDFa tags by a specified ID
  def get_rdfa_by_id rdf_start_class , id
    #map each var on its classname
    id = id.to_s
    rdfa_string = "<div  about=\"#{rdf_start_class+"/"<<id}\" typeof=\"#{@class_map[rdf_start_class.to_sym]}\">\n"
    #get configuration start ->classes
    m = search_models(rdf_start_class)
    m.values[0].each do |mod,attributes|
      unless mod.to_s.eql?("sql_query")
        t_mod = Model.new(mod, rdf_start_class)
        #if sql...
        item=t_mod.get_row_by_id(id).first
        t_mod.model_attributes.each do |name,link_field|
          #property
          #link to other ress
          if name.to_s.include? "->"
            m_class,role_mod = name.to_s.split "->"

            if role_mod.eql?("sql_query")
              hello=""
            else
              if link_field.include?("*")
                field_class,field= link_field.to_s.split("*")
                if field_class.to_s[0..5]=="Model("
                  field_class.gsub!("MODEL(","Model.new(")
                  submodel= eval(field_class.to_s).get_rows
                  rdfa_string<<"<div rel=\"#{m_class}\">\n"
                  submodel.each do |line|                    
                    rdfa_string<<get_rdfa_by_id(role_mod , eval("line.#{field.to_s}"))                    
                  end
                  rdfa_string<<"</div>\n"
                else
                  subitem =  eval("item.#{field_class}")
                  rdfa_string<<"<div rel=\"#{m_class}\">\n"
                  subitem.each do |subline|                    
                    rdfa_string<<  get_rdfa_by_id(role_mod , eval("subline.#{field.to_s}"))                   
                  end 
                  rdfa_string<<"</div>\n"
                end
              else
                rdfa_string<<"<div rel=\"#{m_class}\">\n"
                rdfa_string << get_rdfa_by_id(role_mod , eval("item.#{link_field.to_s}"))
                rdfa_string<<"</div>\n"
              end
            end
          else
            write=true
            #just a property
            #CONST(
            #Model(
            if link_field.to_s[0..5] =="CONST("
              write=false
              val,data_type= t_mod.get_const(link_field)
              if data_type=="LINK"
                #link
                rdfa_string<<"<div rel= \"#{name}\" resource=\"#{val}\"> </div>\n"
              else
                #value
                rdfa_string<<"<div property= \"#{name}\"  content=\"#{val}\" datatype=\"#{data_type}\"> </div>\n"
              end
            else
              m_class,field= link_field.to_s.split("*")
              if  name.to_s[0..5]=="MODEL("
                m_class.gsub!("MODEL(","Model.new(")
                submodel= eval(m_class.to_s).get_rows
                submodel.each do |line|
                  datatype="string"
                  rdfa_string<<"<div property= \"#{ref_pred}\"  content=\"#{eval("line.#{field.to_s.downcase}")}\" datatype=\"#{data_type}\"> </div>\n"
                end
              end
              if field
                write = false
                #rdfa_string<<get_rdfa_by_id("","")
              end
            end
            rdfa_string<<"<div property= \"#{name}\"  content=\"#{eval("item.#{link_field}")}\"></div>\n" if write
          end
        end
      end
    end
    rdfa_string << "</div>\n"
  end

  #not used
  def tripleize (tr_self,c =nil,id=nil)

  end

  # Find all the models to the given key ( the RDF-Class name)
  # returns a hash with the RDF-Class name as key and the models as value
  def search_models key
    model_groups =  eval("configatron.query").to_hash
    model_groups.each do |model_group_name,model_group|
      if model_group_name.to_s.downcase == key.downcase
        return {model_group_name=>model_group}
      end
    end
    nil
  end

  # write the model(s) depending on its RDF-Class name.
  # This is one of the core funktions of rtriplify
  def write_model model_name, class_name
    puts model_name
    ret=""
    model = Model.new(model_name,class_name)   
    data_types= model.get_datatypes
    #build hash
    model.get_rows.each do |item|
      line = Hash.new
      subline = Hash.new
      #and now add all mapping-attributes
      remove =Array.new
      model.model_attributes.each do |k,v|
        #        if k.to_s.include?("->")
        if v.to_s.include?("*") || v.to_s[0..9]=="new_model("

          remove.push(k.to_s) unless remove.index(k.to_s)
          m_class,field=v.to_s.split("*")
          ref_pred,ref_model=k.to_s.split"->"
          if  v.to_s[0..5]=="MODEL("
            m_class.gsub!("MODEL(","Model.new(")
            submodel= eval(m_class.to_s).get_rows
          else
            submodel= eval("item.#{m_class.to_s.downcase}")
          end
          submodel.each do |subitem|
            subline[:id] = eval("item.#{model.get_key}")
            subline[k] = eval("subitem.#{field}")
            #extract_id_line(m.model_attributes, subline, subitem, Array.new)
            ret<<make_triples(subline, class_name, false,Array.new,false )
            subline.clear
          end
        else
          write_line = true;
          if v.to_s.include? "."
            write_line = nil unless eval("item."+v.to_s.downcase.split(".")[0])
          end
          begin
            if v.to_s[0..5]=="CONST("
              line[k.to_s],data_types[k.to_s]= model.get_const(v)
              #datatype to uri format
              if data_types[k.to_s]=="LINK"
                line[k.to_s] =uri line[k.to_s]
                data_types.delete k.to_s
                @object_properties[k.to_s]="t"
              else
                data_types[k.to_s] = uri(data_types[k.to_s])
              end
            else
              line[k.to_s]=eval("item."+v.to_s) if write_line
            end
          rescue Exception => ex
            line[k.to_s]=v.to_s if write_line
          end
        end
        # end
      end
      extract_id_line(model.model_attributes, line, item,data_types)
      remove.each { |rem_attrib|  line.delete(rem_attrib) }
      #get triples of row
      ret<<make_triples(line, class_name , "", data_types)
      #render :text =>  t.make_triples(c1, controller , "", t.dbd_types)
    end
    ret
  end

  # search for the ID field and set it in line var- to the "id"-key
  def extract_id_line model_attributes, line,item,dtypes
    #look if id is mapped to another field
    id_keys = model_attributes.to_hash.keys
    #hotfix..bad performance
    id_keys.map!{|k| k.to_s }
    id_key= id_keys.select{|k| k =~/^(ID|id|iD|Id)$/ }
    if id_key.empty?
      line[:id] = item.id
    else
      line[:id] = eval("item.#{model_attributes[id_key[0].to_sym]}")
      #set the correct datatype for it
      dtypes["id"]= dtypes[id_key[0]]
      #remove the id line
      line.delete id_key[0]
    end
  end

  # Executes a sql command. Better to not use this function
  def write_sql model_name, model_attributes,output
    model_attributes.each do|key,query|
      sql=  ActiveRecord::Base.connection();
      (sql.select_all query).each do |row|
        make_triples(row,model_name,"")
      end
    end
  end

  # the standard triples at the beginning of your rdf output ( version and licence)
  def write_rdf_head
    # $this->writeTriple($self,$this->uri('rdfs:comment'),'Generated by Triplify '.$this->version.' (http://Triplify.org)',true);
    write_triple(@base_uri, uri("rdfs:comment"), 'Generated by Triplify '+'version'+ "  (http://Triplify.org) ", "literal" )
    unless configatron.license.blank?
      #$this->writeTriple($self,'http://creativecommons.org/ns#license',$this->config['license']);
      write_triple(@base_uri,'http://creativecommons.org/ns#license',configatron.license, "literal" )
    end
  end

  # generate the triples from a given hash  
  def make_triples (c1,rdf_class,maketype,dtypes=Array.new,rdf_type=true)
    rdf_ns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    ipref= uri rdf_class.to_s+'/'
    is_literal=false
    dtype,lang,ret="","",""
    object_property = nil
    triples =""

    unless c1[:id]
      id_row = c1.select {|k,v| k =~ /^(id|ID|iD|Id)$/}
      c1[:id] = id_row[0][1]
      c1.delete id_row[0][0]

      #set datatype for id
      #dtypes[:id] = uri( (id_row[0][1]).type)
    end

    subject = uri c1[:id].to_s,ipref
    #write model :-)

    c= @class_map[rdf_class.to_sym] ?@class_map[rdf_class.to_sym]:rdf_class
    triples << write_triple(subject, rdf_ns+"type", uri(c, @object_namespaces[:vocabulary]))  if rdf_type
    # write_triple(subject,predi    cate,object                                                  ,is_literal=false,dtype="",lang="",json=nil)
    c1.delete :id unless rdf_type

    c1.each do |k,v|
      dtype=""
      k=k.to_s
      if v.to_s.empty?
        next
      end
      # beinhaltet key ^^ dann type oder sprache richtig setzen
      if k.index("^^")
        #TODO: k,dtype = k.split("^^")
        dtype= uri k.split("^^")[1]
        k= k.split("^^")[0]
      else if dtypes.include? k
          dtype= uri dtypes[k]
        else if k.index("@")
            lang=k.split("@")[1]
            k = k.split("@")[0]
          end
        end
      end
      # beinhaltet key -> dann muss objekt richtig gesetzt werden
      if k.index("->")
        k, object_property = k.split("->")
      else
        object_property = @object_properties[k]
      end

      #TODO
      #callbackfunktion
      #

      prop= self.uri(k,@object_namespaces[:vocabulary])

      unless object_property
        is_literal= true
        object= v.to_s
      else
        is_literal= false
        #uri($objectProperty.($objectProperty&&substr($objectProperty,-1,1)!='/'?'/':'').$val);
        #TODO: fixme "/" in the middle
        #object= uri  "#{object_property}/#{object_property && object_property[-1,1].to_s !="/" ?"/":":"}#{v}"
        object= uri  "#{object_property}#{object_property[-1,1].to_s !="/" ? "/":":"}#{v}"
        if object[0..1] == "t/"
          object = object.to_s[2..-1]
        end
      end
      triples<<write_triple(subject,prop,object,is_literal,dtype,lang).to_s
    end
    triples
  end

  # triple will be given to its defined output (json||inner_variable||return value
  def write_triple(subject,predicate,object,is_literal=false,dtype="",lang="")
    if @output_json
      oa = {:value=> object,:type=> is_literal ? 'literal' : 'uri'}
      oa['datatype']=dtype if is_literal && dtype
      oa['language']=lang if is_literal && lang
      add_json_pair subject, predicate,oa

    else
      #(lang?"@#{lang}":'')

      #define the object
      if(is_literal)
        object = "\"#{object.to_s.gsub('"','%22')}\""+  (dtype.empty? ?  (lang.empty? ? "": "@#{lang}" ):"^^<#{dtype}>" )
      else
        object = ( object[0..1] == "_:" ) ? object : "<#{object}>"
      end
      #object="\"#{object[1..-2].gsub('"','\"')}\""
      #define the subject
      subject = ( subject[0..1] == "_:" ) ? subject : "<#{subject}>"
      if @output
        @output.write "#{subject} <#{predicate}> #{object} .\n"
      end
      return "#{subject} <#{predicate}> #{object} .\n"
    end
  end

  #generates an uri with the given name
  def uri (name,default="")
    name=name.to_s

    if name.try(:include?, "://")
      return name[0..name.length-2] if name[-1,1]=="/"
      return name[0..name.length]
    else
      name +="/" unless (name[name.length-1..name.length-1] == ("/" || "#")) || name.try(:include?, ":")

      if name.index(":")
        #$this->ns[substr($name,0,strpos($name,':'))].$this->normalizeLocalName(substr($name,strpos($name,':')+1))
        t= @object_namespaces[name.split(":")[0].to_sym]
        t ||=""
        t += "/" unless (t[t.length-1..t.length-1] == ("/" || "#") || t.blank?) || name.try(:include?, ":")
        return  uri( t+ normalize_local_name(name.split(":")[1])+"/")
      else
        ##($default?$default:$GLOBALS['baseURI']).$this->normalizeLocalName($name));
        #falls bei default hinten ein "/" ist abschneiden
        #default= default[0.. default.length-2] unless default[default.length-1..default.length-1] == "/"
        t=  default.blank? ?  @base_uri   : default
        t += "/" unless t[t.length-1..t.length-1]=="/"
        return  uri( t + normalize_local_name(name))
      end
    end
  end

  # extract the base uri for triple generation from given request
  # if param "set" is true, the inner base_uri variable off class will be set too
  def generate_base_uri request, set=nil
    b_uri= uri request.env['REQUEST_URI'].to_s[0..-request.env['PATH_INFO'].length]
    @base_uri = b_uri if set
    b_uri
  end

  # returns an hash with columnname as key and datatype as value
  def dbd_types (model,model_attributes)
    #hard coded mapping look mapping table
    mapping = Hash[ "binary"=>"base64Binary","boolean"=>"boolean","date"=>"date","datetime"=>"dateTime","decimal"=>"decimal","float"=>"float","integer"=>"integer","string"=>"string","text"=>"string","time"=>"time","timestamp"=>"dateTime",]
    dtypes = Hash.new
    model.columns_hash.each_key do |m|
      #make xsd datatye
      dtypes[m.to_s] ="xsd:#{mapping[model.columns_hash[m].type.to_s] }"
    end
    #replace mapping
    model_attributes.each do |k,v|
      dtypes[k.to_s]=dtypes[v.to_s]
    end
    dtypes
  end
  #some encoding stuff
  def normalize_local_name name
    CGI::escape(name).gsub(/%2F/,'/').gsub(/%23/,'#') 
  end

  def json
    @json_hash.to_json
  end

  def add_json_pair subject, predicate,oa
    if @json_hash.key? subject
      if @json_hash[subject].key? predicate
        @json_hash[subject][predicate].merge!(oa)
      else
        @json_hash[subject][predicate]=oa
      end
    else
      @json_hash[subject]=Hash.new
      @json_hash[subject][predicate]=oa
    end
  end
end