class OCI8::Object::Base

def self.default_connection=(con)
  @@default_connection = con
end

def self.get_class_by_typename(name)
  @@name_to_class[name]
end

def self.inherited(klass)
  name = klass.to_s.gsub(/^.*::/, '').gsub(/([a-z\d])([A-Z])/,'\1_\2').upcase
  @@class_to_name[klass] = name
  @@name_to_class[name] = klass
end

def self.method_missing(method_id, *args)
  if args[0].is_a? OCI8
    con = args.shift
  else
    con = @@default_connection
  end
  tdo = con.get_tdo_by_class(self)
  return_type = tdo.class_methods[method_id]
  if return_type == :none
    # procedure
    bind_arg_helper = BindArgumentHelper.new(*args)
    sql = <<EOS
o.typename}.#{method_id}(#{bind_arg_helper.arg_str});
    csr = con.parse_internal(sql)
    begin
      bind_arg_helper.exec(con, csr)
    ensure
      csr.close
    end
    return nil
  elsif return_type
    # function
    return_type = tdo.class_methods[method_id]
    bind_arg_helper = BindArgumentHelper.new(*args)
    sql = <<EOS
:= #{tdo.typename}.#{method_id}(#{bind_arg_helper.arg_str});
    csr = con.parse_internal(sql)
    begin
      csr.bind_param(:rv, nil, return_type)
      bind_arg_helper.exec(con, csr)
      rv = csr[:rv]
    ensure
      csr.close
    end
    return rv
  end
  super # The method is not found.
end

def self.set_typename(name)
  # delete an old name-to-class mapping.
  @@name_to_class[@@class_to_name[self]] = nil
  # set a new name-to-class mapping.
  name = name.upcase
  @@class_to_name[self] = name
  @@name_to_class[name] = self
end

def self.typename
  @@class_to_name[self]
end

def initialize(*args)
  @attributes = {}
  if args[0].is_a? OCI8
    @con = args.shift
  else
    @con = @@default_connection
  end
  return if args.empty?
  raise "no connection is specified." if @con.nil?
  # setup a TDO object.
  tdo = @con.get_tdo_by_class(self.class)
  # call constructor.
  bind_arg_helper = BindArgumentHelper.new(*args)
  sql = <<EOS
f := #{tdo.typename}(#{bind_arg_helper.arg_str});
  csr = @con.parse_internal(sql)
  begin
    csr.bind_param(:self, nil, :named_type_internal, tdo)
    bind_arg_helper.exec(@con, csr)
    @attributes = csr[:self].attributes
  ensure
    csr.close
  end
end

def method_missing(method_id, *args)
  if @attributes.is_a? Array
    return @attributes if method_id == :to_ary
    super
  end
  # getter func
  if @attributes.has_key?(method_id)
    if args.length != 0
      raise ArgumentError, "wrong number of arguments (#{args.length} for 0)"
    end
    return @attributes[method_id]
  end
  # setter func
  method_name = method_id.to_s
  if method_name[-1] == ?=
    attr = method_name[0...-1].intern
    if @attributes.has_key?(attr)
      if args.length != 1
        raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
      end
      return @attributes[attr] = args[0]
    end
  end
  super if @con.nil?
  tdo = @con.get_tdo_by_class(self.class)
  return_type = tdo.instance_methods[method_id]
  if return_type == :none
    # procedure
    bind_arg_helper = BindArgumentHelper.new(*args)
    sql = <<EOS
E
#{tdo.typename} := :self;
#{method_id}(#{bind_arg_helper.arg_str});
f := val;
    csr = @con.parse_internal(sql)
    begin
      csr.bind_param(:self, nil, :named_type_internal, tdo)
      csr[:self].attributes = self
      bind_arg_helper.exec(@con, csr)
      @attributes = csr[:self].attributes
    ensure
      csr.close
    end
    return nil
  elsif return_type
    # function
    bind_arg_helper = BindArgumentHelper.new(*args)
    sql = <<EOS
E
#{tdo.typename} := :self;
:= val.#{method_id}(#{bind_arg_helper.arg_str});
f := val;
    csr = @con.parse_internal(sql)
    begin
      csr.bind_param(:self, nil, :named_type_internal, tdo)
      csr.bind_param(:rv, nil, return_type)
      csr[:self].attributes = self
      bind_arg_helper.exec(@con, csr)
      @attributes = csr[:self].attributes
      rv = csr[:rv]
    ensure
      csr.close
    end
    return rv
  end
  # The method is not found.
  super
end # method_missing