regc

defmodule Regc.Oci.Platform.Normalizer do
  @moduledoc false

  @spec build(String.t(), String.t(), String.t() | nil, keyword()) :: map()
  def build(os, architecture, variant \\ nil, opts \\ []) do
    {architecture, inferred_variant} = normalize_architecture_and_variant(architecture)

    %{
      os: os,
      architecture: architecture,
      variant: variant || inferred_variant,
      os_version: Keyword.get(opts, :os_version),
      os_features: opts |> Keyword.get(:os_features, []) |> normalize_features(),
      features: opts |> Keyword.get(:features, []) |> normalize_features()
    }
  end

  @spec document(map()) :: map()
  def document(platform) do
    %{
      "os" => value(platform, :os, "os"),
      "architecture" => value(platform, :architecture, "architecture"),
      "variant" => value(platform, :variant, "variant"),
      "os.version" => value(platform, :os_version, "os.version"),
      "os.features" => value(platform, :os_features, "os.features"),
      "features" => value(platform, :features, "features")
    }
  end

  defp normalize_architecture_and_variant(architecture) do
    architecture = String.downcase(architecture)

    case Regex.run(~r/\Aarmv([5-8])l?\z/, architecture) do
      [_, version] -> {"arm", "v" <> version}
      nil -> {normalize_architecture(architecture), nil}
    end
  end

  defp normalize_architecture("x86_64"), do: "amd64"

  defp normalize_architecture(architecture)
       when architecture in ["i386", "i486", "i586", "i686", "x86"],
       do: "386"

  defp normalize_architecture("aarch64"), do: "arm64"
  defp normalize_architecture("powerpc64"), do: "ppc64"

  defp normalize_architecture(architecture) when architecture in ["powerpc64le", "ppc64el"],
    do: "ppc64le"

  defp normalize_architecture(architecture), do: architecture

  defp value(map, atom_key, string_key) do
    Map.get(map, atom_key, Map.get(map, string_key))
  end

  defp normalize_features(nil), do: []
  defp normalize_features(features), do: features |> Enum.uniq() |> Enum.sort()
end