codex_sdk

defmodule Codex.Thread.Options do
  @moduledoc """
  Per-thread configuration options.
  """

  alias Codex.FileSearch

  @enforce_keys []
  defstruct metadata: %{},
            labels: %{},
            auto_run: false,
            transport: :exec,
            approval_policy: nil,
            approval_hook: nil,
            approval_timeout_ms: 30_000,
            sandbox: :default,
            sandbox_policy: nil,
            working_directory: nil,
            additional_directories: [],
            skip_git_repo_check: false,
            network_access_enabled: nil,
            web_search_enabled: false,
            apply_patch_freeform_enabled: nil,
            view_image_tool_enabled: nil,
            unified_exec_enabled: nil,
            skills_enabled: nil,
            ask_for_approval: nil,
            attachments: [],
            file_search: nil,
            profile: nil,
            oss: false,
            local_provider: nil,
            full_auto: false,
            dangerously_bypass_approvals_and_sandbox: false,
            output_last_message: nil,
            color: nil,
            config_overrides: [],
            history_persistence: nil,
            history_max_bytes: nil,
            model: nil,
            model_provider: nil,
            model_reasoning_summary: nil,
            model_verbosity: nil,
            model_context_window: nil,
            model_supports_reasoning_summaries: nil,
            request_max_retries: nil,
            stream_max_retries: nil,
            stream_idle_timeout_ms: nil,
            config: nil,
            base_instructions: nil,
            developer_instructions: nil,
            shell_environment_policy: nil,
            retry: nil,
            retry_opts: nil,
            rate_limit: nil,
            rate_limit_opts: nil,
            experimental_raw_events: false

  @type transport :: :exec | {:app_server, pid()}

  @type network_access :: :enabled | :restricted

  @type sandbox ::
          :default
          | :strict
          | :permissive
          | :read_only
          | :workspace_write
          | :danger_full_access
          | :external_sandbox
          | {:external_sandbox, network_access()}
          | String.t()

  @type sandbox_policy_type ::
          :danger_full_access
          | :read_only
          | :workspace_write
          | :external_sandbox
          | String.t()

  @type sandbox_policy :: %{
          optional(:type) => sandbox_policy_type(),
          optional(:writable_roots) => [String.t()],
          optional(:network_access) => boolean() | :enabled | :restricted | String.t(),
          optional(:exclude_tmpdir_env_var) => boolean(),
          optional(:exclude_slash_tmp) => boolean()
        }

  @type color :: :always | :never | :auto | String.t()

  @type reasoning_summary :: :auto | :concise | :detailed | :none | String.t()
  @type model_verbosity :: :low | :medium | :high | String.t()

  @type retry_opts :: keyword()
  @type rate_limit_opts :: keyword()
  @type history_persistence :: String.t()

  @type config_override ::
          String.t()
          | {String.t() | atom(), term()}

  @type t :: %__MODULE__{
          metadata: map(),
          labels: map(),
          auto_run: boolean(),
          transport: transport(),
          approval_policy: module() | nil,
          approval_hook: module() | nil,
          approval_timeout_ms: pos_integer(),
          sandbox: sandbox(),
          sandbox_policy: sandbox_policy() | sandbox_policy_type() | nil,
          working_directory: String.t() | nil,
          additional_directories: [String.t()],
          skip_git_repo_check: boolean(),
          network_access_enabled: boolean() | nil,
          web_search_enabled: boolean(),
          apply_patch_freeform_enabled: boolean() | nil,
          view_image_tool_enabled: boolean() | nil,
          unified_exec_enabled: boolean() | nil,
          skills_enabled: boolean() | nil,
          ask_for_approval: :untrusted | :on_failure | :on_request | :never | String.t() | nil,
          attachments: [map()] | [],
          file_search: FileSearch.t() | nil,
          profile: String.t() | nil,
          oss: boolean(),
          local_provider: String.t() | nil,
          full_auto: boolean(),
          dangerously_bypass_approvals_and_sandbox: boolean(),
          output_last_message: String.t() | nil,
          color: color() | nil,
          config_overrides: [config_override()],
          history_persistence: history_persistence() | nil,
          history_max_bytes: non_neg_integer() | nil,
          model: String.t() | nil,
          model_provider: String.t() | nil,
          model_reasoning_summary: reasoning_summary() | nil,
          model_verbosity: model_verbosity() | nil,
          model_context_window: pos_integer() | nil,
          model_supports_reasoning_summaries: boolean() | nil,
          request_max_retries: pos_integer() | nil,
          stream_max_retries: pos_integer() | nil,
          stream_idle_timeout_ms: pos_integer() | nil,
          config: map() | nil,
          base_instructions: String.t() | nil,
          developer_instructions: String.t() | nil,
          shell_environment_policy: map() | nil,
          retry: boolean() | nil,
          retry_opts: retry_opts() | nil,
          rate_limit: boolean() | nil,
          rate_limit_opts: rate_limit_opts() | nil,
          experimental_raw_events: boolean()
        }

  @doc """
  Builds a thread options struct from various inputs.
  """
  @spec new(map() | keyword() | t()) :: {:ok, t()} | {:error, term()}
  def new(%__MODULE__{} = opts), do: {:ok, opts}
  def new(attrs) when is_list(attrs), do: attrs |> Map.new() |> new()

  def new(attrs) when is_map(attrs) do
    metadata = Map.get(attrs, :metadata, Map.get(attrs, "metadata", %{}))
    labels = Map.get(attrs, :labels, Map.get(attrs, "labels", %{}))
    auto_run = Map.get(attrs, :auto_run, Map.get(attrs, "auto_run", false))
    transport = Map.get(attrs, :transport, Map.get(attrs, "transport"))
    approval_policy = Map.get(attrs, :approval_policy, Map.get(attrs, "approval_policy"))
    approval_hook = Map.get(attrs, :approval_hook, Map.get(attrs, "approval_hook"))

    approval_timeout_ms =
      Map.get(attrs, :approval_timeout_ms, Map.get(attrs, "approval_timeout_ms", 30_000))

    sandbox = Map.get(attrs, :sandbox, Map.get(attrs, "sandbox", :default))
    sandbox_policy = Map.get(attrs, :sandbox_policy, Map.get(attrs, "sandbox_policy"))

    working_directory =
      Map.get(attrs, :working_directory, Map.get(attrs, "working_directory", Map.get(attrs, :cd)))

    additional_directories =
      Map.get(attrs, :additional_directories, Map.get(attrs, "additional_directories", []))

    skip_git_repo_check =
      Map.get(attrs, :skip_git_repo_check, Map.get(attrs, "skip_git_repo_check", false))

    network_access_enabled =
      Map.get(attrs, :network_access_enabled, Map.get(attrs, "network_access_enabled"))

    web_search_enabled =
      Map.get(attrs, :web_search_enabled, Map.get(attrs, "web_search_enabled", false))

    apply_patch_freeform_enabled =
      Map.get(
        attrs,
        :apply_patch_freeform_enabled,
        Map.get(attrs, "apply_patch_freeform_enabled")
      )

    view_image_tool_enabled =
      Map.get(attrs, :view_image_tool_enabled, Map.get(attrs, "view_image_tool_enabled"))

    unified_exec_enabled =
      Map.get(attrs, :unified_exec_enabled, Map.get(attrs, "unified_exec_enabled"))

    skills_enabled = Map.get(attrs, :skills_enabled, Map.get(attrs, "skills_enabled"))

    ask_for_approval = Map.get(attrs, :ask_for_approval, Map.get(attrs, "ask_for_approval"))
    attachments = Map.get(attrs, :attachments, Map.get(attrs, "attachments", []))
    file_search = Map.get(attrs, :file_search, Map.get(attrs, "file_search"))

    profile =
      Map.get(attrs, :profile, Map.get(attrs, "profile", Map.get(attrs, :config_profile)))
      |> case do
        nil -> Map.get(attrs, "config_profile")
        value -> value
      end

    oss = Map.get(attrs, :oss, Map.get(attrs, "oss", false))

    local_provider =
      Map.get(
        attrs,
        :local_provider,
        Map.get(
          attrs,
          "local_provider",
          Map.get(attrs, :oss_provider, Map.get(attrs, "oss_provider"))
        )
      )

    full_auto = Map.get(attrs, :full_auto, Map.get(attrs, "full_auto", false))

    dangerously_bypass_approvals_and_sandbox =
      Map.get(
        attrs,
        :dangerously_bypass_approvals_and_sandbox,
        Map.get(attrs, "dangerously_bypass_approvals_and_sandbox", false)
      )

    output_last_message =
      Map.get(attrs, :output_last_message, Map.get(attrs, "output_last_message"))

    color = Map.get(attrs, :color, Map.get(attrs, "color"))

    config_overrides =
      Map.get(
        attrs,
        :config_overrides,
        Map.get(attrs, "config_overrides", Map.get(attrs, :config_override, []))
      )

    history = Map.get(attrs, :history, Map.get(attrs, "history"))

    history_persistence =
      Map.get(attrs, :history_persistence, Map.get(attrs, "history_persistence"))

    history_max_bytes =
      Map.get(attrs, :history_max_bytes, Map.get(attrs, "history_max_bytes"))

    {history_persistence, history_max_bytes} =
      case history do
        %{} ->
          {
            history_persistence ||
              Map.get(history, :persistence, Map.get(history, "persistence")),
            history_max_bytes ||
              Map.get(
                history,
                :max_bytes,
                Map.get(history, "max_bytes", Map.get(history, "maxBytes"))
              )
          }

        _ ->
          {history_persistence, history_max_bytes}
      end

    model = Map.get(attrs, :model, Map.get(attrs, "model"))

    model_provider =
      Map.get(attrs, :model_provider, Map.get(attrs, "model_provider", Map.get(attrs, :provider)))

    model_reasoning_summary =
      Map.get(attrs, :model_reasoning_summary, Map.get(attrs, "model_reasoning_summary"))

    model_verbosity = Map.get(attrs, :model_verbosity, Map.get(attrs, "model_verbosity"))

    model_context_window =
      Map.get(attrs, :model_context_window, Map.get(attrs, "model_context_window"))

    model_supports_reasoning_summaries =
      Map.get(
        attrs,
        :model_supports_reasoning_summaries,
        Map.get(attrs, "model_supports_reasoning_summaries")
      )

    request_max_retries =
      Map.get(attrs, :request_max_retries, Map.get(attrs, "request_max_retries"))

    stream_max_retries =
      Map.get(attrs, :stream_max_retries, Map.get(attrs, "stream_max_retries"))

    stream_idle_timeout_ms =
      Map.get(attrs, :stream_idle_timeout_ms, Map.get(attrs, "stream_idle_timeout_ms"))

    config = Map.get(attrs, :config, Map.get(attrs, "config"))

    base_instructions =
      Map.get(attrs, :base_instructions, Map.get(attrs, "base_instructions"))

    developer_instructions =
      Map.get(attrs, :developer_instructions, Map.get(attrs, "developer_instructions"))

    shell_environment_policy =
      Map.get(attrs, :shell_environment_policy, Map.get(attrs, "shell_environment_policy"))

    retry = Map.get(attrs, :retry, Map.get(attrs, "retry"))
    retry_opts = Map.get(attrs, :retry_opts, Map.get(attrs, "retry_opts"))
    rate_limit = Map.get(attrs, :rate_limit, Map.get(attrs, "rate_limit"))
    rate_limit_opts = Map.get(attrs, :rate_limit_opts, Map.get(attrs, "rate_limit_opts"))

    experimental_raw_events =
      Map.get(attrs, :experimental_raw_events, Map.get(attrs, "experimental_raw_events", false))

    with {:ok, metadata} <- ensure_map(metadata, :metadata),
         {:ok, labels} <- ensure_map(labels, :labels),
         {:ok, attachments} <- ensure_list(attachments, :attachments),
         {:ok, file_search} <- FileSearch.new(file_search),
         {:ok, transport} <- normalize_transport(transport),
         {:ok, sandbox} <- normalize_sandbox(sandbox),
         {:ok, sandbox_policy} <- normalize_sandbox_policy(sandbox_policy),
         :ok <- validate_boolean(auto_run, :auto_run),
         :ok <- validate_optional_string(working_directory, :working_directory),
         {:ok, additional_directories} <-
           normalize_string_list(additional_directories, :additional_directories),
         :ok <- validate_boolean(skip_git_repo_check, :skip_git_repo_check),
         {:ok, network_access_enabled} <-
           validate_optional_boolean(network_access_enabled, :network_access_enabled),
         :ok <- validate_boolean(web_search_enabled, :web_search_enabled),
         {:ok, apply_patch_freeform_enabled} <-
           validate_optional_boolean(apply_patch_freeform_enabled, :apply_patch_freeform_enabled),
         {:ok, view_image_tool_enabled} <-
           validate_optional_boolean(view_image_tool_enabled, :view_image_tool_enabled),
         {:ok, unified_exec_enabled} <-
           validate_optional_boolean(unified_exec_enabled, :unified_exec_enabled),
         {:ok, skills_enabled} <- validate_optional_boolean(skills_enabled, :skills_enabled),
         {:ok, ask_for_approval} <- normalize_ask_for_approval(ask_for_approval),
         :ok <- validate_optional_string(profile, :profile),
         :ok <- validate_boolean(oss, :oss),
         :ok <- validate_optional_string(local_provider, :local_provider),
         :ok <- validate_boolean(full_auto, :full_auto),
         :ok <-
           validate_boolean(
             dangerously_bypass_approvals_and_sandbox,
             :dangerously_bypass_approvals_and_sandbox
           ),
         :ok <- validate_optional_string(output_last_message, :output_last_message),
         {:ok, color} <- normalize_color(color),
         {:ok, config_overrides} <- normalize_config_overrides(config_overrides),
         {:ok, history_persistence} <- normalize_history_persistence(history_persistence),
         :ok <- validate_optional_non_negative_integer(history_max_bytes, :history_max_bytes),
         :ok <- validate_auto_flags(full_auto, dangerously_bypass_approvals_and_sandbox),
         :ok <- validate_optional_string(model, :model),
         :ok <- validate_optional_string(model_provider, :model_provider),
         {:ok, model_reasoning_summary} <- normalize_reasoning_summary(model_reasoning_summary),
         {:ok, model_verbosity} <- normalize_model_verbosity(model_verbosity),
         :ok <- validate_optional_positive_integer(model_context_window, :model_context_window),
         {:ok, model_supports_reasoning_summaries} <-
           validate_optional_boolean(
             model_supports_reasoning_summaries,
             :model_supports_reasoning_summaries
           ),
         :ok <- validate_optional_positive_integer(request_max_retries, :request_max_retries),
         :ok <- validate_optional_positive_integer(stream_max_retries, :stream_max_retries),
         :ok <-
           validate_optional_positive_integer(stream_idle_timeout_ms, :stream_idle_timeout_ms),
         {:ok, config} <- ensure_optional_map(config, :config),
         :ok <- validate_optional_string(base_instructions, :base_instructions),
         :ok <- validate_optional_string(developer_instructions, :developer_instructions),
         {:ok, shell_environment_policy} <-
           normalize_shell_environment_policy(shell_environment_policy),
         {:ok, retry} <- validate_optional_boolean(retry, :retry),
         {:ok, retry_opts} <- normalize_optional_keyword_list(retry_opts, :retry_opts),
         {:ok, rate_limit} <- validate_optional_boolean(rate_limit, :rate_limit),
         {:ok, rate_limit_opts} <-
           normalize_optional_keyword_list(rate_limit_opts, :rate_limit_opts),
         :ok <- validate_boolean(experimental_raw_events, :experimental_raw_events),
         :ok <- validate_timeout(approval_timeout_ms) do
      {:ok,
       %__MODULE__{
         metadata: metadata,
         labels: labels,
         auto_run: auto_run,
         transport: transport,
         approval_policy: approval_policy,
         approval_hook: approval_hook,
         approval_timeout_ms: approval_timeout_ms,
         sandbox: sandbox,
         sandbox_policy: sandbox_policy,
         working_directory: working_directory,
         additional_directories: additional_directories,
         skip_git_repo_check: skip_git_repo_check,
         network_access_enabled: network_access_enabled,
         web_search_enabled: web_search_enabled,
         apply_patch_freeform_enabled: apply_patch_freeform_enabled,
         view_image_tool_enabled: view_image_tool_enabled,
         unified_exec_enabled: unified_exec_enabled,
         skills_enabled: skills_enabled,
         ask_for_approval: ask_for_approval,
         attachments: attachments,
         file_search: file_search,
         profile: profile,
         oss: oss,
         local_provider: local_provider,
         full_auto: full_auto,
         dangerously_bypass_approvals_and_sandbox: dangerously_bypass_approvals_and_sandbox,
         output_last_message: output_last_message,
         color: color,
         config_overrides: config_overrides,
         history_persistence: history_persistence,
         history_max_bytes: history_max_bytes,
         model: model,
         model_provider: model_provider,
         model_reasoning_summary: model_reasoning_summary,
         model_verbosity: model_verbosity,
         model_context_window: model_context_window,
         model_supports_reasoning_summaries: model_supports_reasoning_summaries,
         request_max_retries: request_max_retries,
         stream_max_retries: stream_max_retries,
         stream_idle_timeout_ms: stream_idle_timeout_ms,
         config: config,
         base_instructions: base_instructions,
         developer_instructions: developer_instructions,
         shell_environment_policy: shell_environment_policy,
         retry: retry,
         retry_opts: retry_opts,
         rate_limit: rate_limit,
         rate_limit_opts: rate_limit_opts,
         experimental_raw_events: experimental_raw_events
       }}
    else
      {:error, _} = error -> error
    end
  end

  defp ensure_map(value, _field) when is_map(value), do: {:ok, value}
  defp ensure_map(nil, _field), do: {:ok, %{}}
  defp ensure_map(value, field), do: {:error, {:invalid_map, field, value}}

  defp ensure_list(value, _field) when is_list(value), do: {:ok, value}
  defp ensure_list(nil, _field), do: {:ok, []}
  defp ensure_list(value, field), do: {:error, {:invalid_list, field, value}}

  defp ensure_optional_map(nil, _field), do: {:ok, nil}
  defp ensure_optional_map(value, _field) when is_map(value), do: {:ok, value}
  defp ensure_optional_map(value, field), do: {:error, {:invalid_map, field, value}}

  defp validate_optional_string(nil, _field), do: :ok
  defp validate_optional_string(value, _field) when is_binary(value), do: :ok
  defp validate_optional_string(value, field), do: {:error, {:"invalid_#{field}", value}}

  defp validate_optional_boolean(nil, _field), do: {:ok, nil}
  defp validate_optional_boolean(value, _field) when is_boolean(value), do: {:ok, value}
  defp validate_optional_boolean(value, field), do: {:error, {:"invalid_#{field}", value}}

  defp validate_optional_positive_integer(nil, _field), do: :ok

  defp validate_optional_positive_integer(value, _field) when is_integer(value) and value > 0,
    do: :ok

  defp validate_optional_positive_integer(value, field),
    do: {:error, {:"invalid_#{field}", value}}

  defp validate_optional_non_negative_integer(nil, _field), do: :ok

  defp validate_optional_non_negative_integer(value, _field)
       when is_integer(value) and value >= 0,
       do: :ok

  defp validate_optional_non_negative_integer(value, field),
    do: {:error, {:"invalid_#{field}", value}}

  defp validate_boolean(value, _field) when is_boolean(value), do: :ok
  defp validate_boolean(value, field), do: {:error, {:"invalid_#{field}", value}}

  defp validate_auto_flags(full_auto, dangerously_bypass)
       when full_auto and dangerously_bypass,
       do: {:error, :conflicting_auto_flags}

  defp validate_auto_flags(_full_auto, _dangerously_bypass), do: :ok

  defp validate_timeout(value) when is_integer(value) and value > 0, do: :ok
  defp validate_timeout(value), do: {:error, {:invalid_timeout, value}}

  defp normalize_string_list(list, _field) when list in [nil, []], do: {:ok, []}

  defp normalize_string_list(list, field) when is_list(list) do
    if Enum.all?(list, &is_binary/1) do
      {:ok, list}
    else
      {:error, {:invalid_list, field, list}}
    end
  end

  defp normalize_string_list(value, field), do: {:error, {:invalid_list, field, value}}

  defp normalize_transport(nil) do
    {:ok, Application.get_env(:codex_sdk, :default_transport, :exec)}
  end

  defp normalize_transport(:exec), do: {:ok, :exec}
  defp normalize_transport("exec"), do: {:ok, :exec}

  defp normalize_transport({:app_server, pid}) when is_pid(pid), do: {:ok, {:app_server, pid}}

  defp normalize_transport(value), do: {:error, {:invalid_transport, value}}

  defp normalize_sandbox(nil), do: {:ok, :default}
  defp normalize_sandbox(:default), do: {:ok, :default}
  defp normalize_sandbox(:strict), do: {:ok, :strict}
  defp normalize_sandbox(:permissive), do: {:ok, :permissive}
  defp normalize_sandbox(:read_only), do: {:ok, :read_only}
  defp normalize_sandbox(:workspace_write), do: {:ok, :workspace_write}
  defp normalize_sandbox(:danger_full_access), do: {:ok, :danger_full_access}
  defp normalize_sandbox(:external_sandbox), do: {:ok, :external_sandbox}
  defp normalize_sandbox({:external_sandbox, :enabled}), do: {:ok, {:external_sandbox, :enabled}}

  defp normalize_sandbox({:external_sandbox, :restricted}),
    do: {:ok, {:external_sandbox, :restricted}}

  defp normalize_sandbox("read-only"), do: {:ok, :read_only}
  defp normalize_sandbox("workspace-write"), do: {:ok, :workspace_write}
  defp normalize_sandbox("danger-full-access"), do: {:ok, :danger_full_access}
  defp normalize_sandbox("external-sandbox"), do: {:ok, :external_sandbox}

  defp normalize_sandbox(value) when is_binary(value) do
    # Accept arbitrary strings for forward compatibility with the upstream CLI, but
    # keep validating common values.
    {:ok, value}
  end

  defp normalize_sandbox(value), do: {:error, {:invalid_sandbox, value}}

  defp normalize_sandbox_policy(nil), do: {:ok, nil}
  defp normalize_sandbox_policy(%{} = policy), do: {:ok, policy}
  defp normalize_sandbox_policy(policy) when is_list(policy), do: {:ok, Map.new(policy)}
  defp normalize_sandbox_policy(policy) when is_atom(policy), do: {:ok, %{type: policy}}
  defp normalize_sandbox_policy(policy) when is_binary(policy), do: {:ok, %{type: policy}}
  defp normalize_sandbox_policy(value), do: {:error, {:invalid_sandbox_policy, value}}

  defp normalize_color(nil), do: {:ok, nil}
  defp normalize_color(:auto), do: {:ok, :auto}
  defp normalize_color(:always), do: {:ok, :always}
  defp normalize_color(:never), do: {:ok, :never}
  defp normalize_color("auto"), do: {:ok, :auto}
  defp normalize_color("always"), do: {:ok, :always}
  defp normalize_color("never"), do: {:ok, :never}
  defp normalize_color(value) when is_binary(value), do: {:ok, value}
  defp normalize_color(value), do: {:error, {:invalid_color, value}}

  defp normalize_history_persistence(nil), do: {:ok, nil}

  defp normalize_history_persistence(value) when is_atom(value) do
    value
    |> Atom.to_string()
    |> normalize_history_persistence()
  end

  defp normalize_history_persistence(value) when is_binary(value) do
    case String.trim(value) do
      "" -> {:ok, nil}
      trimmed -> {:ok, trimmed}
    end
  end

  defp normalize_history_persistence(value),
    do: {:error, {:invalid_history_persistence, value}}

  defp normalize_reasoning_summary(nil), do: {:ok, nil}

  defp normalize_reasoning_summary(value) when is_atom(value) do
    value
    |> Atom.to_string()
    |> normalize_reasoning_summary()
  end

  defp normalize_reasoning_summary(value) when is_binary(value) do
    case String.downcase(String.trim(value)) do
      "" -> {:ok, nil}
      "auto" -> {:ok, "auto"}
      "concise" -> {:ok, "concise"}
      "detailed" -> {:ok, "detailed"}
      "none" -> {:ok, "none"}
      other -> {:error, {:invalid_model_reasoning_summary, other}}
    end
  end

  defp normalize_reasoning_summary(other),
    do: {:error, {:invalid_model_reasoning_summary, other}}

  defp normalize_model_verbosity(nil), do: {:ok, nil}

  defp normalize_model_verbosity(value) when is_atom(value) do
    value
    |> Atom.to_string()
    |> normalize_model_verbosity()
  end

  defp normalize_model_verbosity(value) when is_binary(value) do
    case String.downcase(String.trim(value)) do
      "" -> {:ok, nil}
      "low" -> {:ok, "low"}
      "medium" -> {:ok, "medium"}
      "high" -> {:ok, "high"}
      other -> {:error, {:invalid_model_verbosity, other}}
    end
  end

  defp normalize_model_verbosity(other), do: {:error, {:invalid_model_verbosity, other}}

  defp normalize_config_overrides(nil), do: {:ok, []}

  defp normalize_config_overrides(%{} = overrides) do
    {:ok, Enum.map(overrides, fn {key, value} -> {to_string(key), value} end)}
  end

  defp normalize_config_overrides(overrides) when is_list(overrides) do
    cond do
      Keyword.keyword?(overrides) ->
        {:ok, Enum.map(overrides, fn {key, value} -> {to_string(key), value} end)}

      Enum.all?(overrides, &is_binary/1) ->
        {:ok, overrides}

      Enum.all?(overrides, &match?({_, _}, &1)) ->
        {:ok, Enum.map(overrides, fn {key, value} -> {to_string(key), value} end)}

      true ->
        {:error, {:invalid_config_overrides, overrides}}
    end
  end

  defp normalize_config_overrides(value), do: {:error, {:invalid_config_overrides, value}}

  defp normalize_shell_environment_policy(nil), do: {:ok, nil}

  defp normalize_shell_environment_policy(%{} = policy) do
    with :ok <- validate_shell_env_inherit(policy),
         :ok <- validate_shell_env_ignore_default_excludes(policy),
         :ok <- validate_shell_env_list(policy, ["exclude", :exclude]),
         :ok <- validate_shell_env_list(policy, ["include_only", :include_only]),
         :ok <- validate_shell_env_set(policy) do
      {:ok, policy}
    end
  end

  defp normalize_shell_environment_policy(list) when is_list(list) do
    normalize_shell_environment_policy(Map.new(list))
  end

  defp normalize_shell_environment_policy(value),
    do: {:error, {:invalid_shell_environment_policy, value}}

  defp validate_shell_env_inherit(policy) do
    case fetch_any(policy, ["inherit", :inherit]) do
      nil -> :ok
      value when is_binary(value) -> :ok
      other -> {:error, {:invalid_shell_environment_inherit, other}}
    end
  end

  defp validate_shell_env_ignore_default_excludes(policy) do
    case fetch_any(policy, ["ignore_default_excludes", :ignore_default_excludes]) do
      nil -> :ok
      value when is_boolean(value) -> :ok
      other -> {:error, {:invalid_shell_environment_ignore_default_excludes, other}}
    end
  end

  defp validate_shell_env_list(policy, keys) do
    case fetch_any(policy, keys) do
      nil ->
        :ok

      value when is_list(value) ->
        if Enum.all?(value, &is_binary/1) do
          :ok
        else
          {:error, {:invalid_shell_environment_list, value}}
        end

      other ->
        {:error, {:invalid_shell_environment_list, other}}
    end
  end

  defp validate_shell_env_set(policy) do
    case fetch_any(policy, ["set", :set]) do
      nil ->
        :ok

      %{} = set ->
        validate_string_map(set, :invalid_shell_environment_set)

      other ->
        {:error, {:invalid_shell_environment_set, other}}
    end
  end

  defp validate_string_map(map, error_tag) do
    if Enum.all?(map, fn {key, value} -> is_binary(key) and is_binary(value) end) do
      :ok
    else
      {:error, {error_tag, map}}
    end
  end

  defp normalize_optional_keyword_list(nil, _field), do: {:ok, nil}

  defp normalize_optional_keyword_list(%{} = value, _field),
    do: {:ok, Map.to_list(value)}

  defp normalize_optional_keyword_list(value, field) when is_list(value) do
    if Keyword.keyword?(value) do
      {:ok, value}
    else
      {:error, {:"invalid_#{field}", value}}
    end
  end

  defp normalize_optional_keyword_list(value, field),
    do: {:error, {:"invalid_#{field}", value}}

  defp normalize_ask_for_approval(nil), do: {:ok, nil}
  defp normalize_ask_for_approval(:untrusted), do: {:ok, :untrusted}
  defp normalize_ask_for_approval(:on_failure), do: {:ok, :on_failure}
  defp normalize_ask_for_approval(:on_request), do: {:ok, :on_request}
  defp normalize_ask_for_approval(:never), do: {:ok, :never}
  defp normalize_ask_for_approval("untrusted"), do: {:ok, :untrusted}
  defp normalize_ask_for_approval("on-failure"), do: {:ok, :on_failure}
  defp normalize_ask_for_approval("on-request"), do: {:ok, :on_request}
  defp normalize_ask_for_approval("never"), do: {:ok, :never}
  defp normalize_ask_for_approval(value) when is_binary(value), do: {:ok, value}
  defp normalize_ask_for_approval(value), do: {:error, {:invalid_ask_for_approval, value}}

  defp fetch_any(map, keys) when is_map(map) and is_list(keys) do
    Enum.reduce_while(keys, nil, fn key, _acc ->
      case Map.fetch(map, key) do
        {:ok, value} -> {:halt, value}
        :error -> {:cont, nil}
      end
    end)
  end
end