defmodule Juspay do
  @moduledoc false

  import Juspay.Exception

  defp send_request(method,url,parameters,headers,auth) do
    case method do
      "GET" -> HTTPoison.get url<>"?"<>URI.encode_query(parameters),headers,auth
      "POST" -> HTTPoison.post url,{:form,parameters},headers,auth
    end
  end

  def request(method,url,parameters) do
    {:ok,environment} = Application.fetch_env(:juspay_api_library,:environment)
    {:ok,version} = Application.fetch_env(:juspay_api_library,:version)
    {:ok,api_key} = Application.fetch_env(:juspay_api_library,:api_key)
    if api_key == nil do
      raise authenticationError("ERROR: API key missing. Please specify api_key in config file .")
    end
    auth = [hackney: [basic_auth: {api_key, ""}]]
    url = case environment  do
      "production" -> "https://api.juspay.in"<>url
      "staging" -> "https://sandbox.juspay.in"<>url
    end
    try do
      case send_request(method,url,parameters,%{},auth)  do
        {:ok,response} -> cond  do
                            response.status_code in [400,404] -> raise Juspay.Exception.invalidRequestError.new("Invalid Request", response.status_code, response.body)
                            response.status_code == 401 -> raise Juspay.Exception.authenticationError("Invalid Request", response.status_code, response.body)
                            response.status_code in 200..299 -> Poison.decode!(response.body)
                            true -> raise apiError("Internal Server Error.... please contact support@juspay.in", response.status_code, response.body)
                          end
        {:error,response} -> raise invalidRequestError("Server returned an error response : Reason--> " <> response.reason)
      end
    rescue
      IOError -> raise apiConnectionError("Connection error")
      SocketError -> raise apiConnectionError("SocketError --->  Failed to Connect")
    end
  end

  def check_params(parameters) do
    parameters = parameters
                  |> Enum.into(%{})
                  |> Enum.reduce(%{},fn({key, val}, acc) -> Map.put(acc, string_to_atom(key),float_to_string(val)) end)
                  |> Map.to_list()
    if(length(parameters) == 0) do
      raise invalidArgumentError
    end
   parameters = Enum.into(parameters,[])
  end

  defp float_to_string(val) do
    if is_float(val) do
      to_string(val)
    else
      val
    end
  end

  defp string_to_atom(key) do
    if is_atom(key) do
      key
    else
      String.to_atom(key)
    end
  end

end