#require "ontomde-core/exceptions.rb"
require "singleton"

# Helper methods to handle rdf ressources as object.
module IteratorOrSingleElement
  def to_s
    r=""
    sep=""
    self.each{ |elt|
      r=r+sep+(elt.to_s)
      sep=" "
    }
    return r
  end
  def isFalse?
    return !isTrue?
  end
  def +(array)
    return self if array.kind_of?(ArrayOrSingleElementEmpty)
    return super(array)
  end

  STRING_TO_BOOLEAN_HASH={ "false" => false, "true" => true}
  def other_implem_isTrue?
    return false if length==0
    raise Warning.new,"bad data for isTrue?(length=#{length}>1)" if length>1
    ret=STRING_TO_BOOLEAN_HASH[self[0]]
    return ret unless ret.nil?
    raise Warning.new,"bad data for isTrue?(#{self[0]})" if length>1
  end
  def isTrue?
    #return false if length==0
    return false if empty?
    raise Warning.new,"bad data for isTrue?(length=#{length}>1)" if length>1
    return false if self[0]=="false"
    return true  if self[0]=="true"
    raise Warning.new,"bad data for isTrue?(#{self[0]})" if length>1

  end
end
class ArrayOrSingleElement < Array
  include IteratorOrSingleElement
end
class SetOrSingleElement < Set
  include IteratorOrSingleElement end

# Singleton of an empty ArrayOrSingleElement
# Note:
#    This object is used for performance enhancement.
class ArrayOrSingleElementEmpty #< ArrayOrSingleElement
  include Singleton

  # Size of an empty Array (always 0)
  def size
    0
  end

  # Size of an empty Array (always 0)
  def length
    0
  end

  # Iterator (does nothing)
  def each
  end

  # returns self as
  def select
    # quelque-soit le critere
    # de selection le retour est tout aussi vide
    return self;
  end

  # returns array
  def +(array)
    return array
  end

  # returns !isTrue?
  def isFalse?
    return !isTrue?
  end

  # returns false
  def isTrue?
    return false
  end

  # returns ""
  def to_s
    return ""
  end

  #return true
  def empty?
    return true
  end

  #returns false
  def include?(elt)
    return false
  end

  def delete(elt)
    return nil
  end

  def sort(&block)
    return self
  end
end

