require 'digest/md5'

class BtrieveRecord
  include Btrieve
  attr_reader :data_buffer, :btrieve_table

  def initialize(btrieve_table, data_buffer = nil )
    @btrieve_table = btrieve_table
    @data_buffer = data_buffer.nil? ? Btrieve.create_string_buffer(@btrieve_table.schema[:record_size]) : data_buffer
    @session = @btrieve_table.session
  end

  def insert
    btr_op(@session, INSERT, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, NO_CURRENCY_CHANGE)
  end

  def update
    btr_op(@session, UPDATE, @btrieve_table.pos_buffer, @data_buffer, NULL_BUFFER, NO_CURRENCY_CHANGE)
  end

  def delete
    btr_op(@session, DELETE, @btrieve_table.pos_buffer, NULL_BUFFER, NULL_BUFFER, NULL_KEY)
  end

  def get_attributes(keys)
    keys.inject({}){|vals, key| vals[key]=self[key]; vals}
  end

  def get_all_attributes()
    get_attributes(self.btrieve_table.schema[:columns].keys.sort.inject([]){|array,column|array<<column;array})
  end

  def primary_key()
    get_composite_key(PK_KEYS)
  end

  def foreign_key(prefix)
    keys=PK_KEYS.map{|key|:"#{prefix} #{key.to_s}"}
    get_composite_key(keys)
  end

  def get_unique_reference(association_name)
    dereference(:one_to_one, association_name) do |map, target, index|
      fk_columns = map.keys.inject([]){|vals, column| vals << column; vals}
      fk_values = get_attributes(fk_columns)
      pk_values = map.keys.inject({}){|vals, column| vals[map[column]] = fk_values[column]; vals}
      target.find_in_unique_index(pk_values, index)
    end
  end

  def get_multiple_references(association_name)
    dereference(:one_to_many, association_name) do |map, target, index|
      pk_columns = map.keys.inject([]){|vals, column| vals << map[column] unless map[column] == nil; vals}
      pk_values = get_attributes(pk_columns)
      fk_values = map.keys.inject({}){|vals, column| vals[column] = pk_values[map[column]]; vals}
      target.find_in_index(fk_values, index)
    end
  end

  def [](key_name)
    schema_key=get_schema_key(key_name)
    return nil if(schema_key.nil?)
    raw_data=@data_buffer.unpack(schema_key[:unpacker])[0]
    meta = @session.btrieve_meta
    return raw_data if meta.nil?    # BS LOC - I'm ashamed
    meta.up(@btrieve_table.tablename, key_name, raw_data)
  end

#  def [](key_name)
#    schema_key = get_schema_key(key_name)
#    @data_buffer.unpack(schema_key[:unpacker])[0] if schema_key
#  end
  
  def []=(key_name, raw_data)
    value=@session.btrieve_meta.down(@btrieve_table.tablename, key_name, raw_data)
    schema_key = get_schema_key(key_name)
    packer_string = schema_key[:unpacker]
    match = packer_string.match(/@(\d+)([a-zA-Z]+)(\d*)/)
    offset = match[1].to_i
    datatype = match[2]
    sizeof = BtrieveSchema.sizeof(datatype)
    sizeof *= match[3].empty? ? 1 : match[3].to_i
    packer = "#{datatype}#{sizeof}"
    array = [value]
    packed_value = array.pack(packer)
    range = (offset..offset+sizeof-1)
    @data_buffer[range] = packed_value
  end

  def to_s()
    @btrieve_table.schema[:columns].keys.inject('') { |pretty_print, key| pretty_print = "#{pretty_print} #{key}=>#{self[key]}"; pretty_print }
  end

  def method_missing(symbol)
    return get_unique_reference(symbol) if(@btrieve_table.schema[:one_to_one][symbol])
    return get_multiple_references(symbol) if(@btrieve_table.schema[:one_to_many][symbol])
    super(symbol)
  end

  def version()
    Digest::MD5.hexdigest(@data_buffer)
  end

  private

  def dereference(association_group, association_name, &block)
    association = @btrieve_table.schema[association_group][association_name]
    raise Exception.new("Unknown association '#{association_name}' for table '#{@btrieve_table.tablename}'.") unless association != nil
    map = association[:map]
    target = eval(association[:class].to_s)
    index = association[:index]
    yield(map, target, index)
  end

  def get_schema_key(key_name)
    schema_key = @btrieve_table.schema[:columns][key_name]
    # raising this exception is hurting the dbr process since I use keys that dont exist
    # raise Exception.new("Unknown column '#{key_name}' for table '#{@btrieve_table.tablename}'.") unless schema_key != nil
    schema_key
  end

  def get_composite_key(keys)
    pk=keys.inject([]){|arr,col|arr<<self[col];arr}
    pk[2]=pk[2].strip
    pk.join('.')
  end
end