tehama_client_ex

defmodule TehamaClientApi do
  @moduledoc false

  use HTTPoison.Base

  require Logger

  @base_url Application.get_env(:tehama_client_ex, :api_base_url)

  def process_url(url) do
    @base_url <> url
  end

  def process_response_body(body) do
    body
    |> Poison.decode!()
    |> format_object()
  end

  def format_object(list) when is_list(list) do
    Enum.map(list, &format_object/1)
  end

  def format_object(obj) do
    obj
    # |> Map.take(@expected_fields)
    |> Enum.map(fn {k, v} -> {String.to_atom(k), v} end)
    |> Map.new()
  end

  @spec auth(any, any) :: {:error, any} | {:ok, %TehamaClient.Auth{token: String.t()}}
  def auth(username, password) do
    case post(
           "/auth/login",
           Poison.encode!(%{username: username, password: password}),
           headers()
         ) do
      {:ok, %{body: body, status_code: 200}} ->
        {:ok, %TehamaClient.Auth{token: body.token}}

      {:ok, %{body: error, status_code: code}} ->
        Logger.warn("Error getting auth: #{inspect(error)} (#{code})")
        {:error, error}

      other ->
        Logger.warn("other error: #{inspect(other)}")
        {:error, other}
    end
  end

  @spec site(String.t()) :: %TehamaClient.Site{access_code: String.t()}
  def site(access_code) do
    %TehamaClient.Site{
      access_code: access_code
    }
  end

  def site_list(%TehamaClient.Auth{token: token}) do
    case get("/tehama/site-list-server", headers(token)) |> handle_response() do
      {:ok, json} ->
        with data <- json.data do
          with sites <- data["sites"] do
            sites |> Enum.map(&TehamaClient.Site.new/1)
          end
        end

      {:error, error} ->
        error
    end
  end

  def report_data(%TehamaClient.Auth{token: token}, %TehamaClient.Site{access_code: access_code}) do
    case get("/tehama/sites/report-data/#{access_code}", headers(token)) |> handle_response() do
      {:ok, json} ->
        with data <- json.data do
          with devices <- data["devices"] do
            devices |> Enum.map(&TehamaClient.Device.new/1)
          end
        end

      {:error, error} ->
        error
    end
  end

  def report_data(
        %TehamaClient.Auth{token: token},
        %TehamaClient.Site{access_code: access_code},
        %Date{} = start_time,
        %Date{} = end_time
      ) do
    start_time_str = start_time |> Calendar.strftime("%Y-%m-%dT0000")
    end_time_str = end_time |> Calendar.strftime("%Y-%m-%dT2359")

    case get(
           "/tehama/sites/report-data/#{access_code}?start_time=#{start_time_str}&end_time=#{end_time_str}",
           headers(token)
         )
         |> handle_response() do
      {:ok, json} ->
        with data <- json.data do
          with devices <- data["devices"] do
            devices |> Enum.map(&TehamaClient.Device.new/1)
          end
        end

      {:error, error} ->
        error
    end
  end

  def handle_response(resp) do
    case resp do
      {:ok, %{body: json, status_code: 200}} ->
        {:ok, json}

      {:ok, %{body: error, status_code: 422}} ->
        {:error, error}

      {:ok, %{body: error, status_code: 403}} ->
        {:error, error}
    end
  end

  defp headers() do
    [
      {:"content-type", "application/json"}
    ]
  end

  defp headers(token) do
    %{
      "content-type": "application/json",
      "X-Authorization": token
    }
  end
end