require "active_support"
require 'uuid'
require File.dirname(__FILE__) +'/domain_attribute_description.rb'
require File.dirname(__FILE__) +"/reference.rb"
require File.dirname(__FILE__) +"/index_description.rb"
require File.dirname(__FILE__) +"/lazy_loading_text.rb"
require File.dirname(__FILE__) +"/repository_factory.rb"
module SdbDal
  class DomainObject
  
    @@items_to_commit=nil
    @@transaction_depth=0
    attr_accessor :sdb_key
    def initialize(options={})
      @attribute_values=HashWithIndifferentAccess.new

      self.class.attribute_descriptions.each do |attribute_name,description|
          value=options[attribute_name]
          value=value || options[attribute_name.intern]
          if !description.is_collection && value.respond_to?(:flatten) && value.length==1
            value=value[0]
          end
          @attribute_values[attribute_name]=value
        
      end
      @accessor_cache={}
      @repository=options[:repository]
    end


    def self.primary_key_attribute_names
      return @primary_key_attribute_names
    end


    def id
      return @attribute_values[:id] if self.class.attribute_descriptions[:id]
      return base.id
    end
    def set_map(keys,values)
      (0..keys.length-1).each do |i|
          key=keys[i]
          value=values[i]
          @attribute_values[key]=value
        end


    end


    def self.index_names
      []
    end

    def self.index(name,columns,options={})
       return if self.index_descriptions[name]
      $columns_xxx=columns
      class_eval <<-GETTERDONE

      @@index_descriptions||={}
      unless @@index_descriptions.has_key?(:#{name})
      @@index_names||=[]
      @@index_names<<:#{name}

    def self.index_names
        @@index_names
    end

    attribute_description=SdbDal::DomainAttributeDescription.new(:#{name},:string,{})
    @@index_descriptions[:#{name}]=SdbDal::IndexDescription.new(:#{name},$columns_xxx)
   end
      GETTERDONE
     
      getter_params=[]
      finder_code=""
     
      params=[]
      columns.each do |column|
        if column.respond_to?(:transform)
          finder_code<<"h[:#{column.name}]=#{column.name.to_s.downcase}\n"
          getter_params<<"@attribute_values[:#{column.source_column}]"
       
          params<<"#{column.name.to_s.downcase}"
        else
          finder_code<<"h[:#{column}]=#{column.to_s.downcase}\n"
          getter_params<<"@attribute_values[:#{column}]"
          params<<"#{column.to_s.downcase}"
       
        end
       
      end
      find_scope=":all"
      if options[:unique]
        find_scope=":first"
      end
      class_eval <<-GETTERDONE
        def #{name}              
            return	self.class.calculate_#{name}(#{getter_params.join(",")})
        end

       def self.calculate_#{name}(#{params.join(",")})
            index_description=index_descriptions[:#{name}]
            h={}
            #{finder_code}
            index_description.format_index_entry(@@attribute_descriptions,h)
      end

      def self.find_by_#{name}(#{params.join(",")},options={})
          options[:params]={:#{name}=>self.calculate_#{name}(#{params.join(",")})}
          options[:index]=:#{name}
          options[:index_value]=self.calculate_#{name}(#{params.join(",")})
           find(#{find_scope},options)
      end
      GETTERDONE
    end


    @@index_descriptions ||={}

    def self.index_descriptions
      @@index_descriptions || {}
    end

    def self.data_attribute(name,type,options={})
      class_eval <<-GETTERDONE
    @@attribute_descriptions||=HashWithIndifferentAccess.new 
    
    @@non_clob_attribute_names||=[]
    @@clob_attribute_names||=[]
    @@on_destroy_blocks||=[]
    def self.on_destroy_blocks
      @@on_destroy_blocks || []
    end
     def self.attribute_descriptions
      @@attribute_descriptions
    end
    
    def self.non_clob_attribute_names
      @@non_clob_attribute_names
    end
    def self.clob_attribute_names
      @@clob_attribute_names
    end
    def is_dirty(attribute_name)
             if @attribute_values[attribute_name]!= nil && 
                @attribute_values[attribute_name].respond_to?(:value)
                return @attribute_values[attribute_name].is_dirty
            else
                return true
            end
    end
      GETTERDONE
    return if self.attribute_descriptions.has_key?(name)
  
      attribute_description=DomainAttributeDescription.new(name,type,options)
      self.attribute_descriptions[name] = attribute_description
      @primary_key_attribute_names||=[]
      if attribute_description.is_primary_key 
        @primary_key_attribute_names<<name
        pk_code="[:#{@primary_key_attribute_names.join(",:")}]"
        class_eval <<-GETTERDONE
       def self.primary_key_attribute_names
            #{pk_code}
       end
      def self.exists?(primary_key)
            return self.find(primary_key)!=nil
       end
        
        GETTERDONE
      end
        if attribute_description.value_type==:clob
          clob_attribute_names<<attribute_description.name
        else
          non_clob_attribute_names<<attribute_description.name
        end

      scope=":all"
      if(options[:unique] && options[:unique]==true)
        scope=":first"
      end
      if type==:reference_set
        
    
        class_eval <<-GETTERDONE
        def #{attribute_description.name}
              result=@attribute_values[:#{attribute_description.name}] || []
              result=result.sort_by{|item|item.index}
          
	end
        def add_to_#{attribute_description.name}(item,index=-1)
		@attribute_values[:#{attribute_description.name}] ||=[]
                @attribute_values[:#{attribute_description.name}] <<SdbDal::Reference.new(:target=> item ,:index=>index)
	end
        def remove_from_#{attribute_description.name}(item)
		@attribute_values[:#{attribute_description.name}] ||=[]
                @attribute_values.each do |reference|
                      if reference.targets?(item)
                        @attribute_values.remove(reference)
                        return
                      end
                end
	end
        
        GETTERDONE
    
      elsif type==:clob
        class_eval <<-GETTERDONE
         
        def #{attribute_description.name}
            if @attribute_values[:#{attribute_description.name}]!= nil && 
                            @attribute_values[:#{attribute_description.name}].respond_to?(:value)
		return @attribute_values[:#{attribute_description.name}].value 
            else
                return @attribute_values[:#{attribute_description.name}] 
            end
	end
        
        GETTERDONE
      else
     
        class_eval <<-GETTERDONE
        def #{attribute_description.name}
		return @attribute_values[:#{attribute_description.name}] 
	end
       
        GETTERDONE
      end
      class_eval <<-GETTERDONE
    
	 def #{attribute_description.name}=(xvalue)
                @attribute_values[:#{attribute_description.name}] =xvalue
	end
	def #{attribute_description.name}?
		return @attribute_values[:#{attribute_description.name}] 
	end
	
	def self.find_by_#{attribute_description.name}(#{attribute_description.name.to_s.downcase},options={})
          options[:params]={:#{attribute_description.name}=>#{attribute_description.name.to_s.downcase}}
               find(#{scope},options)
	end
      GETTERDONE
    end
  
    def self.belongs_to(domain_class,foreign_key_attribute=nil,accesser_attribute_name=nil,options={})
    
      foreign_key_attribute ||= "#{domain_class.to_s.downcase}_id".to_sym
      accesser_attribute_name ||=domain_class.to_s.downcase
  
      class_eval <<-GETTERDONE
	def #{accesser_attribute_name}
		#{domain_class}.find(self.#{foreign_key_attribute})
	end
        
      GETTERDONE
    end
    def self.many_to_many(domain_class,
        through_class,
        reflecting_key_attributes=nil,
        foriegn_key_attribute=nil,
        accesser_attribute_name=nil,
        options={})
      reflecting_key_attributes ||= primary_key_attribute_names.map{|x|self.name+"_"+x.to_s}
      reflecting_key_attributes =arrayify(reflecting_key_attributes)
      reflecting_array_code="[:"+reflecting_key_attributes.join(",:")+"]"

      accesser_attribute_name ||=domain_class.to_s.downcase+'s'
      order=""
      if options[:order_by]
        if options[:order]
          order="result=DomainObject.sort_result(result,:#{options[:order_by]},:#{options[:order]})"
        else
          order="result=DomainObject.sort_result(result,:#{options[:order_by]},:ascending)"
        end
      end
   
       
      foriegn_key_attributes=options[:foriegn_key_attribute] || "#{domain_class.to_s.downcase}_id".to_sym
      foriegn_key_attributes=arrayify(foriegn_key_attributes)
      fkey_array_code="[:"+foriegn_key_attributes.join(",:")+"]"
      class_eval <<-XXDONE

	def #{accesser_attribute_name}
            #unless @accessor_cache.has_key? :#{accesser_attribute_name}
      		through_results= #{through_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject.arrayify(self.primary_key)})
                result=[]
                through_results.each do |through_result|
                  item= #{domain_class}.find(through_result.#{foriegn_key_attribute}) 
                  result<< item if item
                end
                #{order}
                
              #  @accessor_cache[:#{accesser_attribute_name}]=result
                return result
            #end
            #return @accessor_cache[:#{accesser_attribute_name}]
            
	end
        def connect_#{domain_class.to_s.downcase}(#{domain_class.to_s.downcase})
            connector=#{through_class}.new
            connector.set_map(#{fkey_array_code},DomainObject.arrayify(#{domain_class.to_s.downcase}.primary_key))
            connector.set_map(#{reflecting_array_code},DomainObject.arrayify(self.primary_key))
            connector.save
        end
      XXDONE
       
   
    end


    def DomainObject.transaction
      @@items_to_commit||=[]
      @@transaction_depth+=1
      begin
        yield
      rescue # catch all
        raise $! # rethrow
      ensure
        @@transaction_depth-=1
      
      end
    
    
      if @@transaction_depth==0
     
        @@items_to_commit.uniq.each do |item |
          item.save!
        end
        @@items_to_commit=[]
      end
    
    end
    def DomainObject.sort_result(results,sort_by,order=:ascending)
      non_null_results=[]
      null_results=[]
      results.each { |i|
        sorter_value=i.get_attribute(sort_by)
        if sorter_value
          non_null_results<<i
        else
          null_results<<i
        end
      }
      sorted_results=non_null_results.sort{ |a,b|
        a_val= a.get_sortable_attribute(sort_by)
        b_val= b.get_sortable_attribute(sort_by)
        
        a_val <=> b_val
      }
        
      if order!=:ascending
        sorted_results.reverse!
      end
      sorted_results.concat( null_results)
      sorted_results
    end
    def get_sortable_attribute(attr_name)
      a_val= self.get_attribute(attr_name)
      return 0 unless a_val
      if a_val.class== Time
        return a_val.to_f
      else
        return a_val
      end
    end
    def self.has_many(domain_class,
        reflecting_key_attributes=nil,
        accesser_attribute_name=nil,
        options={})
    reflecting_key_attributes ||= primary_key_attribute_names.map{|x|self.name.downcase+"_"+x.to_s}
      reflecting_key_attributes =arrayify(reflecting_key_attributes)
      reflecting_array_code="[:"+reflecting_key_attributes.join(",:")+"]"

      accesser_attribute_name ||=domain_class.to_s.downcase+'s'
      order=""
      if options[:order_by]
        order=",:order_by=>:#{options[:order_by]}"
      end
      if options[:order]
        order<<",:order=>:#{options[:order]}"
      end
  
      if options[:dependent]
        
        class_eval <<-XXDONE
          
            on_destroy_blocks<<"#{accesser_attribute_name}.each{|item|item.destroy}"
        XXDONE
      end
      #  if options[:tracking]
      #    #add add_xxx method
      #    #add to list of tracker attributes
      #
      #      class_eval <<-XXDONE
      #
      #    @@attribute_descriptions[ :#{accesser_attribute_name}_tracker]=TrackerDescription.new(:#{accesser_attribute_name}_tracker,:#{domain_class},:#{reflecting_key_attribute})
      # # def #{accesser_attribute_name} # 	find_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class},:#{reflecting_key_attribute})
      # # end
      #        def add_to_#{accesser_attribute_name}(item)
      # # 	item.save!
      #                add_to_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class.to_s},:#{reflecting_key_attribute},item.primary_key)
      #                item.set_attribute(:#{reflecting_key_attribute},self.primary_key)
      #
      #
      # # end
      #    XXDONE
      #  else
      class_eval <<-XXDONE
	def #{accesser_attribute_name}
            if !@accessor_cache.has_key? :#{accesser_attribute_name}
               result= #{domain_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject::arrayify(self.primary_key)}#{order})
                @accessor_cache[:#{accesser_attribute_name}]=result || []
            end
            return @accessor_cache[:#{accesser_attribute_name}] 
	end
      XXDONE
      # end
    end
    def self.AttributeDescription(name)
      return attribute_descriptions[name]
    end
    def self.ColumnDescription(name)
      return column_descriptions[name]
    end
    def primary_key

      result=[]
      self.class.primary_key_attribute_names.each do |key_part|
        result<<@attribute_values[key_part ]
      end
      return result[0] if result.length==1
      return result
    end
    def primary_key=(value)
      key=DomainObject::arrayify(value)
      self.class.primary_key_attribute_names.each do |key_part|

        @attribute_values[ key_part]=key.shift
      end
    end
    def method_missing(method_symbol, *arguments) #:nodoc:
      method_name = method_symbol.to_s

      case method_name.last
      when "="
        if @attribute_values.has_key?(method_name.first(-1))
          @attribute_values[method_name.first(-1)] = arguments.first
        else
          super
        end
      when "?"
        @attribute_values[method_name.first(-1)]
      else
        @attribute_values.has_key?(method_name) ? @attribute_values[method_name] : super
      end
    end
    def index_values
      result={}
      self.class.index_names.each do |name|
              
        result[name]=  self.send("#{name}")
   
      end
      result
    end
    def set_attribute(name,value)
      @attribute_values[name]=value
    end
    def get_attribute(name)
      @attribute_values[name]
    end
    def to_xml
      result= "<#{self.class.table_name}>"
      attributes.each do |key,value|
        if value.respond_to?(:flatten)
          result<<"<#{key}>"
          value.each do |sub_value|
            result<<"<value>#{h sub_value.to_s}</value>"
          end
          result<<"</#{key}>"
        else
          result<<"<#{key}>#{h value.to_s}</#{key}>"
        end
      end
      result<< "</#{self.class.table_name}>"
      result
    end
    def destroy(options={})
      if self.class.on_destroy_blocks
        self.class.on_destroy_blocks.each do |block|
          instance_eval <<-XXDONE
                    #{block}

          XXDONE

        end
      end
      if self.primary_key
        self.repository(options).destroy(self.table_name,self.primary_key)
      end
    end
    def attributes
      result={}
      # #todo refactor to avoid this copy
      self.class.attribute_descriptions.values.each do |description|
        if !description.is_clob || is_dirty(description.name)
          result[description.name]=@attribute_values[description.name]
        end
      end
      return result
    end

    def find_tracked_list(tracking_attribute,other_class,reflecting_attribute)
      # #if the attribute has no  value do a query
      list=@attribute_values[tracking_attribute]
      if !list
        list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
        @attribute_values[tracking_attribute]=list
        self.save!
      end
      
      return other_class.find_list(list)
    
    end
  
    def add_to_tracked_list(tracking_attribute,other_class,reflecting_attribute,value)
      list=@attribute_values[tracking_attribute]
      if !list
        list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
      
      end
      list<<value
      @attribute_values[tracking_attribute]=list.uniq
    
    end
    def save!(options={})
      save(options)
    end
    def save(options={})
      if !self.primary_key
        self.primary_key= UUID.generate.to_s
      end
        
      if @@transaction_depth>0
        # #we are in a transaction.  wait to commit
        @@items_to_commit<<self
     
      else
        temp_accessor_cache=@accessor_cache
        @accessor_cache=nil
   
        #     $service.put_attributes(class_object.table_name,item.send(name_column),attributes,true)
        attributes={}
        # #todo refactor to avoid this copy
        self.class.attribute_descriptions.values.each do |description|
          if !description.is_clob || is_dirty(description.name)
            value=@attribute_values[description.name]
            attributes[description]=value
          end
   
                
           
        end
        self.index_values.each do |name,value|
      
          attributes[self.class.index_descriptions[name]]=value
        end
  
        self.repository(options).save(self.table_name,self.primary_key,attributes,self.class.index_descriptions)
        @accessor_cache=temp_accessor_cache
      end
    
    end
    def table_name
      return self.class.table_name
    end
    def DomainObject.table_name
      return self.name
    end
    #    def find
    #
    #       attributes=repository.find(self.class.name,self.primary_key,@@non_clob_attribute_names,@@clob_attribute_names)
    #       attributes.each do |key,value|
    #           @attribute_values[key]=value
    #       end
    #    end
    def repository(options=nil)
    
      if options and options.has_key?(:repository)
        return options[:repository]
      end
      if @repository
        return @repository
      end

      return self.class.repository
    end
    class << self
      def repository(options={})
    
        if options.has_key?(:repository)
          return options[:repository]
        end
      
        $repository   ||= RepositoryFactory.instance(options)
    
        return $repository
      end
      def find(*arguments)
        scope   = arguments.slice!(0)
        options = arguments.slice!(0) || {}
        
        case scope
        when :all   then return find_every(options)
        when :first then return find_one(options)
        else             return find_single(scope, options)
        end
      end
      def find_one(options)
        options[:limit]=1
        find_every(options).first
      end
      def find_every(options)

        results=[]
        untyped_results=self.repository.query(self.table_name,attribute_descriptions,options)
        untyped_results.each do |item_attributes|

          results<<istantiate(item_attributes,self.repository(options))
        end
        return results

      end
      def find_list(primary_keys,options={})
        result=[]
        primary_keys.each do |key|
          item=find_single(key,options)
          result<<item if item
        end
        return result
      end
      def query_ids(options={})
        self.repository.query_ids(self.table_name,attribute_descriptions,options)
      end
      def istantiate(sdb_attributes,repository)
        this_result=new(sdb_attributes||{})
        get_clob_proc=nil
        clob_attribute_names.each do |clob_attribute_name|
          get_clob_proc= proc {
            repository.get_clob(self.table_name,this_result.primary_key,clob_attribute_name)
          }
                  
          this_result.set_attribute(clob_attribute_name, LazyLoadingText.new(get_clob_proc))
        end
        this_result
      end
      def arrayify(x)
        unless x.is_a?(Array)
          x=[x]
        end
        return x

      end
      def find_single(id, options)
        return nil if id==nil
        id=arrayify(id)
        attributes=self.repository(options).find_one(self.table_name,id,attribute_descriptions)
        if attributes && attributes.length>0
          @primary_key_attribute_names.each do |key_name|
            attributes[key_name]=id.shift
          end
          attributes[:repository]=self.repository(options)
          return istantiate(attributes,self.repository(options))
        end
        return nil
      end
      def find_recent_with_exponential_expansion(time_column,how_many,options={})
        found=[]
        tries=0
        timespan=options[:timespan_hint] || 60*60*4
      
        params = options[:params] || {}
      
        while found.length<how_many && tries<4
          time=Time.now.gmtime-timespan
          params[time_column]  =AttributeRange.new(:greater_than=>time)
          found= find(:all,:limit=>how_many,:order=>:descending,:order_by => time_column,
            :params=>params)
        
          tries=tries+1
          timespan=timespan*3
        end
        return found
          
      end
    
    end
  end
end