require 'flydata-core/postgresql/pg_client'
require 'flydata-core/table_def/postgresql_table_def'
require 'flydata-core/table_def/value_conv'

module Flydata
module SourcePostgresql
module QueryBasedSync

class DiffQueryGenerator

  DEFAULT_LIMIT = 10000

  FETCH_RECORDS_SQL = <<EOS
SELECT %{columns} FROM %{table_name} WHERE %{where_clause} ORDER BY %{order_by_clause} LIMIT %{max_rows};
EOS

  TO_SID_WHERE_CLAUSE = "txid_visible_in_snapshot(xmin::TEXT::BIGINT, '%{to_sid}')"
  FROM_SID_WHERE_CLAUSE = "AND NOT txid_visible_in_snapshot(xmin::TEXT::BIGINT, '%{from_sid}')"

  def initialize(table, schema, query_cond = {})
    @table = table
    @schema = schema

    @columns = query_cond[:columns] or raise ArgumentError, "columns is required"
    @from_sid = query_cond[:from_sid]
    @to_sid = query_cond[:to_sid] or raise ArgumentError, "to_sid is required"
    @pk_columns = query_cond[:pk_columns] or raise ArgumentError, "pk_columns is required"
    @last_pks = query_cond[:last_pks]
    @limit = query_cond[:limit] || DEFAULT_LIMIT
  end

  def build_query(binding_param_enabled = true)
    from_sid_where_clause = if @from_sid
                              FROM_SID_WHERE_CLAUSE % {from_sid: @from_sid}
                            else
                              nil
                            end

    column_names, types = @columns.inject([[],[]]) do |arys, h|
      arys[0] << h[:column]; arys[1] << h[:type].gsub(/\(.+?\)/,''); arys
    end
    columns = column_list(column_names, types)

    query = FETCH_RECORDS_SQL % {
      columns: columns,
      table_name: fq_table_name(@table, @schema),
      where_clause: build_where_clause(@from_sid, @to_sid, @pk_columns, @last_pks, binding_param_enabled),
      order_by_clause: build_order_by_clause(@pk_columns),
      max_rows: @limit,
    }

    opts = {
      value_overriders: build_value_overriders(column_names, types)
    }

    if binding_param_enabled
      opts[:binding_params] = @last_pks
    end

    FlydataCore::Postgresql::PGQuery.new(query, opts)
  end

  private

  def build_where_clause(from_sid, to_sid, pk_columns, last_pks, binding_param_enabled)
    clauses = []
    clauses << TO_SID_WHERE_CLAUSE % { to_sid: to_sid }
    clauses << FROM_SID_WHERE_CLAUSE % { from_sid: from_sid } if from_sid
    if last_pks && !last_pks.empty?
      clauses << pk_conditions(pk_columns, last_pks, binding_param_enabled)
    end
    clauses.join(" ")
  end

  def build_order_by_clause(pk_columns)
    "#{pk_columns.collect{|col| %Q|"#{col}"| }.join(",")}"
  end

  def pk_conditions(pk_columns, last_pks, binding_param_enabled)
    i = pk_columns.size - 1
    str = nil
    while i >= 0
      colname = pk_columns[i]
      val = value_in_where(i, last_pks, binding_param_enabled)
      if str
        str = %Q|"#{colname}" > #{val} OR ("#{colname}" = #{val} AND (#{str}))|
      else
        str = %Q|"#{colname}" > #{val}|
      end
      i -= 1
    end
    " AND (#{str})"
  end

  def value_in_where(index, last_pks, binding_param_enabled)
    if binding_param_enabled
      "$#{index + 1}"
    else
      %Q|'#{last_pks[index]}'|
    end
  end

  def fq_table_name(table, schema)
    !schema.to_s.empty? ? %Q|"#{schema}"."#{table}"| : %Q|"#{table}"|
  end

  # return a list of columns with necessary conversion as a string
  QUERY_VAL_CONV_RULES = Hash.new do |h, k|
    h[k] =
      case k
        when "bytea"; %Q['0x' || encode("%<column>s", 'hex') AS "%<column>s"]
        else %Q["%<column>s"]
      end
  end

  VALUE_OVERRIDERS = Hash.new do |h, k|
    h[k] =
      case k
      when "bit", "varbit"; -> (v) { v ? '%d' % v.to_i(2) : nil }
      when "boolean"; -> (v) { FlydataCore::TableDef::PostgresqlTableDef::to_boolean(v) }
      when "money"; -> (v) { v ? FlydataCore::TableDef::ValueConv.strip_currency_format(v) : nil }
      else
        nil
      end
  end

  def column_list(columns, types)
    columns.each_with_index.collect{|c, i| QUERY_VAL_CONV_RULES[types[i]] % {column:c}}.join(", ")
  end

  def build_value_overriders(columns, types)
    columns.each_with_index.inject({}) do |h, (c, i)|
      overrider = VALUE_OVERRIDERS[types[i]]
      h[c] = overrider if overrider
      h
    end
  end
end

end
end
end