module Bobot
  # Parses and raises Facebook response errors for the send API.
  class ErrorParser
    INTERNAL_ERROR_CODES = {
      1200 => [],
    }.freeze

    ACCESS_TOKEN_ERROR_CODES = {
      190 => [],
    }.freeze

    ACCOUNT_LINKING_ERROR_CODES = {
      10_303 => [],
    }.freeze

    LIMIT_ERROR_CODES = {
      4 => [2_018_022],
      100 => [2_018_109],
      613 => [nil],
    }.freeze

    BAD_PARAMETER_ERROR_CODES = {
      100 => [nil, 2_018_001],
    }.freeze

    PERMISSION_ERROR_CODES = {
      10 => [2_018_065, 2_018_108],
      200 => [1_545_041, 2_018_028, 2_018_027, 2_018_021],
      230 => [nil],
    }.freeze

    class << self
      # Raise any errors in the given response.
      #
      # response - A HTTParty::Response object.
      #
      # Returns nil if no errors were found, otherwises raises appropriately
      def raise_errors_from(response)
        return false unless response.key?('error')

        error = response['error']

        error_code = error['code']
        error_subcode = error['error_subcode']

        raise_code_only_error(error_code, error) if error_subcode.nil?

        raise_code_subcode_error(error_code, error_subcode, error)

        # Default to unidentified error
        raise FacebookError.new(error)
      end

    private

      def raise_code_only_error(error_code, args)
        raise InternalError.new(args)       if internal_error?(error_code)
        raise AccessTokenError.new(args)    if access_token_error?(error_code)
        raise AccountLinkingError.new(args) if account_linking_error?(error_code)
      end

      def raise_code_subcode_error(error_code, error_subcode, args)
        raise LimitError.new(args)        if limit_error?(error_code, error_subcode)
        raise BadParameterError.new(args) if bad_parameter_error?(error_code, error_subcode)
        raise PermissionError.new(args)   if permission_error?(error_code, error_subcode)
      end

      def internal_error?(error_code)
        INTERNAL_ERROR_CODES.key?(error_code)
      end

      def access_token_error?(error_code)
        ACCESS_TOKEN_ERROR_CODES.key?(error_code)
      end

      def account_linking_error?(error_code)
        ACCOUNT_LINKING_ERROR_CODES.key?(error_code)
      end

      def limit_error?(error_code, error_subcode)
        limit_errors = LIMIT_ERROR_CODES[error_code]
        return unless limit_errors

        limit_errors.include? error_subcode
      end

      def bad_parameter_error?(error_code, error_subcode)
        bad_parameter_errors = BAD_PARAMETER_ERROR_CODES[error_code]
        return unless bad_parameter_errors

        bad_parameter_errors.include? error_subcode
      end

      def permission_error?(error_code, error_subcode)
        permission_errors = PERMISSION_ERROR_CODES[error_code]
        return unless permission_errors

        permission_errors.include? error_subcode
      end
    end
  end
end