ex_llm

defmodule ExLLM.Adapters.OpenAI do
  @moduledoc """
  OpenAI GPT API adapter for ExLLM.

  ## Configuration

  This adapter requires an OpenAI API key and optionally a base URL.

  ### Using Environment Variables

      # Set environment variables
      export OPENAI_API_KEY="your-api-key"
      export OPENAI_MODEL="gpt-4-turbo"  # optional
      export OPENAI_API_BASE="https://api.openai.com/v1"  # optional

      # Use with default environment provider
      ExLLM.Adapters.OpenAI.chat(messages, config_provider: ExLLM.ConfigProvider.Env)

  ### Using Static Configuration

      config = %{
        openai: %{
          api_key: "your-api-key",
          model: "gpt-4-turbo",
          base_url: "https://api.openai.com/v1"  # optional
        }
      }
      {:ok, provider} = ExLLM.ConfigProvider.Static.start_link(config)
      ExLLM.Adapters.OpenAI.chat(messages, config_provider: provider)

  ## Example Usage

      messages = [
        %{role: "user", content: "Hello, how are you?"}
      ]

      # Simple chat
      {:ok, response} = ExLLM.Adapters.OpenAI.chat(messages)
      IO.puts(response.content)

      # Streaming chat
      {:ok, stream} = ExLLM.Adapters.OpenAI.stream_chat(messages)
      for chunk <- stream do
        if chunk.content, do: IO.write(chunk.content)
      end
  """

  @behaviour ExLLM.Adapter
  @behaviour ExLLM.Adapters.Shared.StreamingBehavior

  alias ExLLM.{Error, Logger, Types}

  alias ExLLM.Adapters.Shared.{
    ConfigHelper,
    ErrorHandler,
    HTTPClient,
    MessageFormatter,
    ModelUtils,
    StreamingBehavior,
    Validation
  }

  @default_base_url "https://api.openai.com/v1"
  @default_temperature 0.7

  @impl true
  def chat(messages, options \\ []) do
    with :ok <- MessageFormatter.validate_messages(messages),
         :ok <- validate_advanced_content(messages),
         :ok <- validate_unsupported_parameters(options),
         config_provider <- ConfigHelper.get_config_provider(options),
         config <- ConfigHelper.get_config(:openai, config_provider),
         api_key <- ConfigHelper.get_api_key(config, "OPENAI_API_KEY"),
         {:ok, _} <- Validation.validate_api_key(api_key) do
      model =
        Keyword.get(
          options,
          :model,
          Map.get(config, :model) || ConfigHelper.ensure_default_model(:openai)
        )

      body = build_request_body(messages, model, config, options)
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/chat/completions"

      case HTTPClient.post_json(url, body, headers, timeout: 60_000, provider: :openai) do
        {:ok, response} ->
          {:ok, parse_response(response, model)}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @impl true
  def stream_chat(messages, options \\ []) do
    with :ok <- MessageFormatter.validate_messages(messages),
         :ok <- validate_advanced_content(messages),
         :ok <- validate_streaming_specific_options(options),
         :ok <- validate_unsupported_parameters_except_streaming(options),
         config_provider <- ConfigHelper.get_config_provider(options),
         config <- ConfigHelper.get_config(:openai, config_provider),
         api_key <- ConfigHelper.get_api_key(config, "OPENAI_API_KEY"),
         {:ok, _} <- Validation.validate_api_key(api_key) do
      model =
        Keyword.get(
          options,
          :model,
          Map.get(config, :model) || ConfigHelper.ensure_default_model(:openai)
        )

      body =
        messages
        |> build_request_body(model, config, options)
        |> Map.put(:stream, true)

      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/chat/completions"
      parent = self()
      ref = make_ref()

      # Start streaming task
      Task.start(fn ->
        HTTPClient.stream_request(
          url,
          body,
          headers,
          fn chunk -> send(parent, {ref, {:chunk, chunk}}) end,
          on_error: fn status, body ->
            send(
              parent,
              {ref, {:error, ErrorHandler.handle_provider_error(:openai, status, body)}}
            )
          end,
          provider: :openai
        )

        # Wait for stream completion and forward the done signal
        receive do
          :stream_done -> send(parent, {ref, :done})
          {:stream_error, error} -> send(parent, {ref, {:error, error}})
        after
          60_000 -> send(parent, {ref, {:error, :timeout}})
        end
      end)

      # Create stream that processes chunks
      stream =
        Stream.resource(
          fn -> {ref, model} end,
          fn {ref, _model} = state ->
            receive do
              {^ref, {:chunk, data}} ->
                case parse_stream_chunk(data) do
                  {:ok, :done} -> {:halt, state}
                  {:ok, chunk} -> {[chunk], state}
                  # Skip bad chunks
                  {:error, _} -> {[], state}
                end

              {^ref, :done} ->
                {:halt, state}

              {^ref, {:error, error}} ->
                throw(error)
            after
              100 -> {[], state}
            end
          end,
          fn _ -> :ok end
        )

      {:ok, stream}
    end
  end

  @impl true
  def list_models(options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)

    # Use ModelLoader with API fetching
    ExLLM.ModelLoader.load_models(
      :openai,
      Keyword.merge(options,
        api_fetcher: fn _opts -> fetch_openai_models(config) end,
        config_transformer: &openai_model_transformer/2
      )
    )
  end

  defp fetch_openai_models(config) do
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    case Validation.validate_api_key(api_key) do
      {:error, _} = error ->
        error

      {:ok, _} ->
        headers = build_headers(api_key, config)
        url = "#{get_base_url(config)}/models"

        case HTTPClient.post_json(url, %{}, headers, method: :get, provider: :openai) do
          {:ok, %{"data" => data}} ->
            models =
              data
              |> Enum.filter(&is_chat_model?/1)
              |> Enum.map(&parse_api_model/1)
              |> Enum.sort_by(& &1.id, :desc)

            {:ok, models}

          {:error, {:api_error, %{status: status, body: body}}} ->
            Logger.debug("Failed to fetch OpenAI models: #{status} - #{inspect(body)}")
            ErrorHandler.handle_provider_error(:openai, status, body)

          {:error, reason} ->
            Logger.debug("Failed to fetch OpenAI models: #{inspect(reason)}")
            {:error, reason}
        end
    end
  end

  defp is_chat_model?(model) do
    id = model["id"]
    # Include GPT models, O models, and exclude instruction-tuned variants
    # Exclude old snapshots
    (String.contains?(id, "gpt") || String.starts_with?(id, "o")) &&
      not String.contains?(id, "instruct") &&
      not String.contains?(id, "0301") &&
      not String.contains?(id, "0314") &&
      not String.contains?(id, "0613")
  end

  defp parse_api_model(model) do
    model_id = model["id"]

    %Types.Model{
      id: model_id,
      name: format_openai_model_name(model_id),
      description: model["description"],
      context_window: get_context_window(model_id),
      capabilities: infer_model_capabilities(model_id)
    }
  end

  defp format_openai_model_name(model_id) do
    # Special cases for OpenAI-specific naming
    case model_id do
      "gpt-4.1" -> "GPT-4.1"
      "gpt-4.1-mini" -> "GPT-4.1 Mini"
      "gpt-4.1-nano" -> "GPT-4.1 Nano"
      "gpt-4o" -> "GPT-4o"
      "gpt-4o-mini" -> "GPT-4o Mini"
      "o3" -> "O3"
      "o3-mini" -> "O3 Mini"
      "o1" -> "O1"
      "o1-mini" -> "O1 Mini"
      _ -> ModelUtils.format_model_name(model_id)
    end
  end

  defp infer_model_capabilities(model_id) do
    # Base capabilities for all OpenAI models
    base_features = [:streaming, :function_calling]

    # Add vision for multimodal models
    features =
      if String.contains?(model_id, "4o") || String.contains?(model_id, "4.1") do
        [:vision | base_features]
      else
        base_features
      end

    %{
      supports_streaming: true,
      supports_functions: true,
      supports_vision: :vision in features,
      features: features
    }
  end

  # Transform config data to OpenAI model format
  defp openai_model_transformer(model_id, config) do
    %Types.Model{
      id: to_string(model_id),
      name: Map.get(config, :name, format_openai_model_name(to_string(model_id))),
      description: Map.get(config, :description),
      context_window: Map.get(config, :context_window, 128_000),
      capabilities: %{
        supports_streaming: :streaming in Map.get(config, :capabilities, []),
        supports_functions: :function_calling in Map.get(config, :capabilities, []),
        supports_vision: :vision in Map.get(config, :capabilities, []),
        features: Map.get(config, :capabilities, [])
      }
    }
  end

  @impl true
  def configured?(options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")
    !is_nil(api_key) && api_key != ""
  end

  @impl true
  def default_model do
    ConfigHelper.ensure_default_model(:openai)
  end

  # Default model fetching moved to shared ConfigHelper module

  # Streaming behavior callback
  @impl ExLLM.Adapters.Shared.StreamingBehavior
  def parse_stream_chunk(data) do
    case data do
      "[DONE]" ->
        {:ok, :done}

      _ ->
        case Jason.decode(data) do
          {:ok, parsed} ->
            choice = get_in(parsed, ["choices", Access.at(0)]) || %{}
            delta = choice["delta"] || %{}

            chunk =
              StreamingBehavior.create_text_chunk(
                delta["content"] || "",
                finish_reason: choice["finish_reason"]
              )

            {:ok, chunk}

          {:error, _} ->
            {:error, :invalid_json}
        end
    end
  end

  # Private functions

  # API key validation moved to shared Validation module

  @doc false
  def build_request_body(messages, model, config, options) do
    %{
      model: model,
      messages: MessageFormatter.stringify_message_keys(messages),
      temperature:
        Keyword.get(options, :temperature, Map.get(config, :temperature, @default_temperature))
    }
    |> maybe_add_max_tokens(options, config)
    |> maybe_add_modern_parameters(options)
    |> maybe_add_response_format(options)
    |> maybe_add_tools(options)
    |> maybe_add_audio_options(options)
    |> maybe_add_web_search(options)
    |> maybe_add_o_series_options(options, model)
    |> maybe_add_prediction(options)
    |> maybe_add_streaming_options(options)
    |> maybe_add_system_prompt(options)
    # Keep for backward compatibility
    |> maybe_add_functions(options)
  end

  defp build_headers(api_key, config) do
    headers = [
      {"authorization", "Bearer #{api_key}"}
    ]

    if org = Map.get(config, :organization) do
      [{"openai-organization", org} | headers]
    else
      headers
    end
  end

  defp maybe_add_system_prompt(body, options) do
    case Keyword.get(options, :system) do
      nil -> body
      system -> Map.update!(body, :messages, &MessageFormatter.add_system_message(&1, system))
    end
  end

  defp maybe_add_functions(body, options) do
    case Keyword.get(options, :functions) do
      nil -> body
      functions -> Map.put(body, :functions, functions)
    end
  end

  defp get_base_url(config) do
    # Check config first, then environment variable, then default
    Map.get(config, :base_url) ||
      System.get_env("OPENAI_API_BASE") ||
      @default_base_url
  end

  def parse_response(response, model) do
    choice = get_in(response, ["choices", Access.at(0)]) || %{}
    message = choice["message"] || %{}
    usage = response["usage"] || %{}

    # Enhanced usage tracking
    enhanced_usage = parse_enhanced_usage(usage)

    %Types.LLMResponse{
      content: message["content"] || "",
      function_call: message["function_call"],
      tool_calls: message["tool_calls"],
      refusal: message["refusal"],
      logprobs: choice["logprobs"],
      usage: enhanced_usage,
      model: model,
      finish_reason: choice["finish_reason"],
      cost:
        ExLLM.Cost.calculate("openai", model, %{
          input_tokens: enhanced_usage.input_tokens,
          output_tokens: enhanced_usage.output_tokens
        })
    }
  end

  defp get_context_window(model_id) do
    # Use ModelConfig for context window lookup
    # This will return nil if model not found, which we handle in the caller
    ExLLM.ModelConfig.get_context_window(:openai, model_id)
  end

  # Public helper functions for testing and validation
  def validate_functions_parameter(functions) when is_list(functions) do
    Logger.warn("[OpenAI] The 'functions' parameter is deprecated. Use 'tools' instead.")
    :ok
  end

  # Helper functions for validation and building request body

  defp validate_advanced_content(messages) do
    Enum.each(messages, fn message ->
      # Developer role is now supported for o1+ models!
      # Check for developer role (both atom and string keys/values)
      # role = Map.get(message, :role) || Map.get(message, "role")
      # if role == "developer" or role == :developer do
      #   raise RuntimeError, "Developer role for o1+ models is not yet supported in this adapter"
      # end

      case message do
        %{content: content} when is_list(content) ->
          # Check for unsupported content types
          content_types =
            Enum.map(content, fn
              %{type: type} -> type
              _ -> :unknown
            end)

          if "file" in content_types do
            raise RuntimeError, "File content references are not yet supported in this adapter"
          end

          # Audio content in messages is now supported!
          # "input_audio" in content_types ->
          #   raise RuntimeError, "Audio content in messages is not yet supported in this adapter"

          # Multiple content parts are now supported (for audio and other content)!
          # length(content) > 1 and "text" in content_types ->
          #   raise RuntimeError, "Multiple content parts per message are not yet supported in this adapter"

          :ok

        _ ->
          :ok
      end
    end)

    :ok
  end

  defp validate_unsupported_parameters(options) do
    # Special case for parallel_tool_calls - if tools are provided, give specific message
    # This is now supported!
    # if Keyword.has_key?(options, :parallel_tool_calls) and Keyword.has_key?(options, :tools) do
    #   raise RuntimeError, "parallel tool calls are not yet supported"
    # end

    unsupported_params = [
      # Modern request parameters are now supported!
      # {:max_completion_tokens, "max_completion_tokens parameter is not yet supported"},
      # {:n, "n parameter for multiple completions is not yet supported"},
      # {:top_p, "top_p nucleus sampling parameter is not yet supported"},
      # {:frequency_penalty, "frequency_penalty parameter is not yet supported"},
      # {:presence_penalty, "presence_penalty parameter is not yet supported"},
      # {:seed, "seed parameter for deterministic sampling is not yet supported"},
      # {:stop, "stop sequences parameter is not yet supported"},
      # {:service_tier, "service_tier parameter is not yet supported"},
      # {:logprobs, "logprobs parameter is not yet supported"},
      # {:top_logprobs, "top_logprobs parameter is not yet supported"},

      # {:response_format, "response_format JSON mode and JSON schema are not yet supported"},
      # {:tools, "modern tools API is not yet supported (use 'functions' for legacy support)"},
      # {:tool_choice, "tool_choice parameter is not yet supported"},
      # {:parallel_tool_calls, "parallel tool calls are not yet supported"},
      # {:audio, "audio output is not yet supported"},  # Audio output is now supported!
      # {:web_search_options, "web search integration is not yet supported"},  # Web search is now supported!
      # {:reasoning_effort, "reasoning_effort parameter is not yet supported"},  # Reasoning effort is now supported!
      # {:prediction, "predicted outputs are not yet supported"}  # Predicted outputs are now supported!,
      # {:stream_options, "advanced stream_options are not yet supported"}  # Now supported!
    ]

    Enum.each(unsupported_params, fn {param, message} ->
      if Keyword.has_key?(options, param) do
        raise RuntimeError, message
      end
    end)

    :ok
  end

  defp validate_unsupported_parameters_except_streaming(options) do
    # Same as validate_unsupported_parameters but without streaming-specific ones
    unsupported_params = [
      # Modern request parameters are now supported!
      # {:max_completion_tokens, "max_completion_tokens parameter is not yet supported"},
      # {:n, "n parameter for multiple completions is not yet supported"},
      # {:top_p, "top_p nucleus sampling parameter is not yet supported"},
      # {:frequency_penalty, "frequency_penalty parameter is not yet supported"},
      # {:presence_penalty, "presence_penalty parameter is not yet supported"},
      # {:seed, "seed parameter for deterministic sampling is not yet supported"},
      # {:stop, "stop sequences parameter is not yet supported"},
      # {:service_tier, "service_tier parameter is not yet supported"},
      # {:logprobs, "logprobs parameter is not yet supported"},
      # {:top_logprobs, "top_logprobs parameter is not yet supported"},

      # {:response_format, "response_format JSON mode and JSON schema are not yet supported"},
      # {:tool_choice, "tool_choice parameter is not yet supported"},
      # {:parallel_tool_calls, "parallel tool calls are not yet supported"},
      # {:audio, "audio output is not yet supported"},  # Audio output is now supported!
      # {:web_search_options, "web search integration is not yet supported"},  # Web search is now supported!
      # {:reasoning_effort, "reasoning_effort parameter is not yet supported"},  # Reasoning effort is now supported!
      # {:prediction, "predicted outputs are not yet supported"}  # Predicted outputs are now supported!
    ]

    Enum.each(unsupported_params, fn {param, message} ->
      if Keyword.has_key?(options, param) do
        raise RuntimeError, message
      end
    end)

    :ok
  end

  defp validate_streaming_specific_options(options) do
    # Check for streaming-specific unsupported features
    streaming_unsupported = [
      # {:tools, "streaming tool calls are not yet supported"},  # Now supported!
      # {:stream_options, "advanced stream_options are not yet supported"}  # Now supported!
    ]

    Enum.each(streaming_unsupported, fn {param, message} ->
      if Keyword.has_key?(options, param) do
        raise RuntimeError, message
      end
    end)

    :ok
  end

  defp maybe_add_max_tokens(body, options, config) do
    cond do
      Keyword.has_key?(options, :max_completion_tokens) ->
        Map.put(body, :max_completion_tokens, Keyword.get(options, :max_completion_tokens))

      Keyword.has_key?(options, :max_tokens) ->
        # Legacy parameter for backward compatibility
        Map.put(body, :max_tokens, Keyword.get(options, :max_tokens))

      Map.has_key?(config, :max_tokens) ->
        Map.put(body, :max_tokens, Map.get(config, :max_tokens))

      true ->
        body
    end
  end

  defp maybe_add_modern_parameters(body, options) do
    body
    |> maybe_add_optional_param(options, :n)
    |> maybe_add_optional_param(options, :top_p)
    |> maybe_add_optional_param(options, :frequency_penalty)
    |> maybe_add_optional_param(options, :presence_penalty)
    |> maybe_add_optional_param(options, :seed)
    |> maybe_add_optional_param(options, :stop)
    |> maybe_add_optional_param(options, :service_tier)
    |> maybe_add_optional_param(options, :logprobs)
    |> maybe_add_optional_param(options, :top_logprobs)
  end

  defp maybe_add_response_format(body, options) do
    case Keyword.get(options, :response_format) do
      nil -> body
      format -> Map.put(body, :response_format, format)
    end
  end

  defp maybe_add_tools(body, options) do
    case Keyword.get(options, :tools) do
      nil ->
        body

      tools ->
        body
        |> Map.put(:tools, tools)
        |> maybe_add_optional_param(options, :tool_choice)
        |> maybe_add_optional_param(options, :parallel_tool_calls)
    end
  end

  defp maybe_add_audio_options(body, options) do
    case Keyword.get(options, :audio) do
      nil -> body
      audio_config -> Map.put(body, :audio, audio_config)
    end
  end

  defp maybe_add_web_search(body, options) do
    case Keyword.get(options, :web_search_options) do
      nil -> body
      web_search -> Map.put(body, :web_search_options, web_search)
    end
  end

  defp maybe_add_o_series_options(body, options, model) do
    if String.starts_with?(model, "o") do
      body
      |> maybe_add_optional_param(options, :reasoning_effort)
    else
      body
    end
  end

  defp maybe_add_prediction(body, options) do
    case Keyword.get(options, :prediction) do
      nil -> body
      prediction -> Map.put(body, :prediction, prediction)
    end
  end

  defp maybe_add_streaming_options(body, options) do
    case Keyword.get(options, :stream_options) do
      nil -> body
      stream_opts -> Map.put(body, :stream_options, stream_opts)
    end
  end

  defp maybe_add_optional_param(body, options, param) do
    case Keyword.get(options, param) do
      nil -> body
      value -> Map.put(body, param, value)
    end
  end

  defp parse_enhanced_usage(usage) do
    base_usage = %{
      input_tokens: usage["prompt_tokens"] || 0,
      output_tokens: usage["completion_tokens"] || 0,
      total_tokens: usage["total_tokens"] || 0
    }

    # Add enhanced details if available
    prompt_details = usage["prompt_tokens_details"] || %{}
    completion_details = usage["completion_tokens_details"] || %{}

    enhanced_details = %{
      cached_tokens: prompt_details["cached_tokens"],
      audio_tokens:
        (prompt_details["audio_tokens"] || 0) + (completion_details["audio_tokens"] || 0),
      reasoning_tokens: completion_details["reasoning_tokens"]
    }

    # Only include non-nil enhanced details
    enhanced_details
    |> Enum.filter(fn {_k, v} -> not is_nil(v) end)
    |> Enum.into(base_usage)
  end

  @impl true
  def embeddings(inputs, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key),
         {:ok, url} <- build_embeddings_url(config),
         {:ok, req_body} <- build_embeddings_request(inputs, config, options),
         {:ok, response} <- send_embeddings_request(url, req_body, config, api_key) do
      parse_embeddings_response(response, inputs, config, options)
    end
  end

  @impl true
  def list_embedding_models(_options \\ []) do
    models = [
      %Types.EmbeddingModel{
        name: "text-embedding-3-small",
        dimensions: 1536,
        max_inputs: 1,
        provider: :openai,
        description: "Small, efficient embedding model",
        pricing: %{
          # $0.02 per million
          input_cost_per_token: 0.00002 / 1000,
          output_cost_per_token: 0.0,
          currency: "USD"
        }
      },
      %Types.EmbeddingModel{
        name: "text-embedding-3-large",
        dimensions: 3072,
        max_inputs: 1,
        provider: :openai,
        description: "Large, high-quality embedding model",
        pricing: %{
          # $0.13 per million
          input_cost_per_token: 0.00013 / 1000,
          output_cost_per_token: 0.0,
          currency: "USD"
        }
      },
      %Types.EmbeddingModel{
        name: "text-embedding-ada-002",
        dimensions: 1536,
        max_inputs: 1,
        provider: :openai,
        description: "Legacy embedding model",
        pricing: %{
          # $0.10 per million
          input_cost_per_token: 0.0001 / 1000,
          output_cost_per_token: 0.0,
          currency: "USD"
        }
      }
    ]

    {:ok, models}
  end

  # Private embedding functions

  defp build_embeddings_url(config) do
    {:ok, "#{get_base_url(config)}/embeddings"}
  end

  defp build_embeddings_request(inputs, _config, options) do
    model = Keyword.get(options, :model, "text-embedding-3-small")

    # OpenAI supports multiple inputs but we'll send one at a time for consistency
    body = %{
      model: model,
      input: inputs,
      encoding_format: "float"
    }

    # Add optional parameters
    body =
      if dimensions = Keyword.get(options, :dimensions) do
        Map.put(body, :dimensions, dimensions)
      else
        body
      end

    {:ok, body}
  end

  defp send_embeddings_request(url, body, config, api_key) do
    headers = build_headers(api_key, config)

    case HTTPClient.post_json(url, body, headers, timeout: 30_000) do
      {:ok, response} -> {:ok, response}
      {:error, reason} -> {:error, reason}
    end
  end

  defp parse_embeddings_response(response, _inputs, _config, options) do
    case response do
      %{"data" => data, "usage" => usage, "model" => model} ->
        # Extract embeddings
        embeddings =
          Enum.map(data, fn item ->
            item["embedding"]
          end)

        # Build response
        embedding_response = %Types.EmbeddingResponse{
          embeddings: embeddings,
          model: model,
          usage: %{
            input_tokens: usage["prompt_tokens"],
            # Embeddings don't have output tokens
            output_tokens: 0
          }
        }

        # Add cost tracking if enabled
        embedding_response =
          if Keyword.get(options, :track_cost, true) do
            cost = ExLLM.Cost.calculate(:openai, model, embedding_response.usage)
            %{embedding_response | cost: cost}
          else
            embedding_response
          end

        {:ok, embedding_response}

      _ ->
        {:error, Error.json_parse_error("Invalid embeddings response")}
    end
  end

  # Additional API endpoints

  @doc """
  Moderate content using OpenAI's moderation API.
  """
  def moderate_content(input, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      body = %{
        input: input,
        model: Keyword.get(options, :model, "text-moderation-latest")
      }

      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/moderations"

      case HTTPClient.post_json(url, body, headers, timeout: 30_000, provider: :openai) do
        {:ok, response} ->
          {:ok, parse_moderation_response(response)}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Generate images using OpenAI's DALL-E API.
  """
  def generate_image(prompt, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      body = %{
        prompt: prompt,
        model: Keyword.get(options, :model, "dall-e-3"),
        n: Keyword.get(options, :n, 1),
        size: Keyword.get(options, :size, "1024x1024"),
        quality: Keyword.get(options, :quality, "standard"),
        response_format: Keyword.get(options, :response_format, "url")
      }

      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/images/generations"

      case HTTPClient.post_json(url, body, headers, timeout: 120_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Create an assistant.
  """
  def create_assistant(assistant_params, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      # Set default model if not provided
      body = Map.put_new(assistant_params, :model, "gpt-4-turbo")

      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/assistants"

      case HTTPClient.post_json(url, body, headers, timeout: 30_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Transcribe audio using OpenAI's Whisper API.
  """
  def transcribe_audio(file_path, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key),
         # File path is provided by the user for legitimate file upload
         # sobelow_skip ["Traversal.FileModule"]
         {:ok, _file_data} <- File.read(file_path) do
      # For now, return a simple error since we don't have multipart upload support
      # Real implementation would need multipart form data support in HTTPClient
      {:error, :multipart_not_supported}
    end
  end

  @doc """
  Upload a file to OpenAI for use with assistants or other endpoints.

  ## Parameters
  - `file_path` - Path to the file to upload
  - `purpose` - The intended purpose of the file. Supported values:
    - `"fine-tune"` - For fine-tuning models
    - `"fine-tune-results"` - Fine-tuning results (system-generated)
    - `"assistants"` - For use with Assistants API
    - `"assistants_output"` - Assistant outputs (system-generated)
    - `"batch"` - For batch API input
    - `"batch_output"` - Batch API results (system-generated)
    - `"vision"` - For vision fine-tuning
    - `"user_data"` - Flexible file type for any purpose
    - `"evals"` - For evaluation datasets
  - `options` - Additional options including config_provider

  ## Examples

      {:ok, file} = OpenAI.upload_file("/path/to/data.jsonl", "fine-tune")
      file["id"] # => "file-abc123"
      file["expires_at"] # => 1680202602

  ## File Object Structure

  The returned file object contains:
  - `"id"` - The file identifier (e.g., "file-abc123")
  - `"object"` - Always "file"
  - `"bytes"` - Size of the file in bytes
  - `"created_at"` - Unix timestamp when created
  - `"expires_at"` - Unix timestamp when the file expires
  - `"filename"` - The name of the uploaded file
  - `"purpose"` - The intended purpose of the file
  - `"status"` - (Deprecated) Upload status
  - `"status_details"` - (Deprecated) Validation error details
  """
  def upload_file(file_path, purpose, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key),
         {:ok, _} <- validate_file_purpose(purpose) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/files"

      form_data = [
        purpose: purpose,
        file: {:file, file_path}
      ]

      case HTTPClient.post_multipart(url, form_data, headers, timeout: 60_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  List all uploaded files.

  ## Options
  - `:after` - Cursor for pagination (object ID)
  - `:limit` - Number of objects to return (1-10000, default: 10000)
  - `:order` - Sort order: "asc" or "desc" (default: "desc")
  - `:purpose` - Filter by file purpose

  ## Examples

      # List all files
      {:ok, files} = OpenAI.list_files()
      
      # List with pagination
      {:ok, files} = OpenAI.list_files(limit: 100, after: "file-abc123")
      
      # Filter by purpose
      {:ok, files} = OpenAI.list_files(purpose: "fine-tune")
  """
  def list_files(options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/files"

      # Build query parameters according to API spec
      query_params = []

      # Add pagination cursor
      query_params =
        if after_cursor = Keyword.get(options, :after) do
          [{"after", after_cursor} | query_params]
        else
          query_params
        end

      # Add limit (1-10000, default 10000)
      query_params =
        if limit = Keyword.get(options, :limit) do
          # Validate limit range
          limit = max(1, min(limit, 10_000))
          [{"limit", to_string(limit)} | query_params]
        else
          query_params
        end

      # Add order (asc/desc, default desc)
      query_params =
        if order = Keyword.get(options, :order) do
          order = if order in ["asc", "desc"], do: order, else: "desc"
          [{"order", order} | query_params]
        else
          query_params
        end

      # Add purpose filter
      query_params =
        if purpose = Keyword.get(options, :purpose) do
          [{"purpose", purpose} | query_params]
        else
          query_params
        end

      # Build final URL with query string
      url =
        if query_params != [] do
          url <> "?" <> URI.encode_query(query_params)
        else
          url
        end

      case HTTPClient.post_json(url, %{}, headers,
             method: :get,
             timeout: 30_000,
             provider: :openai
           ) do
        {:ok, response} ->
          # Response should have "data" array and "object": "list"
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Get metadata for a specific file.
  """
  def get_file(file_id, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/files/#{file_id}"

      case HTTPClient.post_json(url, %{}, headers,
             method: :get,
             timeout: 30_000,
             provider: :openai
           ) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Delete an uploaded file.
  """
  def delete_file(file_id, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/files/#{file_id}"

      case HTTPClient.post_json(url, %{}, headers,
             method: :delete,
             timeout: 30_000,
             provider: :openai
           ) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Retrieve the content of an uploaded file.
  """
  def retrieve_file_content(file_id, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/files/#{file_id}/content"

      # Remove content-type header for file download
      headers = List.keydelete(headers, "Content-Type", 0)

      case HTTPClient.post_json(url, %{}, headers,
             method: :get,
             timeout: 60_000,
             provider: :openai
           ) do
        {:ok, response} when is_binary(response) ->
          {:ok, response}

        {:ok, response} ->
          # If response is JSON, convert to string
          {:ok, Jason.encode!(response)}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  defp validate_file_purpose(purpose)
       when purpose in [
              "fine-tune",
              "fine-tune-results",
              "assistants",
              "assistants_output",
              "batch",
              "batch_output",
              "vision",
              "user_data",
              "evals"
            ] do
    {:ok, purpose}
  end

  defp validate_file_purpose(purpose) do
    Error.validation_error(
      :purpose,
      "Invalid purpose '#{purpose}'. Must be one of: fine-tune, fine-tune-results, assistants, assistants_output, batch, batch_output, vision, user_data, evals"
    )
  end

  # Upload API functions

  @doc """
  Create an Upload object for multipart file uploads.

  Use this for files larger than the regular file upload limit. 
  An Upload can accept at most 8 GB and expires after 1 hour.

  ## Parameters
  - `bytes` - The total number of bytes to upload
  - `filename` - The name of the file
  - `mime_type` - The MIME type (e.g., "text/jsonl")
  - `purpose` - The intended purpose of the file
  - `options` - Additional options

  ## Examples

      {:ok, upload} = OpenAI.create_upload(
        bytes: 2_147_483_648,
        filename: "training_examples.jsonl",
        mime_type: "text/jsonl",
        purpose: "fine-tune"
      )
      
      upload["id"] # => "upload_abc123"
      upload["status"] # => "pending"
  """
  def create_upload(params, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key),
         {:ok, _} <- validate_upload_params(params) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/uploads"

      body = %{
        bytes: params[:bytes],
        filename: params[:filename],
        mime_type: params[:mime_type],
        purpose: params[:purpose]
      }

      case HTTPClient.post_json(url, body, headers, timeout: 30_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Add a part to an existing upload.

  Each part can be at most 64 MB. Parts can be added in parallel.

  ## Parameters
  - `upload_id` - The ID of the Upload
  - `data` - The chunk of bytes for this part
  - `options` - Additional options

  ## Examples

      {:ok, part} = OpenAI.add_upload_part("upload_abc123", chunk_data)
      part["id"] # => "part_def456"
  """
  def add_upload_part(upload_id, data, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key),
         {:ok, _} <- validate_part_size(data) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/uploads/#{upload_id}/parts"

      # Use multipart form for the data chunk
      form_data = [
        data: data
      ]

      case HTTPClient.post_multipart(url, form_data, headers, timeout: 60_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Complete an upload and create the final File object.

  ## Parameters
  - `upload_id` - The ID of the Upload
  - `part_ids` - Ordered list of Part IDs
  - `options` - Additional options (can include `:md5` for checksum verification)

  ## Examples

      {:ok, completed} = OpenAI.complete_upload(
        "upload_abc123",
        ["part_def456", "part_ghi789"]
      )
      
      completed["status"] # => "completed"
      completed["file"]["id"] # => "file-xyz321"
  """
  def complete_upload(upload_id, part_ids, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/uploads/#{upload_id}/complete"

      body = %{
        part_ids: part_ids
      }

      # Add optional MD5 checksum if provided
      body =
        if md5 = Keyword.get(options, :md5) do
          Map.put(body, :md5, md5)
        else
          body
        end

      case HTTPClient.post_json(url, body, headers, timeout: 60_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  @doc """
  Cancel an upload.

  No parts may be added after an upload is cancelled.

  ## Parameters
  - `upload_id` - The ID of the Upload to cancel
  - `options` - Additional options

  ## Examples

      {:ok, cancelled} = OpenAI.cancel_upload("upload_abc123")
      cancelled["status"] # => "cancelled"
  """
  def cancel_upload(upload_id, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/uploads/#{upload_id}/cancel"

      case HTTPClient.post_json(url, %{}, headers, timeout: 30_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  defp validate_upload_params(params) do
    required = [:bytes, :filename, :mime_type, :purpose]

    missing = required -- Keyword.keys(params)

    if missing != [] do
      Error.validation_error(:params, "Missing required parameters: #{inspect(missing)}")
    else
      # Validate bytes (max 8GB)
      # 8 GB
      max_bytes = 8 * 1024 * 1024 * 1024

      if params[:bytes] > max_bytes do
        Error.validation_error(:bytes, "Upload size cannot exceed 8 GB")
      else
        # Validate purpose
        validate_file_purpose(params[:purpose])
      end
    end
  end

  defp validate_part_size(data) do
    # 64 MB
    max_part_size = 64 * 1024 * 1024

    size =
      case data do
        binary when is_binary(binary) ->
          byte_size(binary)

        {:file, path} ->
          case File.stat(path) do
            {:ok, %{size: size}} -> size
            _ -> 0
          end

        _ ->
          0
      end

    if size > max_part_size do
      Error.validation_error(:data, "Part size cannot exceed 64 MB")
    else
      {:ok, data}
    end
  end

  @doc """
  Create a batch request for processing multiple inputs.
  """
  def create_batch(_requests, options \\ []) do
    config_provider = ConfigHelper.get_config_provider(options)
    config = ConfigHelper.get_config(:openai, config_provider)
    api_key = ConfigHelper.get_api_key(config, "OPENAI_API_KEY")

    with {:ok, _} <- Validation.validate_api_key(api_key) do
      # For now, return a simple implementation that works with the test
      # Real implementation would need file upload and JSONL processing
      headers = build_headers(api_key, config)
      url = "#{get_base_url(config)}/batches"

      # Simple batch creation without file upload for now
      body = %{
        endpoint: "/v1/chat/completions",
        completion_window: Keyword.get(options, :completion_window, "24h")
      }

      case HTTPClient.post_json(url, body, headers, timeout: 30_000, provider: :openai) do
        {:ok, response} ->
          {:ok, response}

        {:error, {:api_error, %{status: status, body: body}}} ->
          ErrorHandler.handle_provider_error(:openai, status, body)

        {:error, reason} ->
          {:error, reason}
      end
    end
  end

  defp parse_moderation_response(response) do
    case response do
      %{"results" => [result | _]} ->
        %{
          flagged: result["flagged"],
          categories: result["categories"],
          category_scores: result["category_scores"]
        }

      _ ->
        %{flagged: false, categories: %{}, category_scores: %{}}
    end
  end
end