module Sqlite
  module Pervasive
    module DatabaseMethods

      def dataset(opts = nil)
        ds = super
        ds.extend(DatasetMethods)
        ds
      end

      def select_fields(table, *fields)
        dataset.select_fields(table, *fields)
      end

    end

    module DatasetMethods

      def get_column_type(column_name)
        if model and model.respond_to?(:datatypes) and model.datatypes and model.datatypes[column_name]
          return model.datatypes[column_name][:type]
        end
        nil
      end

      def quoted_identifier(name, convert=true)
        convert ? "\"#{convert_aliased_col_to_real_col(name)}\"" : "\"#{name}\""
      end

      # Take a table name and write out the field names for that table in this style:
      # "`DUDES`.`KID - DATE`".lit    where the table name is :dudes,
      # and fields are [:kid_date]
      def select_fields(hash)
        new_hash = Hash.new{|k, v| k[v]= {}}

        hash.each do |association, fields|
          new_hash[association][:fields] = fields

          if association == :self
            new_hash[association][:model] = self.model
            new_hash[association][:association_name] = self.model.table_name
          elsif association.to_s.match /(\w+)__(\w+)/  # crew_legs__position_code
            # not an assocation on the current model .. but another one
            new_hash[association][:association_name] = $2.to_s.upcase
            new_hash[association][:model] = model.association_reflection($1.to_sym)[:class].association_reflection($2.to_sym)[:class]
          else
            raise(Sequel::Error, "Invalid #{model} association: #{association}") unless model.association_reflection(association)
            new_hash[association][:association_name] = association.to_s.upcase
            new_hash[association][:model] = model.association_reflection(association)[:class]
          end
          fields = fields + new_hash[association][:model].primary_key unless fields[0] == :*
          new_hash[association][:fields] = fields
        end

        s = []
        new_hash.each do |association, hash|
          if hash[:fields].size == 1 and hash[:fields][0] == :*
            s << "#{quoted_identifier(hash[:association_name], false)}.*".lit
          else
            s << hash[:fields].collect do |field|
              raw_field_name = convert_aliased_col_to_real_col_with_model(field, hash[:model])
              as_alias = ''
              raw_field_name

              if association != :self and ( hash[:model].primary_key.include? field or field_duplicate(new_hash, association, field) )
                as_field_name = "#{hash[:association_name]}_#{raw_field_name}"
                as_alias = "AS #{quoted_identifier(as_field_name, false)}"
              end
              "#{quoted_identifier(hash[:association_name], false)}.#{quoted_identifier(raw_field_name, false)} #{as_alias}".lit
            end
          end
        end

        clone(:select => s.flatten)
      end

      private

      # is the field name found in the fields of any other association besides the one you passed in
      def field_duplicate(hash, association, field)
        hash.each do |association_key, hash_values|
          next if association_key == association
          return true if hash_values[:fields].include? field
        end
        return false
      end

      def convert_aliased_col_to_real_col(col_name)
        if respond_to?(:model) and model.respond_to?(:aliases) and model.aliases
          sym_name = col_name.to_s.downcase.to_sym
          col_name = model.aliases[sym_name].to_s.upcase if model.aliases.include? sym_name
        end
        col_name
      end

      def convert_aliased_col_to_real_col_with_model(col_name, model)
        if model.respond_to?(:aliases) and model.aliases
          sym_name = col_name.to_s.downcase.to_sym
          col_name = model.aliases[sym_name].to_s.upcase if model.aliases.include? sym_name
        end
        col_name
      end
    end
  end
end