require 'flydata-core/errors'
require 'flydata-core/mysql/config'
require 'mysql2'

module FlydataCore
  module Mysql
    class CompatibilityChecker
      def initialize(option = {})
        option ||= {}
        @option = option.merge FlydataCore::Mysql::Config.build_mysql_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 MysqlCompatibilityChecker < 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 = Mysql2::Client.new(@option)
          client.query(query)
        ensure
          client.close rescue nil if client
        end
      end
    end

    class SyncPermissionChecker < MysqlCompatibilityChecker
      def create_query(option = @option)
        "SHOW GRANTS"
      end

      def check_result(result, option = @option)
        databases = ['mysql', @option[:database]]
        get_grant_regex = /GRANT (?<privs>.*) ON (`)?(?<db_name>[^`]*)(`)?\.\* TO '#{@option[:username]}/
        necessary_permission_fields = ["SELECT","RELOAD","LOCK TABLES","REPLICATION SLAVE","REPLICATION CLIENT"]
        all_privileges_field = ["ALL PRIVILEGES"]

        found_priv = Hash[databases.map {|d| [d,[]]}]
        missing_priv = {}

        result.each do |res|
          # SHOW GRANTS should only return one column
          res_value = res.values.first
          matched_values = res_value.match(get_grant_regex)
          next unless matched_values
          line_priv = matched_values["privs"].split(", ")
          if matched_values["db_name"] == "*"
            return true if (all_privileges_field - line_priv).empty?
            databases.each {|d| found_priv[d] << line_priv }
          elsif databases.include? matched_values["db_name"] 
            if (all_privileges_field - line_priv).empty?
              found_priv[matched_values["db_name"]] = necessary_permission_fields
            else
              found_priv[matched_values["db_name"]] << line_priv
            end
          end
          missing_priv = get_missing_privileges(found_priv, necessary_permission_fields)
          return true if missing_priv.empty?
        end
        error_text = "The user '#{@option[:username]}' does not have the correct permissions to run FlyData Sync\n"
        error_text << "    * These privileges are missing...\n"
        missing_priv.each_key {|db| error_text << "      for the database '#{db}': #{missing_priv[db].join(", ")}\n"}
        raise MysqlCompatibilityError, error_text
      end

      private

      def get_missing_privileges(found_priv, all_priv)
        return_hash = {}
        found_priv.each_key do |key|
          missing_priv = all_priv - found_priv[key].flatten.uniq
          return_hash[key] = missing_priv unless missing_priv.empty?
        end
        return_hash
      end
    end

    module MysqlVariablesHandling
      def create_query(option = @option)
        "SHOW VARIABLES;"
      end

      def convert_result_to_hash(result)
        ret = {}
        result.each do |record|
          k = record['Variable_name']
          v = record['Value']
          ret[k] = v
        end
        ret
      end
    end

    class BinlogParameterChecker < MysqlCompatibilityChecker
      include MysqlVariablesHandling


      BASE_SYS_VAR_TO_CHECK = {
        # parameter => expected value
        'binlog_format' => 'ROW',
        #'binlog_checksum' => 'NONE', # no longer necessary with mysql-replication-listener 0.2.0
        'log_bin_use_v1_row_events' => 'ON',
        'log_slave_updates' => 'ON',
      }

      ADDITIONAL_SYS_VAR_TO_CHECK = {
        # parameter => {"comparison sign"=>minimum value}
        'net_read_timeout'=>{'>='=>600},
        'net_write_timeout'=>{'>='=>600},
        #'wait_timeout'=>{'>='=>60},
      }

      SYS_VAR_TO_CHECK = BASE_SYS_VAR_TO_CHECK.merge(ADDITIONAL_SYS_VAR_TO_CHECK)

      def check_result(result, option = @option)
        param_hash = convert_result_to_hash(result)
        errors = compare_sys_var_values(param_hash, self.class::SYS_VAR_TO_CHECK)

        unless errors.empty?
          raise FlydataCore::MysqlCompatibilityError, build_error_message(errors)
        end
      end

      def build_error_message(errors)
        err_msg = errors.inject('') {|m, (k, v)| m << "\n    * #{v[:err_reason]}"}
        "These system variable(s) are not the correct value: #{err_msg}\n" +
        "   Please change these system variables for FlyData Sync to run"
      end

      private

      def compare_sys_var_values(input_value_hash, expected_value_hash)
        # { '<param-name>' => {actual_val: '<actual-val>', err_reason: '<err-reason>'} }
        errors = {}

        expected_value_hash.each do |param_name, exp_val_info|
          # Ignore parameters if not returned
          # binlog_checksum and log_bin_use_v1_row_events are supported only for Mysql v5.6
          next unless input_value_hash.has_key?(param_name)
          actual_val = input_value_hash[param_name]
          err_reason = nil

          if exp_val_info.kind_of?(Hash)
            exp_val_info.each do |compare_sym, exp_val|
              case compare_sym
              when '='
                unless actual_val.to_s != exp_val.to_s
                  err_reason = "#{param_name} is '#{actual_val}' but should be '#{exp_val}'"
                end
              when '>='
                unless actual_val.to_i >= exp_val.to_i
                  err_reason = "#{param_name} is '#{actual_val}' but should be at least '#{exp_val}'"
                end
              else
                raise "Unsupported compare symbol - #{compare_sym}"
              end
              break # support just one key-value for now
            end
          elsif exp_val_info.to_s != actual_val.to_s
            err_reason = "#{param_name} is '#{actual_val}' but should be '#{exp_val_info}'"
          end
          errors[param_name] = {actual_val: actual_val, err_reason: err_reason} if err_reason
        end
        errors
      end
    end

    class RequiredBinlogParameterChecker < BinlogParameterChecker
      SYS_VAR_TO_CHECK = BASE_SYS_VAR_TO_CHECK
    end

    class OptionalBinlogParameterChecker < BinlogParameterChecker
      SYS_VAR_TO_CHECK = ADDITIONAL_SYS_VAR_TO_CHECK

      def build_error_message(errors)
        err_msg = errors.inject('') {|m, (k, v)| m << "\n    * #{v[:err_reason]}"}
        "[WARNING] These system variable(s) are not the recommended values: #{err_msg}\n" +
        "   These settings are not required but highly recommended for the FlyData Agent to run as efficiently as possible"
      end
    end

    class TableExistenceChecker < MysqlCompatibilityChecker
      TABLE_EXISTENCE_CHECK_QUERY_TMPLT = <<EOT
SELECT
  t.table_name as table_name
FROM
  information_schema.tables t
WHERE
  t.table_schema='%{database}'
  AND t.table_name in (%{table_names});
EOT
      def create_query(option = @option)
        TABLE_EXISTENCE_CHECK_QUERY_TMPLT % {database: option[:database], table_names: option[:tables].collect{|tn| "'#{tn}'"}.join(',')}
      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::MysqlCompatibilityError,
            "These tables are missing. Create these tables on your database or remove them from the data entry : #{missing_tables.join(", ")}"
        end
      end
    end

    class TableTypeChecker < MysqlCompatibilityChecker
      SELECT_TABLE_INFO_TMPLT = 
        "SELECT table_name, table_type, engine " +
        "FROM information_schema.tables " +
        "WHERE table_schema = '%s' and table_name in (%s)"

      UNSUPPORTED_ENGINES = %w(MEMORY BLACKHOLE)

      # option[:client] : Mysql2::Client object
      # option[:tables] : target table list
      def create_query(option = @option)
        SELECT_TABLE_INFO_TMPLT % [
          Mysql2::Client.escape(option[:database]),
          option[:tables].collect{|t| "'#{Mysql2::Client.escape(t)}'"}.join(", ")
        ]
      end

      def check_result(result, option = @option)
        invalid_tables = []
        result.each do |r|
          invalid_tables.push(r['table_name']) if r['table_type'] == 'VIEW' || UNSUPPORTED_ENGINES.include?(r['engine'])
        end

        unless invalid_tables.empty?
          raise FlydataCore::MysqlCompatibilityError,
            "FlyData does not support VIEW and #{UNSUPPORTED_ENGINES.join(',')} STORAGE ENGINE table. " +
            "Remove following tables from data entry: #{invalid_tables.join(", ")}"
        end
      end
    end

    class PrimaryKeyChecker < MysqlCompatibilityChecker
      PK_CHECK_QUERY_TMPLT = <<EOT
SELECT
  t.table_name,
  SUM(IF(tc.constraint_type='PRIMARY KEY', 1, 0)) as num_pk
FROM
  (select * from information_schema.tables where table_schema = '%{database}' AND table_name in (%{table_names})) t
  LEFT OUTER JOIN
  (select * from information_schema.table_constraints where table_schema = '%{database}' AND table_name in (%{table_names})) tc
  USING (table_schema, table_name)
GROUP BY
  t.table_schema, t.table_name
HAVING
  num_pk = 0;
EOT
      def create_query(option = @option)
        PK_CHECK_QUERY_TMPLT % {database: option[:database], table_names: option[:tables].collect{|tn| "'#{tn}'"}.join(',')}
      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::MysqlCompatibilityError,
            "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

    class NonRdsRetentionChecker < MysqlCompatibilityChecker
      include MysqlVariablesHandling

      BINLOG_RETENTION_HOURS = 24
      EXPIRE_LOGS_DAYS_LIMIT = BINLOG_RETENTION_HOURS / 24

      def check_result(result, option = @option)
        param_hash = convert_result_to_hash(result)

        if param_hash["expire_logs_days"].to_s != '0' &&
           param_hash["expire_logs_days"].to_i <= EXPIRE_LOGS_DAYS_LIMIT
          raise FlydataCore::MysqlCompatibilityError,
            "Binary log retention is too short\n " +
            "  We recommend the system variable '@@expire_logs_days' to be either set to 0 or at least #{EXPIRE_LOGS_DAYS_LIMIT} day(s)"
        end
      end
    end

    class RdsMasterStatusChecker < MysqlCompatibilityChecker
      BINLOG_RETENTION_HOURS = NonRdsRetentionChecker::BINLOG_RETENTION_HOURS

      def create_query(option = @option)
        "show master status;"
      end

      # "show master status;" returns nothing if backup retention period is not set.
      def check_result(result, option = @option)
        if result.first.nil?
          raise FlydataCore::MysqlCompatibilityError,
            "Backup Retention Period must be set on your RDS console."
        end
      end
    end

    class RdsRetentionChecker < MysqlCompatibilityChecker
      BINLOG_RETENTION_HOURS = NonRdsRetentionChecker::BINLOG_RETENTION_HOURS

      def create_query(option = @option)
        "call mysql.rds_show_configuration;"
      end

      def check_result(result, option = @option)
        if result.first["name"] == "binlog retention hours"
          if result.first["value"].nil? ||
             result.first["value"].to_i <= BINLOG_RETENTION_HOURS
            raise FlydataCore::MysqlCompatibilityError,
              "Binary log retention is too short\n" +
              "  We recommend setting RDS binlog retention " +
              "to be at least #{BINLOG_RETENTION_HOURS} hours. To do this, " +
              "run this on your RDS MySQL database:\n" +
              "  $> call mysql.rds_set_configuration('binlog retention hours', 94);"
          end
        end
      end
    end
  end
end