require 'flydata-core/errors'
require 'flydata-core/postgresql/config'
require 'pg'

module FlydataCore
  module Postgresql
    class CompatibilityChecker
      def initialize(option = {})
        option ||= {}
        @option = option.merge FlydataCore::Postgresql::Config.build_db_opts(option)
      end

      def do_check(option = @option, &block)
        result = block.call create_query(option)
        check_result(result, option)
      end

      # Override
      #def create_query(option = @option)
      #end

      # Override
      #def validate_result(result, option = @option)
      #end
    end

    class PostgresqlCompatibilityChecker < CompatibilityChecker
      def do_check(option = @option, &block)
        query = create_query(option)
        result = if block
                   block.call query
                 else
                   exec_query(query)
                 end
        check_result(result, option)
      end

      def exec_query(query)
        begin
          client = PGconn.connect(FlydataCore::Postgresql::Config.opts_for_pg(@option))
          client.exec(query)
        ensure
          client.close rescue nil if client
        end
      end

      def schema_and_table_in_query(option = @option)
        schema = if option[:schema].to_s.strip.empty?
                   "select current_schema"
                 else
                   "'#{option[:schema]}'"
                 end
        {
          schema_name: schema,
          table_names: option[:tables].collect{|tn| "'#{tn}'"}.join(',')
        }
      end
    end

    class TableExistenceChecker < PostgresqlCompatibilityChecker
      TABLE_EXISTENCE_CHECK_QUERY_TMPLT = <<EOT
SELECT
  table_name
FROM
  information_schema.tables
WHERE
  table_schema in (%{schema_name})
  AND
  table_name in (%{table_names});
EOT

      def create_query(option = @option)
        TABLE_EXISTENCE_CHECK_QUERY_TMPLT % schema_and_table_in_query(option)
      end

      def check_result(result, option = @option)
        existing_tables = []
        result.each {|r| existing_tables << r['table_name']}
        missing_tables = option[:tables] - existing_tables

        unless missing_tables.empty?
          raise FlydataCore::PostgresqlCompatibilityError,
            "These tables are missing. Create these tables on your database or remove them from the data entry : #{missing_tables.join(", ")}"
        end
      end
    end

    class PrimaryKeyChecker < PostgresqlCompatibilityChecker
      PK_CHECK_QUERY_TMPLT = <<EOT
SELECT
  t.table_name
FROM
  (select * from information_schema.tables where table_schema in (%{schema_name}) AND table_name in (%{table_names})) t
  LEFT OUTER JOIN
  (select * from information_schema.table_constraints where table_schema in (%{schema_name}) AND table_name in (%{table_names})) tc
  USING (table_schema, table_name)
GROUP BY
  t.table_schema, t.table_name
HAVING
  SUM(CASE WHEN tc.constraint_type='PRIMARY KEY' THEN 1 ELSE 0 END) = 0;
EOT

      def create_query(option = @option)
        PK_CHECK_QUERY_TMPLT % schema_and_table_in_query(option)
      end

      def check_result(result, option = @option)
        missing_pk_tables = []
        result.each {|r| missing_pk_tables << r['table_name']}

        unless missing_pk_tables.empty?
          raise FlydataCore::PostgresqlCompatibilityError,
            "Primary key is required for tables to sync. " +
            "Add primary key or remove following tables from data entry: #{missing_pk_tables.join(", ")}"
        end
      end
    end
  end
end