pxshot

defmodule Pxshot.Response do
  @moduledoc """
  Response structs for Pxshot API.
  """

  defmodule RateLimit do
    @moduledoc """
    Rate limit information from response headers.
    """

    defstruct [:limit, :remaining, :reset, :retry_after]

    @type t :: %__MODULE__{
            limit: integer() | nil,
            remaining: integer() | nil,
            reset: integer() | nil,
            retry_after: integer() | nil
          }
  end

  defmodule StoredScreenshot do
    @moduledoc """
    Response when storing a screenshot (store: true).
    """

    defstruct [:url, :expires_at, :width, :height, :size_bytes, :rate_limit]

    @type t :: %__MODULE__{
            url: String.t(),
            expires_at: DateTime.t() | String.t(),
            width: integer(),
            height: integer(),
            size_bytes: integer(),
            rate_limit: RateLimit.t() | nil
          }

    @doc false
    def from_map(map, rate_limit) when is_map(map) do
      expires_at =
        case map["expires_at"] || map["expiresAt"] do
          nil -> nil
          dt when is_binary(dt) -> parse_datetime(dt)
          dt -> dt
        end

      %__MODULE__{
        url: map["url"],
        expires_at: expires_at,
        width: map["width"],
        height: map["height"],
        size_bytes: map["size_bytes"] || map["sizeBytes"],
        rate_limit: rate_limit
      }
    end

    defp parse_datetime(dt_string) do
      case DateTime.from_iso8601(dt_string) do
        {:ok, dt, _offset} -> dt
        {:error, _} -> dt_string
      end
    end
  end

  defmodule Usage do
    @moduledoc """
    Usage statistics response.
    """

    defstruct [:period, :screenshots_used, :screenshots_limit, :storage_used_bytes, :rate_limit]

    @type t :: %__MODULE__{
            period: String.t(),
            screenshots_used: integer(),
            screenshots_limit: integer(),
            storage_used_bytes: integer(),
            rate_limit: RateLimit.t() | nil
          }

    @doc false
    def from_map(map, rate_limit) when is_map(map) do
      %__MODULE__{
        period: map["period"],
        screenshots_used: map["screenshots_used"] || map["screenshotsUsed"],
        screenshots_limit: map["screenshots_limit"] || map["screenshotsLimit"],
        storage_used_bytes: map["storage_used_bytes"] || map["storageUsedBytes"],
        rate_limit: rate_limit
      }
    end

    @doc """
    Returns the percentage of screenshot quota used.
    """
    @spec usage_percent(t()) :: float()
    def usage_percent(%__MODULE__{screenshots_used: used, screenshots_limit: limit})
        when is_integer(limit) and limit > 0 do
      used / limit * 100
    end

    def usage_percent(_), do: 0.0
  end

  defmodule Health do
    @moduledoc """
    Health check response.
    """

    defstruct [:status, :version, :uptime]

    @type t :: %__MODULE__{
            status: String.t(),
            version: String.t() | nil,
            uptime: integer() | nil
          }

    @doc false
    def from_map(map) when is_map(map) do
      %__MODULE__{
        status: map["status"] || "ok",
        version: map["version"],
        uptime: map["uptime"]
      }
    end

    @doc """
    Returns true if the API is healthy.
    """
    @spec healthy?(t()) :: boolean()
    def healthy?(%__MODULE__{status: "ok"}), do: true
    def healthy?(%__MODULE__{}), do: false
  end
end