class SnapTrade::Configuration

def self.default
  @@default ||= Configuration.new
end

def api_key_with_prefix(param_name, param_alias = nil)
  value = @api_key_store[param_name]
  value = @api_key_store.fetch(param_alias, value) unless param_alias.nil?
  return nil if value.nil?
  if @api_key_prefix[param_name]
    "#{@api_key_prefix[param_name]}#{value}"
  else
    value
  end
end

def auth_settings
  {
    'PartnerClientId' =>
      {
        type: 'api_key',
        in: 'query',
        key: 'clientId',
        value: api_key_with_prefix('PartnerClientId')
      },
    'PartnerSignature' =>
      {
        type: 'api_key',
        in: 'header',
        key: 'Signature',
        value: api_key_with_prefix('PartnerSignature')
      },
    'PartnerTimestamp' =>
      {
        type: 'api_key',
        in: 'query',
        key: 'timestamp',
        value: api_key_with_prefix('PartnerTimestamp')
      },
  }
end

def base_path=(base_path)
  # Add leading and trailing slashes to base_path
  @base_path = "/#{base_path}".gsub(/\/+/, '/')
  @base_path = '' if @base_path == '/'
end

def base_url(operation = nil)
  index = server_operation_index.fetch(operation, server_index)
  return "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '') if index == nil
  server_url(index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])
end

def client_id=(value)
  @api_key_store['PartnerClientId'] = value
end

def configure
  yield(self) if block_given?
end

def configure_middleware(connection)
  return if @middlewares.empty?
  [:request, :response, :use, :insert, :insert_before, :insert_after, :swap].each do |operation|
    next unless @middlewares.key?(operation)
    @middlewares[operation].each do |key, args, block|
      connection.builder.send(operation, key, *args, &block)
    end
  end
  if @middlewares.key?(:delete)
    @middlewares[:delete].each do |key, _args, _block|
      connection.builder.delete(key)
    end
  end
end

def consumer_key=(value)
  if value.nil? || value.empty?
    raise ArgumentError, "Invalid value for consumer_key, must be non-empty string"
  end
  @consumer_key = value
end

def host=(host)
  # remove http(s):// and anything after a slash
  @host = host.sub(/https?:\/\//, '').split('/').first
  # try to set @scheme and @base_path if possible
  begin
    uri = URI.parse(host)
    @scheme = uri.scheme
    @base_path = uri.path
  rescue InvalidURIError
  end
  # unset server_index so host is used when getting request url (see ApiClient#build_request_url)
  @server_index = nil
end

def initialize
  @scheme = 'https'
  @host = 'api.snaptrade.com'
  @base_path = '/api/v1'
  @server_index = 0
  @server_operation_index = {}
  @server_variables = {}
  @server_operation_variables = {}
  @api_key_store = {}
  @api_key_prefix = {}
  @client_side_validation = true
  @ssl_verify = true
  @ssl_verify_mode = nil
  @ssl_ca_file = nil
  @ssl_client_cert = nil
  @ssl_client_key = nil
  @middlewares = Hash.new { |h, k| h[k] = [] }
  @timeout = 60
  # return data as binary instead of file
  @return_binary_data = false
  @params_encoder = nil
  @debugging = false
  @inject_format = false
  @force_ending_format = false
  @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
  yield(self) if block_given?
end

def operation_server_settings
  {
  }
end

def request(*middleware)
  set_faraday_middleware(:request, *middleware)
end

def response(*middleware)
  set_faraday_middleware(:response, *middleware)
end

def scheme=(scheme)
  # remove :// from scheme
  @scheme = scheme.sub(/:\/\//, '')
end

def server_settings
  [
    {
      url: "https://api.snaptrade.com/api/v1",
      description: "SnapTrade Production API",
    }
  ]
end

def server_url(index, variables = {}, servers = nil)
  servers = server_settings if servers == nil
  # check array index out of bound
  if (index < 0 || index >= servers.size)
    fail ArgumentError, "Invalid index #{index} when selecting the server. Must be less than #{servers.size}"
  end
  server = servers[index]
  url = server[:url]
  return url unless server.key? :variables
  # go through variable and assign a value
  server[:variables].each do |name, variable|
    if variables.key?(name)
      if (!server[:variables][name].key?(:enum_values) || server[:variables][name][:enum_values].include?(variables[name]))
        url.gsub! "{" + name.to_s + "}", variables[name]
      else
        fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variables[name]}. Must be #{server[:variables][name][:enum_values]}."
      end
    else
      # use default value
      url.gsub! "{" + name.to_s + "}", server[:variables][name][:default_value]
    end
  end
  url
end

def set_faraday_middleware(operation, key, *args, &block)
  unless [:request, :response, :use, :insert, :insert_before, :insert_after, :swap, :delete].include?(operation)
    fail ArgumentError, "Invalid faraday middleware operation #{operation}. Must be" \
                        " :request, :response, :use, :insert, :insert_before, :insert_after, :swap or :delete."
  end
  @middlewares[operation] << [key, args, block]
end

def signature=(value)
  @api_key_store['PartnerSignature'] = value
end

def timestamp=(value)
  @api_key_store['PartnerTimestamp'] = value
end

def use(*middleware)
  set_faraday_middleware(:use, *middleware)
end