require 'json'

module ActiveMerchant #:nodoc:
  module Billing #:nodoc:
    # For more information on Balanced visit https://www.balancedpayments.com
    # or visit #balanced on irc.freenode.net
    #
    # Instantiate a instance of BalancedGateway by passing through your
    # Balanced API key secret.
    #
    # ==== To obtain an API key of your own
    #
    # 1. Visit https://www.balancedpayments.com
    # 2. Click "Get started"
    # 3. The next screen will give you a test API key of your own
    # 4. When you're ready to generate a production API key click the "Go
    #    live" button on the Balanced dashboard and fill in your marketplace
    #    details.
    class BalancedGateway < Gateway
      VERSION = "2.0.0"

      self.live_url = 'https://api.balancedpayments.com'

      self.supported_countries = ['US']
      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
      self.homepage_url = 'https://www.balancedpayments.com/'
      self.display_name = 'Balanced'
      self.money_format = :cents

      # Creates a new BalancedGateway
      #
      # ==== Options
      #
      # * <tt>:login</tt> -- The Balanced API Secret (REQUIRED)
      def initialize(options = {})
        requires!(options, :login)
        super
      end

      def purchase(money, payment_method, options = {})
        post = {}
        add_amount(post, money)
        post[:description] = options[:description]
        add_common_params(post, options)

        MultiResponse.run do |r|
          identifier = if(payment_method.respond_to?(:number))
            r.process{store(payment_method, options)}
            r.authorization
          else
            payment_method
          end
          r.process{commit("debits", "cards/#{card_identifier_from(identifier)}/debits", post)}
        end
      end

      def authorize(money, payment_method, options = {})
        post = {}
        add_amount(post, money)
        post[:description] = options[:description]
        add_common_params(post, options)

        MultiResponse.run do |r|
          identifier = if(payment_method.respond_to?(:number))
            r.process{store(payment_method, options)}
            r.authorization
          else
            payment_method
          end
          r.process{commit("card_holds", "cards/#{card_identifier_from(identifier)}/card_holds", post)}
        end
      end

      def capture(money, identifier, options = {})
        post = {}
        add_amount(post, money)
        post[:description] = options[:description] if options[:description]
        add_common_params(post, options)

        commit("debits", "card_holds/#{reference_identifier_from(identifier)}/debits", post)
      end

      def void(identifier, options = {})
        post = {}
        post[:is_void] = true
        add_common_params(post, options)

        commit("card_holds", "card_holds/#{reference_identifier_from(identifier)}", post, :put)
      end

      def refund(money, identifier, options = {})
        post = {}
        add_amount(post, money)
        post[:description] = options[:description]
        add_common_params(post, options)

        commit("refunds", "debits/#{reference_identifier_from(identifier)}/refunds", post)
      end

      def store(credit_card, options={})
        post = {}

        post[:number] = credit_card.number
        post[:expiration_month] = credit_card.month
        post[:expiration_year] = credit_card.year
        post[:cvv] = credit_card.verification_value if credit_card.verification_value?
        post[:name] = credit_card.name if credit_card.name

        add_address(post, options)

        commit("cards", "cards", post)
      end

      private

      def reference_identifier_from(identifier)
        case identifier
        when %r{\|}
          uri = identifier.
            split("|").
            detect{|part| part.size > 0}
          uri.split("/")[2]
        when %r{\/}
          identifier.split("/")[5]
        else
          identifier
        end
      end

      def card_identifier_from(identifier)
        identifier.split("/").last
      end

      def add_amount(post, money)
        post[:amount] = amount(money) if money
      end

      def add_address(post, options)
        address = (options[:billing_address] || options[:address])
        if(address && address[:zip].present?)
          post[:address] = {}
          post[:address][:line1] = address[:address1] if address[:address1]
          post[:address][:line2] = address[:address2] if address[:address2]
          post[:address][:city] = address[:city] if address[:city]
          post[:address][:state] = address[:state] if address[:state]
          post[:address][:postal_code] = address[:zip] if address[:zip]
          post[:address][:country_code] = address[:country] if address[:country]
        end
      end

      def add_common_params(post, options)
        post[:appears_on_statement_as] = options[:appears_on_statement_as]
        post[:on_behalf_of_uri] = options[:on_behalf_of_uri]
        post[:meta] = options[:meta]
      end

      def commit(entity_name, path, post, method=:post)
        raw_response = begin
          parse(ssl_request(
            method,
            live_url + "/#{path}",
            post_data(post),
            headers
          ))
        rescue ResponseError => e
          raise unless(e.response.code.to_s =~ /4\d\d/)
          parse(e.response.body)
        end

        Response.new(
          success_from(entity_name, raw_response),
          message_from(raw_response),
          raw_response,
          authorization: authorization_from(entity_name, raw_response),
          test: test?,
        )
      end

      def success_from(entity_name, raw_response)
        entity = (raw_response[entity_name] || []).first
        if(!entity)
          false
        elsif((entity_name == "refunds") && entity.include?("status"))
          %w(succeeded pending).include?(entity["status"])
        elsif(entity.include?("status"))
          (entity["status"] == "succeeded")
        elsif(entity_name == "cards")
          !!entity["id"]
        else
          false
        end
      end

      def message_from(raw_response)
        if(raw_response["errors"])
          error = raw_response["errors"].first
          (error["additional"] || error["message"] || error["description"])
        else
          "Success"
        end
      end

      def authorization_from(entity_name, raw_response)
        entity = (raw_response[entity_name] || []).first
        (entity && entity["id"])
      end

      def parse(body)
        JSON.parse(body)
      rescue JSON::ParserError
        message = 'Invalid response received from the Balanced API. Please contact support@balancedpayments.com if you continue to receive this message.'
        message += " (The raw response returned by the API was #{raw_response.inspect})"
        {
          "errors" => [{
            "message" => message
          }]
        }
      end

      def post_data(params)
        return nil unless params

        params.map do |key, value|
          next if value.blank?
          if value.is_a?(Hash)
            h = {}
            value.each do |k, v|
              h["#{key}[#{k}]"] = v unless v.blank?
            end
            post_data(h)
          else
            "#{key}=#{CGI.escape(value.to_s)}"
          end
        end.compact.join("&")
      end

      def headers
        @@ua ||= JSON.dump(
           bindings_version: ActiveMerchant::VERSION,
           lang: 'ruby',
           lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
           lib_version: BalancedGateway::VERSION,
           platform: RUBY_PLATFORM,
           publisher: 'active_merchant'
        )

        {
            "Authorization" => "Basic " + Base64.encode64(@options[:login].to_s + ":").strip,
            "User-Agent" => "Balanced/v1.1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
            "Accept" => "application/vnd.api+json;revision=1.1",
            "X-Balanced-User-Agent" => @@ua,
        }
      end
    end
  end
end