module Mrdfs_Literal
end
class Crdf_Resource

  # helper method used by rdf property getter
  # return first value contained in val ArrayOrSingleElement
  #
  # When val is empty:
  #    log an error if warn==true
  #    returns nil
  # When val contains more than one element:
  #    log an error
  #    returns first element found
  def rdf_getter_one(val,warn,propNameShort)
    if val.nil? || val.size==0
      log_error_nil_one(propNameShort) if warn
      return nil
    end
    return val[0] if val.length==1
    log.error "#{propNameShort}_one  used with multi-value (class=#{self.class.name})(uri=#{rdf_uri})(length=#{val.length})(value=(#{val.to_s}) Returning first one found as workaround : (#{val[0]})"
    return val[0]
  end
  # raise an exception if value does not have a type in range array.
  # This method is used by rdf attributes operators.
  #
  # range: array of types
  # value: a value
  # property: name of the property, value comes from (used in error message)
  def check_rdfType(range,value,property)
    return if value.nil?
    return if range.empty?
    range.each { |r|
      return if value.kind_of?(r)
      return if r==::Mrdfs_Literal && (value.kind_of?(String) || value.kind_of?(Fixnum))
    }
    raise Exception.new(
      <<END

********* ILLEGAL ASSIGNEMENT TYPE **********
** property #{property}
** has a range of (valid value types)
** [ #{range} ]
** which is not compatible with type #{value.class.name}
** Please check your code for incorrect assignement.
**
** This model element is related to these other model elements:
#{mtk_related_message}
********* ILLEGAL ASSIGNEMENT TYPE **********
END
    )
  end

  # helper method used by rdf property
  # to retrieve the inverse of a property.
  #
  # This method return is randomly ordered
  #
  # sym_short: name of the inverse property
  # filter: method calling the direct property
  #        (used for performance reason to avoid eval)
  def rdf_getter_inv(sym_short,&filter)
    ret=nil
    ext_isReferencedBy.each { |g|
      next unless g.respond_to?(sym_short)
      next unless yield(g).include?(self)
      ret=::ArrayOrSingleElement.new if ret.nil?
      next if ret.include?(g)
      ret << g
    }
    return ret.nil? ? ::ArrayOrSingleElementEmpty.instance : ret
  end
end

module Kernel

  #Creates accessors for rdf property passed as argument.
  #
  #Example:
  #  for rdf_safe_attr_reader_many uml_abcde_efgh
  #  the following methods are generated
  #
  #  def uml_abcd_efgh ()
  #    returns an Array of reference elements.
  #    (This array is READ-ONLY)
  #
  #  def uml_efgh ()
  #    same as uml_abcd_efgh
  #    in case of name clashing use long version.
  #
  #  def uml_efgh_one()
  #     Returns nil if array is empty
  #     Triggers an error if array contains more than one element.
  #     returns the first element of array
  #
  #  def uml_efgh=(x)
  #     reset array and add x
  #
  #  def uml_efgh_add(x)
  #     add x to the existing array
  #
  #  def uml_efgh?
  #     returns uml_efgh.isTrue?()
  #
  def rdf_safe_attr_reader_many(*syms)
    syms.each { |s|
      rdf_attr_rubyCode(s,[]).each { |code|
        class_eval code
      }
    }
  end

  #creates rdf attribute and accessors
  def rdf_attr(sym,range)
    rdf_attr_rubyCode(sym,range).each { |code|
      class_eval code
    }
  end

  # returns ruby code generated for rdf attribute and accessors.
  def rdf_attr_rubyCode(sym,range)
    ret=[]
    # TODO: ne pas crer un objet vide systématiquement.

    #sym_array=sym.to_s.split("_",3)
    #sym_short=""
    #if sym_array[0]=="uml" && sym_array[2]!=""
    #	sym_short="#{sym_array[0]}_#{sym_array[2]}"
    #else
    sym_short=sym
    #end
    #version normale
    #TODO: supprimer la version normale
    #      ou raccourcir les nom en amont
    #class_eval %{def #{sym}
    #	log.warn "method #{sym} is deprecated. Use #{sym_short} instead"
    #	@#{sym}.nil? ? ::ArrayOrSingleElementEmpty.instance : @#{sym}
    #end}
    #version courte

    #log.debug "sym_short: >#{sym_array[0]}< >#{sym_array[1]}< >#{sym_array[2]}<"
    #log.debug sym_short
    ret << %{def #{sym_short}
			@#{sym}.nil? ? ::ArrayOrSingleElementEmpty.instance : @#{sym}
		end}

    (range.empty?&&true ? [Crdf_Resource] : range).each { |inv_res|
      next if inv_res==::Mrdfs_Literal
      inv_res.class_eval <<END
		def #{sym_short}_inv
			return rdf_getter_inv(:#{sym_short}) { |g| g.#{sym_short} }
		end
		def #{sym_short}_inv_one()
			return rdf_getter_one(#{sym_short}_inv,true,:#{sym_short}_inv)
		end
		def #{sym_short}_inv_one0()
			return rdf_getter_one(#{sym_short}_inv,false,:#{sym_short}_inv)
		end
END
    }


    range_array="["; sep=""
    range.each { |r|
      range_array+=sep+r.name #.getRubyModuleName
      sep=","
    }
    range_array+="]"

    if (true)
      ret << %{def #{sym_short}_typeOk?(val)
				check_rdfType(#{range_array},val,:#{sym_short})
			end
      }
    else
      # TODO: more performant but generates warnings
      # investigate reason of multiple execution
      ret << %{RANGE_#{sym_short}=#{range_array}
			def #{sym_short}_typeOk?(val)
				check_rdfType(RANGE_#{sym_short},val,:#{sym_short})
			end
      }
    end

    ret <<  %{def #{sym_short}?
			return #{sym_short}.isTrue?
		end}

    ret << %{def #{sym_short}_one()
			return rdf_getter_one(@#{sym},true,:#{sym_short})
		end}

    ret << %{def #{sym_short}_one0()
			return rdf_getter_one(@#{sym},false,:#{sym_short})
		end}

    inv=(sym_short.to_s=="ext_isReferencedBy") ? "" : "item.ext_isReferencedBy_add(self) if item.respond_to?(:ext_isReferencedBy_add) "

    ret << %{def #{sym_short}=(v)
			if v.nil?
				@#{sym}=nil
			elsif  v.kind_of?(ArrayOrSingleElement) || v.kind_of?(Array) || v.kind_of?(ArrayOrSingleElementEmpty)
				@#{sym}= ArrayOrSingleElement.new
				v.each { |item|
					#{sym_short}_typeOk?(item)
    @#{sym}.push(item)
    #{inv}
					}
			else
				@#{sym}= ArrayOrSingleElement.new
				#{sym_short}_typeOk?(v)
				@#{sym}.push(v)
				item=v
				#{inv}
			end
		end}

    ret << %{def #{sym_short}_add(item)
			if !item.nil?
				#log.debug @#{sym}.size+1000
				if @#{sym}.nil?
					#log.debug "reset @#{sym}"
					@#{sym}= ArrayOrSingleElement.new
				end
				#{sym_short}_typeOk?(item)
				@#{sym}.push(item)
				#{inv}
			end
		end}

    return ret
  end
end


module Mrdf_Model
  def mtk_object_message
    return ""
  end
  def mtk_related_message
    return ""
  end
end

module Mrdf_Resource
  #return a string describing this object
  #(used for error log messages)
  def mtk_object_message
    return <<END
**      uri =#{rdf_uri}
**      type=#{self.class.name}
**      to_s=#{self.to_s}
END
  end
  #return a string describing object related to this object
  #(used for error log messages)
  def mtk_related_message
    related=""
    ext_isReferencedBy.each { |g|
      related=related+"**  (#{g.class.name}) #{g}\n"
    }
    return related
  end


  # generates an error message used when
  # "meth" returns unexpectedly no data.
  def log_error_nil_one(meth)
    return if log_already_displayed?("#{rdf_uri}__#{meth}")
    log.error {

      <<END
#{meth}_one nil for #{self}::#{self.class.name} (uri=#{rdf_uri})
********* INVALID DATA DETECTED **********
** This software expects the model element specified bellow
**#{mtk_object_message}
** to have exactly one "#{meth}".
**
** This is most likely caused by a missing data in source model.
** Please check that previous element has a #{meth} defined.
**
** This model element is related to these other model elements:
#{mtk_related_message}
********* INVALID DATA DETECTED **********
END
    }
    raise Warning.new,"#{meth}_one nil null" if context[:failOnEmptyCallto_one,true]
  end
end

#List of error message keys already displayed
MDA_LOG_ALREADY_DISPLAYED=Array.new

def log_already_displayed?(key)
  return true if MDA_LOG_ALREADY_DISPLAYED.include?(key)
  MDA_LOG_ALREADY_DISPLAYED<< key
  return false
end