class Sequel::Schema::Generator

def self.add_type_method(*types)
  types.each do |type|
    class_eval("def #{type}(name, opts={}); column(name, #{type}, opts); end", __FILE__, __LINE__)
  end
end

def check(*args, &block)
  constraint(nil, *args, &block)
end

def column(name, type, opts = {})
  columns << {:name => name, :type => type}.merge(opts)
  index(name) if opts[:index]
end

def composite_foreign_key(columns, opts)
  constraints << {:type => :foreign_key, :columns => columns}.merge(opts)
end

def composite_primary_key(columns, *args)
  opts = args.pop || {}
  constraints << {:type => :primary_key, :columns => columns}.merge(opts)
end

def constraint(name, *args, &block)
  constraints << {:name => name, :type => :check, :check => block || args}
end

def dump_columns
  strings = []
  cols = columns.dup
  if pkn = primary_key_name
    cols.delete_if{|x| x[:name] == pkn}
    pk = @primary_key.dup
    pkname = pk.delete(:name)
    @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
    strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
  end
  cols.each do |c|
    c = c.dup
    name = c.delete(:name)
    type = c.delete(:type)
    opts = opts_inspect(c)
    strings << if type.is_a?(Class)
      "#{type.name} #{name.inspect}#{opts}"
    else
      "column #{name.inspect}, #{type.inspect}#{opts}"
    end
  end
  strings.join("\n")
end

def dump_constraints
  cs = constraints.map do |c|
    c = c.dup
    type = c.delete(:type)
    case type
    when :check
      raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
      name = c.delete(:name)
      if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
        "check #{c[:check].first.inspect[1...-1]}"
      else
        "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
      end
    else
      cols = c.delete(:columns)
      "#{type} #{cols.inspect}#{opts_inspect(c)}"
    end
  end
  cs.join("\n")
end

def dump_indexes(options={})
  is = indexes.map do |c|
    c = c.dup
    cols = c.delete(:columns)
    if table = options[:add_index] || options[:drop_index]
      "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{', :ignore_errors=>true' if options[:ignore_errors]}#{opts_inspect(c)}"
    else
      "index #{cols.inspect}#{opts_inspect(c)}"
    end
  end
  is.join("\n")
end

def foreign_key(name, table=nil, opts = {})
  opts = case table
  when Hash
    table.merge(opts)
  when Symbol
    opts.merge(:table=>table)
  when NilClass
    opts
  else
    raise(Error, "The second argument to foreign_key should be a Hash, Symbol, or nil")
  end
  return composite_foreign_key(name, opts) if name.is_a?(Array)
  column(name, Integer, opts)
end

def full_text_index(columns, opts = {})
  index(columns, opts.merge(:type => :full_text))
end

def has_column?(name)
  columns.any?{|c| c[:name] == name}
end

def index(columns, opts = {})
  indexes << {:columns => Array(columns)}.merge(opts)
end

def initialize(db, &block)
  @db = db
  @columns = []
  @indexes = []
  @constraints = []
  @primary_key = nil
  instance_eval(&block) if block
  @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
end

def method_missing(type, name = nil, opts = {})
  name ? column(name, type, opts) : super
end

def opts_inspect(opts)
  if opts[:default]
    opts = opts.dup
    de = case d = opts.delete(:default)
    when BigDecimal, Sequel::SQL::Blob
      "#{d.class.name}.new(#{d.to_s.inspect})"
    when DateTime, Date
      "#{d.class.name}.parse(#{d.to_s.inspect})"
    when Time
      "#{d.class.name}.parse(#{d.strftime('%H:%M:%S').inspect})"
    else
      d.inspect
    end
    ", :default=>#{de}#{", #{opts.inspect[1...-1]}" if opts.length > 0}"
  else
    ", #{opts.inspect[1...-1]}" if opts.length > 0
  end
end

def primary_key(name, *args)
  return composite_primary_key(name, *args) if name.is_a?(Array)
  @primary_key = @db.serial_primary_key_options.merge({:name => name})
  
  if opts = args.pop
    opts = {:type => opts} unless opts.is_a?(Hash)
    if type = args.pop
      opts.merge!(:type => type)
    end
    @primary_key.merge!(opts)
  end
  @primary_key
end

def primary_key_name
  @primary_key[:name] if @primary_key
end

def spatial_index(columns, opts = {})
  index(columns, opts.merge(:type => :spatial))
end

def unique(columns, opts = {})
  constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
end