defmodule FennecPrecompile.SystemInfo do
  @available_nif_versions ~w(2.14 2.15 2.16)

  @doc """
  Returns the target triple for download or compile and load.

  This function is translating and adding more info to the system
  architecture returned by Elixir/Erlang to one used by `convention`.

  ## Examples

      iex> FennecPrecompile.SystemInfo.target(:rust)
      {:ok, "aarch64-apple-darwin"}
      iex> FennecPrecompile.SystemInfo.target(:zig)
      {:ok, "aarch64-macos"}

  """
  def target(convention, opts \\ []) do
    config = opts[:target_config] || target_config()
    normalize_target_system = opts[:normalize_target_system] || &FennecPrecompile.SystemInfo.normalize_target_system(&1, &2)
    available_targets = opts[:available_targets] || default_targets(convention)
    available_nif_versions = opts[:available_nif_versions] || @available_nif_versions

    arch_os =
      case config.os_type do
        {:unix, _} ->
          config.target_system
          |> normalize_target_system.(convention)
          |> system_architecture_to_string()

        {:win32, _} ->
          existing_target =
            config.target_system
            |> system_architecture_to_string()

          # For when someone is setting "TARGET_*" vars on Windows
          if existing_target in available_targets do
            existing_target
          else
            # 32 or 64 bits
            arch =
              case convention do
                :rust ->
                  case config.word_size do
                    4 -> "i686"
                    8 -> "x86_64"
                    _ -> "unknown"
                  end
                :zig ->
                  case config.word_size do
                    4 -> "x86"
                    8 -> "x64"
                    _ -> "unknown"
                  end
              end

            config.target_system
            |> Map.put_new(:arch, arch)
            |> Map.put_new(:os, "windows")
            |> Map.put_new(:abi, "msvc")
            |> system_architecture_to_string()
          end
      end

    cond do
      arch_os not in available_targets ->
        {:error,
         "precompiled NIF is not available for this target: #{inspect(arch_os)}.\n" <>
           "The available targets are:\n - #{Enum.join(available_targets, "\n - ")}"}

      config.nif_version not in available_nif_versions ->
        {:error,
         "precompiled NIF is not available for this NIF version: #{inspect(config.nif_version)}.\n" <>
           "The available NIF versions are:\n - #{Enum.join(available_nif_versions, "\n - ")}"}

      true ->
        {:ok, arch_os}
    end
  end

  @doc """
  Get a config map for current node.

  ## Parameters

    - `allow_env_var_override`.

      Defaults to `true`.

      Indicating whether allows environment variables to override
      values for `:arch`, `:vendor`, `:os` and `:abi`.

      The following environment variables will be tested and replace
      correspondingly if not empty.

      | Environment Variable | Maps to Key |
      |----------------------|-------------|
      | `TARGET_ARCH`        | `:arch`     |
      | `TARGET_VENDOR`      | `:vendor`   |
      | `TARGET_OS  `        | `:os`       |
      | `TARGET_ABI`         | `:abi`      |

  ## Return

  The map includes 4 keys:
    - `:os_type`. Value returned from `:os.type()`.
    - `:target_system`.
    - `:word_size`. Value returned from `:erlang.system_info(:wordsize)`.
    - `:nif_version`. Exact or compatible nif version for current node.

  ## Example

      iex> FennecPrecompile.SystemInfo.target_config(false)
      %{
        nif_version: "2.16",
        os_type: {:unix, :darwin},
        target_system: %{abi: "darwin21.4.0", arch: "aarch64", os: "apple"},
        word_size: 8
      }

      iex> System.put_env("TARGET_ARCH", "x86_64")
      :ok
      iex> FennecPrecompile.SystemInfo.target_config(true)
      %{
        nif_version: "2.16",
        os_type: {:unix, :darwin},
        target_system: %{abi: "darwin21.4.0", arch: "x86_64", os: "apple"},
        word_size: 8
      }

  """
  @spec target_config(boolean()) :: %{
    os_type: {:unix, atom} | {:win32, atom},
    target_system: %{},
    word_size: 4 | 8,
    nif_version: String.t()
  }
  def target_config(allow_env_var_override \\ true) do
    current_nif_version = current_nif_version()
    override =
      if allow_env_var_override do
        &(maybe_override_with_env_vars(&1))
      else
        &(&1)
      end

    nif_version =
      case find_compatible_nif_version(current_nif_version, @available_nif_versions) do
        {:ok, vsn} ->
          vsn

        :error ->
          # In case of error, use the current so we can tell the user.
          current_nif_version
      end

    current_system_arch = system_architecture()

    %{
      os_type: :os.type(),
      target_system: override.(current_system_arch),
      word_size: :erlang.system_info(:wordsize),
      nif_version: nif_version
    }
  end

  @doc """
  Normalize the given target system map accordingly

  `convention` can be `:rust` or `:zig`

  """
  def normalize_target_system(target_system, convention)
  def normalize_target_system(target_system, :rust) do
    cond do
      target_system.abi =~ "darwin" ->
        arch = with "arm" <- target_system.arch, do: "aarch64"

        %{target_system | arch: arch, os: "apple", abi: "darwin"}

      target_system.os =~ "linux" ->
        arch = with "amd64" <- target_system.arch, do: "x86_64"

        %{target_system | arch: arch}

      true ->
        target_system
    end
  end

  def normalize_target_system(target_system, :zig) do
    cond do
      target_system.abi =~ "darwin" ->
        arch = with "arm" <- target_system.arch, do: "aarch64"

        %{target_system | arch: arch, os: "macos", abi: nil}

      target_system.os =~ "linux" ->
        arch = with "amd64" <- target_system.arch, do: "x86_64"

        %{target_system | arch: arch}

      target_system.os =~ "windows" ->
        arch = case target_system.arch do
          "amd64" -> "x64"
          "x86_64" -> "x64"
          _ -> target_system.arch
        end

        %{target_system | arch: arch}

      true ->
        target_system
    end
  end

  @doc """
  Convert system architecture map to its string form.

  ## Example

    iex> system_architecture = FennecPrecompile.SystemInfo.system_architecture()
    %{abi: "darwin21.4.0", arch: "aarch64", os: "apple"}
    iex> FennecPrecompile.SystemInfo.system_architecture_to_string(system_architecture)
    "aarch64-apple-darwin21.4.0"

  """
  def system_architecture_to_string(system_architecture) do
    values =
      for key <- [:arch, :vendor, :os, :abi],
          value = system_architecture[key],
          do: value

    Enum.join(values, "-")
  end

  @doc """
  Get nif version for current node.

  ## Example

    iex> FennecPrecompile.SystemInfo.current_nif_version()
    "2.16"

  """
  @spec current_nif_version() :: String.t()
  def current_nif_version do
    :erlang.system_info(:nif_version) |> List.to_string()
  end

  @doc """
  In case one is using this lib in a newer OTP version, we try to
  find the latest compatible NIF version.
  """
  @spec find_compatible_nif_version(String.t(), [String.t()]) :: {:ok, String.t()} | :error
  def find_compatible_nif_version(vsn, available \\ @available_nif_versions) do
    if vsn in available do
      {:ok, vsn}
    else
      [major, minor | _] = parse_version(vsn)

      available
      |> Enum.map(&parse_version/1)
      |> Enum.filter(fn
        [^major, available_minor | _] when available_minor <= minor -> true
        [_ | _] -> false
      end)
      |> case do
        [] -> :error
        match -> {:ok, match |> Enum.max() |> Enum.join(".")}
      end
    end
  end

  defp parse_version(vsn) do
    vsn |> String.split(".") |> Enum.map(&String.to_integer/1)
  end

  @doc """
  Parse `:erlang.system_info(:system_architecture)` into a map

  The result map may include `:arch`, `:vendor`, `:os` and `:abi` keys
  if `:erlang.system_info/1` returns "ARCH-VENDOR-OS-ABI".

  Or the result will include `:arch`, `:os` and `:abi` keys
  if `:erlang.system_info/1` returns "ARCH-OS-ABI".

  For other cases, an empty map is returned.

  ## Examples

      iex> FennecPrecompile.SystemInfo.system_architecture()
      %{abi: "darwin21.4.0", arch: "aarch64", os: "apple"}

  """
  @spec system_architecture() :: %{atom => String.t()} | %{}
  def system_architecture do
    base =
      :erlang.system_info(:system_architecture)
      |> List.to_string()
      |> String.split("-")

    triple_keys =
      case length(base) do
        4 ->
          [:arch, :vendor, :os, :abi]

        3 ->
          [:arch, :os, :abi]

        _ ->
          # It's too complicated to find out, and we won't support this for now.
          []
      end

    triple_keys
    |> Enum.zip(base)
    |> Enum.into(%{})
  end

  @doc """
  Override system architeture map with environment variables to support systems like Nerves.

  See: https://hexdocs.pm/nerves/compiling-non-beam-code.html#target-cpu-arch-os-and-abi
  """
  def maybe_override_with_env_vars(original_sys_arch, get_env \\ &System.get_env/1) do
    envs_with_keys = [
      arch: "TARGET_ARCH",
      vendor: "TARGET_VENDOR",
      os: "TARGET_OS",
      abi: "TARGET_ABI"
    ]

    Enum.reduce(envs_with_keys, original_sys_arch, fn {key, env_key}, acc ->
      if env_value = get_env.(env_key) do
        Map.put(acc, key, env_value)
      else
        acc
      end
    end)
  end

  @doc """
  Return a list of default targets.
  """
  def default_targets(convention)
  def default_targets(:rust) do
    ~w(
      aarch64-apple-darwin
      x86_64-apple-darwin
      x86_64-unknown-linux-gnu
      x86_64-unknown-linux-musl
      arm-unknown-linux-gnueabihf
      aarch64-unknown-linux-gnu
      x86_64-pc-windows-msvc
      x86_64-pc-windows-gnu
    )
  end

  def default_targets(:zig) do
    common_targest =
      ~w(
        x86_64-linux-gnu
        x86_64-linux-musl
        x86_64-windows-gnu
        aarch64-linux-gnu
        aarch64-linux-musl
        riscv64-linux-musl
      )
    with {:unix, :darwin}  <- :os.type() do
      ~w(
        x86_64-macos
        aarch64-macos
      )
    else
      _ -> []
    end
    ++ common_targest
  end

  @doc """
  Returns user cache directory.
  """
  def cache_dir(sub_dir \\ "") do
    cache_opts = if System.get_env("MIX_XDG"), do: %{os: :linux}, else: %{}
    cache_dir = :filename.basedir(:user_cache, sub_dir, cache_opts)
    File.mkdir_p!(cache_dir)
    cache_dir
  end
end