regc

defmodule Regc.Oci.Client.Context do
  @moduledoc false

  alias Regc.Oci.{Error, Options, Platform, Reference}

  @enforce_keys [:source_ref, :options]
  defstruct [:source_ref, :options, :platform]

  @type t :: %__MODULE__{
          source_ref: Reference.t(),
          options: Options.t(),
          platform: Platform.t() | nil
        }

  @spec new(term(), term()) :: {:ok, t()} | {:error, Error.t()}
  def new(reference, opts) do
    with {:ok, options} <- normalize_options(opts, reference),
         {:ok, source_ref} <- Reference.parse(reference, options),
         {:ok, platform} <- requested_platform(options) do
      {:ok,
       %__MODULE__{
         source_ref: source_ref,
         platform: platform,
         options: options
       }}
    end
  end

  defp requested_platform(%Options{platform: nil}), do: {:ok, nil}
  defp requested_platform(%Options{platform: platform}), do: Platform.parse(platform)

  defp normalize_options(opts, reference) do
    case Options.parse(opts) do
      {:ok, options} ->
        {:ok, options}

      {:error, {:invalid_option, option} = cause} ->
        option_error(option, cause, reference)
    end
  end

  defp option_error(option, cause, reference) do
    case Options.error_context(option) do
      :reference ->
        Error.result(
          :reference,
          :invalid_reference,
          Options.error_message(option),
          reference: reference
        )

      :resolution ->
        Error.result(
          :manifest_resolve,
          :invalid_option,
          Options.error_message(option),
          reference: reference
        )

      :fetch ->
        Error.result(
          :manifest_fetch,
          :invalid_option,
          Options.error_message(option),
          reference: reference,
          cause: cause
        )
    end
  end
end