cape

defmodule Arpas.REST.Esri.Api do
  @moduledoc ~S'''
  Utilita per accedere ad AGOL(Arcgis online) tramite api rest
  '''

  alias Arpas.REST.Esri.Env

  @doc """
  Restituisce token per accedere ad AGOL
  :idro
  :alai
  """
  def token(:idro), do: token(Env.id_idro(), Env.secret_idro())

  def token(:alai), do: token(Env.id(), Env.secret())

  def token() do
    token(:idro)
  end

  def token(id, secret) do
    url = Env.token_url()
    expiration = "21600"

    headers = [
      {"Accept", "application/json"},
      {"Content-Type", "application/x-www-form-urlencoded"},
      # , no-store, must-revalidate"}
      {"Cache-Control", "no-cache"}
    ]

    payload =
      "client_id=#{id}&client_secret=#{secret}&grant_type=client_credentials&expiration=#{expiration}"

    case HTTPoison.post(url, payload, headers) do
      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
        {:ok, my_token} =
          body
          |> Poison.decode()

        adesso = DateTime.now!("Etc/UTC")
        finisce = my_token["expires_in"]
        IO.puts(finisce)
        scadenza = DateTime.add(adesso, finisce, :second)
        my_token = Map.put(my_token, "log_now", adesso)
        Map.put(my_token, "scade", scadenza)

      {:ok, %HTTPoison.Response{status_code: 404}} ->
        IO.puts("Not found :(")

      {:error, %HTTPoison.Error{reason: reason}} ->
        IO.inspect(reason)
    end
  end

  def get_access_token do
    token()
    |> Map.get("access_token")
  end

  def features(feauture_url) do
    feature(feauture_url, "")
  end

  def feature(feauture_url, numero) do
    access = get_access_token()
    url = feauture_url <> numero <> "/query?where=1=1&outfields=*"

    headers = [
      {"Accept", "application/json"},
      {"Content-Type", "application/x-www-form-urlencoded"},
      {"Cache-Control", "no-cache, no-store, must-revalidate"}
    ]

    IO.puts(url)
    payload = "token=#{access}&f=json"

    case HTTPoison.post(url, payload, headers) do
      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
        {:ok, idro} =
          body
          |> Poison.decode()

        idro

      {:ok, %HTTPoison.Response{status_code: 404}} ->
        IO.puts("Not found :(")
        {:error, codice: "404"}

      {:error, %HTTPoison.Error{reason: reason}} ->
        IO.inspect(reason)
        {:error, codice: reason}
    end
  end

  def service_features(url) do
    access = get_access_token()
    IO.puts(url)

    url =
      if url == "" do
        Env.services() <> "?token=#{access}&f=json"
      else
        url <> "?token=#{access}&f=json"
      end

    headers = [
      {"Accept", "application/json"},
      {"Content-Type", "application/x-www-form-urlencoded"},
      {"Cache-Control", "no-cache, no-store, must-revalidate"}
    ]

    case HTTPoison.get(url, headers) do
      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
        body
        |> Poison.decode()

      {:ok, %HTTPoison.Response{status_code: 404}} ->
        IO.puts("Not found :(")
        {:error, codice: "404"}

      {:error, %HTTPoison.Error{reason: reason}} ->
        IO.inspect(reason)
        {:error, codice: reason}

      value ->
        IO.puts(value)
    end
  end

  def layers(url) do
    case service_features(url) do
      {:ok, servizio} ->
        servizio

      {:error, reason} ->
        reason
    end
  end
end