require 'pp'
require 'yaml'

class Bjorm
  attr_accessor :path, :tables, :extension

  def initialize(path='./', extension="tbl")
    @extension = extension
    @path = File.join(File.dirname(__FILE__), path)
    @tables = {}
  end

  def add_table(name, columns=[])
    a = BjormTable.new(@path, @extension, name, columns)
    yield a if block_given?
    @tables[name] = a
    a
  end

  def load_table(name)
    file = File.join( @path, "#{name}.#{@extension}")
    table = YAML.load_file(file)
    @tables[name] = table
    table
  end
end

class BjormTable
  attr_accessor :name, :columns, :file

  def initialize(path, extension, name, columns)
    @name = name
    @file = File.join(File.dirname(__FILE__), path, "#{name}.#{extension}")
    @columns = Hash.new {|h,k| h[k] = {}}
    @records = {}
    columns.each { |column,klass| @columns[column]['class'] = klass.to_s }
  end

  def column(name,klass)
    @columns[name]['class'] = klass.to_s
  end

  def serialize
    File.open(@file, 'w+') { |f| f << self.to_yaml }
  end

  def add_record(key,hash, &block)
    unless @records.has_key? key
      @records[key] = {}
      hash.each {|column,data|
        if @columns.has_key? column
          @records[key][column] = data if data.is_a? Object.const_get(@columns[column]['class'])
        end
      }
      @records[key]
    else
       raise "Key already exists!"
    end
  end

  def insert(hash = {})
    key = @records.keys.max
    if key.nil?
      key = 1
    else
      key += 1
    end
    record = add_record(key,hash)
    yield record if block_given?
  end

  def project(keys)
    records = @records.inject({}) { |hsh, (key, data)| hsh.update(key => data.reject { |k,v| ! keys.include?(k) }) }
  end

  def select(*keys, &block)
    unless keys.empty?
      records = project(keys)
    else
      records = @records
    end

    if block_given?
      records.delete_if { |key, value| not block.call(value)}
    else
      records
    end
  end

  def find(key)
    @records[key]
  end
end

if __FILE__ == $0
  require "test/unit"

  class TestBjorm < Test::Unit::TestCase
    def setup
      @db = Bjorm.new('./','ttbl')
      @table = BjormTable.new('./', 'ttbl', :shows, :name => String, :director => String, :author => String)
      File.delete(@table.file) if File.exists?(@table.file)
    end

    def test_add_table
      assert_equal @db.tables.size, 0
      table = @db.add_table(:shows, :name => String, :director => String, :author => String)
      assert_equal @db.tables.size, 1
      assert_equal @db.tables[:shows], table
    end

    def test_add_table_with_block
      assert_equal @db.tables.size, 0

      table = @db.add_table('people') { |t|
        t.column 'name', String
        t.column 'age', String
      }

      assert_equal @db.tables.size, 1
      assert_equal @db.tables['people'], table
      assert @db.tables['people'].columns.has_key?('name')
    end

    def test_load_table
      @table.add_record(1, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')
      @table.serialize

      assert_equal(0, @db.tables.size)
      @db.load_table(:shows)
      assert_equal(1, @db.tables.size)

      File.delete(@table.file)
    end
  end

  class TestBjormTable < Test::Unit::TestCase
    def setup
      @table = BjormTable.new('./', 'ttbl', :shows, :name => String, :director => String, :author => String)
      class<<@table
        attr_accessor :records
      end
    end

    def test_new_table
      assert_equal @table.file, File.join(File.dirname(__FILE__), './shows.ttbl')
      assert_equal @table.columns, {:name => {'class' => 'String'}, :director => {'class' => 'String'}, :author => {'class' => 'String'}}
    end

    def test_add_record
      assert_equal @table.records.size, 0
      @table.add_record(1, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')
      assert_equal @table.records.size, 1
      assert_raise(RuntimeError) { @table.add_record(1, :pie) }
    end

    def test_insert
      assert_equal @table.records.size, 0
      @table.insert(:name => 'Proof', :director => 'Mad', :author => 'Dave')
      assert_equal @table.records.size, 1
      assert_equal @table.select.keys.max, 1
      @table.add_record(22, :name => 'wow', :director => 'huh', :author => 'damn')
      @table.insert(:name => 'cat', :author => 'dog', :director => 'horse')
      assert_equal @table.select.keys.max, 23
    end

    def test_insert_with_block
      assert_equal @table.records.size, 0
      @table.insert do |record|
        record[:name] = 'No Exit'
        record[:author] = 'Sarte'
        record[:director] = 'Southwest'
      end
      assert_equal @table.records.size, 1
    end

    def test_column
      assert_equal 3, @table.columns.size
      @table.column :drama, :Symbol
      assert_equal 4, @table.columns.size
      assert_equal({'class' => 'Symbol'}, @table.columns[:drama])
    end

    def test_select
      assert_equal @table.select.size, 0
      @table.add_record(1, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')
      assert_equal @table.select.size, 1
      assert !@table.select(:name)[1].has_key?(:director)
      assert @table.select[1].has_key?(:director)
      assert_equal @table.select(:name), {1 => {:name => 'Proof'} }
      assert_equal @table.select, { 1 => {:name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn'} }
    end

    def test_select_with_block
      @table.add_record(1, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')
      @table.add_record(2, :name => 'On The Verge', :director => 'Ellen Fenster', :author => 'unknown')

      result = @table.select { |x| x[:name] == 'Proof' }
      assert_equal(result, { 1 => {:name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn'} } )

      @table.add_record(3, :name => 'Poof', :director => 'Mdeline Ringham', :author => 'Jon Fraatz')
      assert_equal 1, @table.select { |x| x[:name] =~ /oof/ && x[:director] =~ /Mad/}.size
    end

    def test_find
      assert_nil @table.find(2)
      @table.add_record(2, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')
      assert_equal @table.find(2), :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn'
    end

    def test_serialize
      File.delete(@table.file) if File.exists?(@table.file)

      @table.add_record(1, :name => 'Proof', :director => 'Madeline Ringham', :author => 'David Auburn')

      @table.serialize
      assert File.exists?(@table.file)

      a = YAML.load_file(@table.file)
      assert_instance_of(BjormTable, a)
      assert_equal @table.columns, a.columns

      File.delete(@table.file)
    end
  end
end