def ca
  Java::Ca
end


module DBRB_java_access

  include Java

  class DBTarget
    def initialize( dbsession )
      @db = dbsession
    end
    
    def db
      @db
    end    
  end

  class ExportContext
    
    def initialize( srcdbsession, destdbsession )
      @srcdb = srcdbsession
      @destdb = destdbsession
      @params = nil
    end
    
    def parameters
      @params
    end

    def parameters=( params )
      @params = params
    end
    
    def source
      @srcdb
    end

    def destination
      @destdb
    end

    def to( db )
      return DBTarget.new( db )
    end

    def import( sql, params=nil )
      if params == nil
        params = @parameters
      end
      
      @destdb.exec sql, params
    end
    
  end
  
  
  class DBSession
    
    @@default_source = nil
    @@default_destination = nil
    
    def initialize( url )
      @dbsession = ca.pencilneck.dbrb::DBSession.new( url )
      @console = @dbsession.getConsole()
      @console.system "Connection " + self.object_id.to_s + " created and linked to " + url
    end
    
    def url
      @dbsession.getURL
    end
    
    def console
      @console
    end
    
    def self.default_source
      @@default_source
    end

    def self.default_source= ( db )
      @@default_source = db
      db.console.system "Default source set to " + db.url
    end

    def self.default_destination
      @@default_destination
    end

    def self.default_destination= ( db )
      @@default_destination = db
      db.console.system "Default destination set to " + db.url
    end
    
    def exec( sql, params=nil )
      @dbsession.exec( sql, params )
    end

    def query( sql, params=nil )
      @dbsession.query( sql, params )
    end

    def query_scalar( sql, params=nil )
      @dbsession.query_scalar( sql, params )
    end

    def show_query( sql, params=nil )
      @dbsession.show_query( sql, params )
    end

    def show_query_again( params=nil )
      @dbsession.show_query_again( params )
    end
    
    def enable_pooling ()
      @dbsession.enableStatementPool()
    end

    def disable_pooling ()
      @dbsession.disableStatementPool()
    end
    
    def export( *args, &block )
      if (! block_given?)
        throw "Can't export without a processing block."
      end
      
      sql = nil;
      dest = nil;
      params = nil;
    
      args.each do |a|
        if a.is_a? String then sql=a end
        if a.is_a? Hash then params=a end
        if a.is_a? DBTarget then dest=a.db end
        if a.is_a? DBSession then dest=db end
      end
    
      if sql.nil? then throw "Can't export without an SQL statement to export from." end
      if dest.nil? then dest=@@default_destination end 

      ctx = ExportContext.new self, dest
      rs = self.query sql, params
      dest.enable_pooling
      
      while rs.next
        ctx.parameters = ca.pencilneck.dbrb::DBSession.getCurrentResultValues( rs, self )
        ctx.instance_eval(&block)
      end
      
      rs.close
      dest.disable_pooling
      
    end
    
  end

end

def show_param ( p )
  ca.pencilneck.dbrb::DBSession.show_param( p )
end

def source ( url=nil )
  if url != nil
    DBRB_java_access::DBSession.default_source = DBRB_java_access::DBSession.new url 
  end
  DBRB_java_access::DBSession.default_source
end

def destination ( url=nil )
  if url != nil
    DBRB_java_access::DBSession.default_destination = DBRB_java_access::DBSession.new url 
  end
  DBRB_java_access::DBSession.default_destination
end

def to( db )
  return DBRB_java_access::DBTarget.new( db )
end

def source_exec ( sql, params=nil )
  source.exec( sql, params )
end

def source_query_scalar ( sql, params=nil )
  source.query_scalar( sql, params )
end

def source_show_query ( sql, params=nil )
  source.show_query( sql, params )
end

def destination_exec ( sql, params=nil )
  destination.exec( sql, params )
end

def destination_query_scalar ( sql, params=nil )
  destination.query_scalar( sql, params )
end

def destination_show_query ( sql, params=nil )
  destination.show_query( sql, params )
end

def export( *args, &block )
  source.export(*args, &block)
end