regc

defmodule Regc.Oci.Descriptor do
  @moduledoc """
  A validated OCI content descriptor.
  """

  alias Regc.Oci.Descriptor.{Decoder, Preference}
  alias Regc.Oci.Platform

  @enforce_keys [:media_type, :digest, :size]
  defstruct [
    :media_type,
    :digest,
    :size,
    :urls,
    :data,
    :platform,
    :artifact_type,
    annotations: %{}
  ]

  @type t :: %__MODULE__{
          media_type: String.t(),
          digest: String.t(),
          size: non_neg_integer(),
          urls: [String.t()] | nil,
          data: String.t() | nil,
          platform: Platform.t() | nil,
          artifact_type: String.t() | nil,
          annotations: map()
        }

  @spec from_map(map(), keyword()) :: {:ok, t()} | {:error, atom()}
  def from_map(document, opts \\ [])

  def from_map(document, opts) when is_map(document) and is_list(opts) do
    case Decoder.decode(document, opts) do
      {:ok, fields} -> {:ok, struct!(__MODULE__, fields)}
      {:error, reason} -> {:error, reason}
    end
  end

  def from_map(_document, _opts), do: {:error, :invalid_descriptor}

  @doc false
  @spec annotations_valid?(term()) :: boolean()
  defdelegate annotations_valid?(annotations), to: Decoder

  @doc false
  @spec media_type_valid?(term()) :: boolean()
  defdelegate media_type_valid?(value), to: Decoder

  @doc false
  @spec prefer_inline(t(), t()) :: t()
  def prefer_inline(%__MODULE__{} = existing, %__MODULE__{} = candidate),
    do: Preference.prefer_inline(existing, candidate)
end