require 'payment/errors'
require 'payment/test_cards'
class Payment::TestGateway

  ERROR_MAP = { ERR20052: :insufficient_funds, ERR20051: :retry_later, ERR20011: :do_not_retry }.freeze

  FAILED_RESPONSE_EXAMPLE = { response_code: "99",
                              response_msg: "Declined",
                              error_code: "ERR10048",
                              error_msg: "Example error message",
                              violator_param: "MERCHANTPAYMENTID",
                              time: Time.now,
                              success: false,
                              amount: 10,
                              currency: 'USD',
                              error: nil }.freeze

  include Payment::Errors

  def self.active?
    true
  end

  def self.request
    {}
  end

  def self.dummy_api(amount, currency, from = nil, card = nil, refund = nil)
    if card
      success = card[:token] || Payment::TestCards.get(:test_gateway).map{ |c| c[:number] }.include?(card[:number])
      card_token = card[:token] || rand(2).to_s + SecureRandom.urlsafe_base64(23)
    end
    h = success || from || refund ? { success: true, amount: amount, currency: currency, card_token: card_token, pg_tran_date: Time.now.to_i } : FAILED_RESPONSE_EXAMPLE
    h = h.merge({ from_currency: from, to_currency: currency, converted_amount: amount }) if from
    h
  end

  def self.charge_from_card(payment, customer, card, pre_auth, saved_card)
    request = self.request.merge({card_token: card}) if saved_card
    card = saved_card ? { token: card } : card
    response = dummy_api(payment[:amount], payment[:currency], nil, card)
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.cancel_transaction(payment)
    request = self.request.merge({payment: payment})
    response = dummy_api(payment[:amount], payment[:currency], nil, nil, true)
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.refund_money(payment)
    request = self.request.merge({payment: payment})
    response = dummy_api(payment[:amount], payment[:currency], nil, nil, true)
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.query_saved_cards(customer)
    request = self.request.merge({customer: customer[:id]})
    response = { success: true, card_list: [{ "cardToken" => SecureRandom.urlsafe_base64(24) }] }
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.delete_card(token)
    request = self.request.merge({card_token: token})
    response = {success: true}
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.currency_exchange(from, to, amount)
    request = self.request.merge({from_currency: from, to_currency: to, amount: amount})
    response = dummy_api(amount, to, from)
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end

  def self.query_bin_number(bin_number)
    request = self.request.merge({bin: bin_number})
    response = { success: true, bin: { "cardBrand": %w[VISA MC].sample } }
    [request, response]
  rescue => e
    Payment.debug_message(request, response, e)
  end
end