# WARNING: 
# This store is not converted to the latest Og codebase.
# DO NOT USE YET!

begin
  require 'dbi'
rescue Object => ex
  Logger.error 'Ruby-DBI bindings not present or ADO support not available.'
  Logger.error ex
end

require 'og/store/sql'

# Customize the standard SqlServer resultset to make
# more compatible with Og.
=begin
class Sqlserver::Result
  def blank?
    0 == num_rows
  end

  alias_method :next, :fetch_row  

  def each_row
    each do |row|
      yield(row, 0)
    end
  end
  
  def first_value
    val = fetch_row[0]
    free
    return val
  end
  
  alias_method :close, :free
end
=end

module Og

module SqlserverUtils
  include SqlUtils
  
  def escape(str)
    return nil unless str
    return Sqlserver.quote(str)
  end
  
  def quote(val)
    case val
      when Fixnum, Integer, Float
        val ? val.to_s : 'NULL'
      when String
        val ? "'#{escape(val)}'" : 'NULL'
      when Time
        val ? "'#{timestamp(val)}'" : 'NULL'
      when Date
        val ? "'#{date(val)}'" : 'NULL'
      when TrueClass
        val ? "'1'" : 'NULL'
      else 
        # gmosx: keep the '' for nil symbols.
        val ? escape(val.to_yaml) : ''
    end 
  end  
end

# A Store that persists objects into a Sqlserver database.
# To read documentation about the methods, consult the documentation
# for SqlStore and Store.

class SqlserverStore < SqlStore
  extend SqlserverUtils
  include SqlserverUtils

  def self.create(options)
    raise 'Not implemented'
  end

  def self.destroy(options)
    raise 'Not implemented'
  end

  def initialize(options)
    super

    begin
      @conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{options[:address]};Initial Catalog=#{options[:name]};User Id=#{options[:user]};Password=#{options[:password]};")
    rescue => ex
      # gmosx, FIXME: drak, fix this!
      if ex.to_s =~ /database .* does not exist/i
        Logger.info "Database '#{options[:name]}' not found!"
        self.class.create(options)
        retry
      end
      raise
    end
  end

  def close
    @conn.disconnect
    super
  end

  def enchant(klass, manager)
    klass.property :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
    super
  end
  
  def query(sql)
#    Logger.debug sql if $DBG
    return @conn.select_all(sql)
  rescue => ex
    handle_sql_exception(ex, sql)
  end

  def exec(sql)
#    Logger.debug sql if $DBG
    @conn.execute(sql).finish 
  rescue => ex
    handle_sql_exception(ex, sql)
  end

private

  def create_table(klass)
    fields = fields_for_class(klass)

    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
    
    # Create table constrains.
    
    if klass.__meta and constrains = klass.__meta[:sql_constrain]
      sql << ", #{constrains.join(', ')}"
    end
    
    sql << ");"
    
    # Create indices.
    
    if klass.__meta and indices = klass.__meta[:index]
      for data in indices
        idx, options = *data
        idx = idx.to_s
        pre_sql, post_sql = options[:pre], options[:post]
        idxname = idx.gsub(/ /, "").gsub(/,/, "_").gsub(/\(.*\)/, "")
        sql << " CREATE #{pre_sql} INDEX #{klass::OGTABLE}_#{idxname}_idx #{post_sql} ON #{klass::OGTABLE} (#{idx});"  
      end
    end
    
    conn.query_with_result = false

    begin
      conn.query(sql)
      Logger.info "Created table '#{klass::OGTABLE}'."
    rescue => ex
      # gmosx: any idea how to better test this?
      if ex.errno == 1050 # table already exists.
        Logger.debug 'Table already exists' if $DBG
        return
      else
        raise
      end
    end

    # Create join tables if needed. Join tables are used in
    # 'many_to_many' relations.
    
    if klass.__meta and join_tables = klass.__meta[:join_tables] 
      for join_table in join_tables
        begin
          conn.query(create_join_table_sql(join_table))
        rescue => ex
          # gmosx: any idea how to better test this?
          if ex.errno == 1050 # table already exists.
            Logger.debug 'Join table already exists'
          else
            raise
          end
        end
      end
    end
  end

  def create_field_map(klass)
    conn.query_with_result = true
    res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
    map = {}

    res.num_fields.times do |i|
      map[res.fetch_field.name.intern] = i
    end

    return map
  ensure
    res.close if res
  end

  def write_prop(p)
    if p.klass.ancestors.include?(Integer)
      return "#\{@#{p.symbol} || 'NULL'\}"
    elsif p.klass.ancestors.include?(Float)
      return "#\{@#{p.symbol} || 'NULL'\}"    
    elsif p.klass.ancestors.include?(String)
      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
    elsif p.klass.ancestors.include?(Time)
      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
    elsif p.klass.ancestors.include?(Date)
      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
    elsif p.klass.ancestors.include?(TrueClass)
      return "#\{@#{p.symbol} ? \"'1'\" : 'NULL' \}"
    else 
      # gmosx: keep the '' for nil symbols.
      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
    end
  end    
  
  def read_prop(p, col)
    if p.klass.ancestors.include?(Integer)
      return "res[#{col} + offset].to_i"
    elsif p.klass.ancestors.include?(Float)
      return "res[#{col} + offset].to_f"
    elsif p.klass.ancestors.include?(String)
      return "res[#{col} + offset]"
    elsif p.klass.ancestors.include?(Time)
      return "#{self.class}.parse_timestamp(res[#{col} + offset])"
    elsif p.klass.ancestors.include?(Date)
      return "#{self.class}.parse_date(res[#{col} + offset])"
    elsif p.klass.ancestors.include?(TrueClass)
      return "('0' != res[#{col} + offset])"
    else 
      return "YAML.load(res[#{col} + offset])"
    end        
  end

  def eval_og_insert(klass)
    props = klass.properties
    values = props.collect { |p| write_prop(p) }.join(',') 
    
    sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"

    klass.class_eval %{
      def og_insert(store)
        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
        store.conn.query_with_result = false
        store.conn.query "#{sql}"
        @#{klass.pk_symbol} = store.conn.insert_id
        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
      end
    }
  end

end

end