defmodule OpenAi.Projects do
  @moduledoc """
  Provides API endpoints related to projects
  """

  @default_client OpenAi.Client

  @doc """
  Archives a project in the organization. Archived projects cannot be used or updated.
  """
  @spec archive_project(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.t()} | {:error, OpenAi.Error.error()}
  def archive_project(project_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :archive_project},
      url: "/organization/projects/#{project_id}/archive",
      method: :post,
      response: [{200, {OpenAi.Project, :t}}],
      opts: opts
    })
  end

  @doc """
  Create a new project in the organization. Projects can be created and archived, but cannot be deleted.
  """
  @spec create_project(body :: OpenAi.Project.CreateRequest.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.t()} | {:error, OpenAi.Error.error()}
  def create_project(body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [body: body],
      call: {OpenAi.Projects, :create_project},
      url: "/organization/projects",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.CreateRequest, :t}}],
      response: [{200, {OpenAi.Project, :t}}],
      opts: opts
    })
  end

  @doc """
  Creates a new service account in the project. This also returns an unredacted API key for the service account.
  """
  @spec create_project_service_account(
          project_id :: String.t(),
          body :: OpenAi.Project.ServiceAccount.CreateRequest.t(),
          opts :: keyword
        ) ::
          {:ok, OpenAi.Project.ServiceAccount.CreateResponse.t()} | {:error, OpenAi.Error.error()}
  def create_project_service_account(project_id, body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, body: body],
      call: {OpenAi.Projects, :create_project_service_account},
      url: "/organization/projects/#{project_id}/service_accounts",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.ServiceAccount.CreateRequest, :t}}],
      response: [
        {200, {OpenAi.Project.ServiceAccount.CreateResponse, :t}},
        {400, {OpenAi.ErrorResponse, :t}}
      ],
      opts: opts
    })
  end

  @doc """
  Adds a user to the project. Users must already be members of the organization to be added to a project.
  """
  @spec create_project_user(
          project_id :: String.t(),
          body :: OpenAi.Project.User.CreateRequest.t(),
          opts :: keyword
        ) :: {:ok, OpenAi.Project.User.t()} | {:error, OpenAi.Error.error()}
  def create_project_user(project_id, body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, body: body],
      call: {OpenAi.Projects, :create_project_user},
      url: "/organization/projects/#{project_id}/users",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.User.CreateRequest, :t}}],
      response: [{200, {OpenAi.Project.User, :t}}, {400, {OpenAi.ErrorResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Deletes an API key from the project.
  """
  @spec delete_project_api_key(project_id :: String.t(), key_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.ApiKey.DeleteResponse.t()} | {:error, OpenAi.Error.error()}
  def delete_project_api_key(project_id, key_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, key_id: key_id],
      call: {OpenAi.Projects, :delete_project_api_key},
      url: "/organization/projects/#{project_id}/api_keys/#{key_id}",
      method: :delete,
      response: [
        {200, {OpenAi.Project.ApiKey.DeleteResponse, :t}},
        {400, {OpenAi.ErrorResponse, :t}}
      ],
      opts: opts
    })
  end

  @doc """
  Deletes a service account from the project.
  """
  @spec delete_project_service_account(
          project_id :: String.t(),
          service_account_id :: String.t(),
          opts :: keyword
        ) ::
          {:ok, OpenAi.Project.ServiceAccount.DeleteResponse.t()} | {:error, OpenAi.Error.error()}
  def delete_project_service_account(project_id, service_account_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, service_account_id: service_account_id],
      call: {OpenAi.Projects, :delete_project_service_account},
      url: "/organization/projects/#{project_id}/service_accounts/#{service_account_id}",
      method: :delete,
      response: [{200, {OpenAi.Project.ServiceAccount.DeleteResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Deletes a user from the project.
  """
  @spec delete_project_user(project_id :: String.t(), user_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.User.DeleteResponse.t()} | {:error, OpenAi.Error.error()}
  def delete_project_user(project_id, user_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, user_id: user_id],
      call: {OpenAi.Projects, :delete_project_user},
      url: "/organization/projects/#{project_id}/users/#{user_id}",
      method: :delete,
      response: [
        {200, {OpenAi.Project.User.DeleteResponse, :t}},
        {400, {OpenAi.ErrorResponse, :t}}
      ],
      opts: opts
    })
  end

  @doc """
  Returns a list of API keys in the project.

  ## Options

    * `limit`: A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
      
    * `after`: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
      

  """
  @spec list_project_api_keys(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.ApiKey.ListResponse.t()} | {:error, OpenAi.Error.error()}
  def list_project_api_keys(project_id, opts \\ []) do
    client = opts[:client] || @default_client
    query = Keyword.take(opts, [:after, :limit])

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :list_project_api_keys},
      url: "/organization/projects/#{project_id}/api_keys",
      method: :get,
      query: query,
      response: [{200, {OpenAi.Project.ApiKey.ListResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Returns the rate limits per model for a project.

  ## Options

    * `limit`: A limit on the number of objects to be returned. The default is 100.
      
    * `after`: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
      
    * `before`: A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, beginning with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
      

  """
  @spec list_project_rate_limits(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.RateLimitListResponse.t()} | {:error, OpenAi.Error.error()}
  def list_project_rate_limits(project_id, opts \\ []) do
    client = opts[:client] || @default_client
    query = Keyword.take(opts, [:after, :before, :limit])

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :list_project_rate_limits},
      url: "/organization/projects/#{project_id}/rate_limits",
      method: :get,
      query: query,
      response: [{200, {OpenAi.Project.RateLimitListResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Returns a list of service accounts in the project.

  ## Options

    * `limit`: A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
      
    * `after`: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
      

  """
  @spec list_project_service_accounts(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.ServiceAccount.ListResponse.t()} | {:error, OpenAi.Error.error()}
  def list_project_service_accounts(project_id, opts \\ []) do
    client = opts[:client] || @default_client
    query = Keyword.take(opts, [:after, :limit])

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :list_project_service_accounts},
      url: "/organization/projects/#{project_id}/service_accounts",
      method: :get,
      query: query,
      response: [
        {200, {OpenAi.Project.ServiceAccount.ListResponse, :t}},
        {400, {OpenAi.ErrorResponse, :t}}
      ],
      opts: opts
    })
  end

  @doc """
  Returns a list of users in the project.

  ## Options

    * `limit`: A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
      
    * `after`: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
      

  """
  @spec list_project_users(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.User.ListResponse.t()} | {:error, OpenAi.Error.error()}
  def list_project_users(project_id, opts \\ []) do
    client = opts[:client] || @default_client
    query = Keyword.take(opts, [:after, :limit])

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :list_project_users},
      url: "/organization/projects/#{project_id}/users",
      method: :get,
      query: query,
      response: [{200, {OpenAi.Project.User.ListResponse, :t}}, {400, {OpenAi.ErrorResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Returns a list of projects.

  ## Options

    * `limit`: A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
      
    * `after`: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
      
    * `include_archived`: If `true` returns all projects including those that have been `archived`. Archived projects are not included by default.

  """
  @spec list_projects(opts :: keyword) ::
          {:ok, OpenAi.Project.ListResponse.t()} | {:error, OpenAi.Error.error()}
  def list_projects(opts \\ []) do
    client = opts[:client] || @default_client
    query = Keyword.take(opts, [:after, :include_archived, :limit])

    client.request(%{
      args: [],
      call: {OpenAi.Projects, :list_projects},
      url: "/organization/projects",
      method: :get,
      query: query,
      response: [{200, {OpenAi.Project.ListResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Modifies a project in the organization.
  """
  @spec modify_project(
          project_id :: String.t(),
          body :: OpenAi.Project.UpdateRequest.t(),
          opts :: keyword
        ) :: {:ok, OpenAi.Project.t()} | {:error, OpenAi.Error.error()}
  def modify_project(project_id, body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, body: body],
      call: {OpenAi.Projects, :modify_project},
      url: "/organization/projects/#{project_id}",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.UpdateRequest, :t}}],
      response: [{200, {OpenAi.Project, :t}}, {400, {OpenAi.ErrorResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Modifies a user's role in the project.
  """
  @spec modify_project_user(
          project_id :: String.t(),
          user_id :: String.t(),
          body :: OpenAi.Project.User.UpdateRequest.t(),
          opts :: keyword
        ) :: {:ok, OpenAi.Project.User.t()} | {:error, OpenAi.Error.error()}
  def modify_project_user(project_id, user_id, body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, user_id: user_id, body: body],
      call: {OpenAi.Projects, :modify_project_user},
      url: "/organization/projects/#{project_id}/users/#{user_id}",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.User.UpdateRequest, :t}}],
      response: [{200, {OpenAi.Project.User, :t}}, {400, {OpenAi.ErrorResponse, :t}}],
      opts: opts
    })
  end

  @doc """
  Retrieves a project.
  """
  @spec retrieve_project(project_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.t()} | {:error, OpenAi.Error.error()}
  def retrieve_project(project_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id],
      call: {OpenAi.Projects, :retrieve_project},
      url: "/organization/projects/#{project_id}",
      method: :get,
      response: [{200, {OpenAi.Project, :t}}],
      opts: opts
    })
  end

  @doc """
  Retrieves an API key in the project.
  """
  @spec retrieve_project_api_key(project_id :: String.t(), key_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.ApiKey.t()} | {:error, OpenAi.Error.error()}
  def retrieve_project_api_key(project_id, key_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, key_id: key_id],
      call: {OpenAi.Projects, :retrieve_project_api_key},
      url: "/organization/projects/#{project_id}/api_keys/#{key_id}",
      method: :get,
      response: [{200, {OpenAi.Project.ApiKey, :t}}],
      opts: opts
    })
  end

  @doc """
  Retrieves a service account in the project.
  """
  @spec retrieve_project_service_account(
          project_id :: String.t(),
          service_account_id :: String.t(),
          opts :: keyword
        ) :: {:ok, OpenAi.Project.ServiceAccount.t()} | {:error, OpenAi.Error.error()}
  def retrieve_project_service_account(project_id, service_account_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, service_account_id: service_account_id],
      call: {OpenAi.Projects, :retrieve_project_service_account},
      url: "/organization/projects/#{project_id}/service_accounts/#{service_account_id}",
      method: :get,
      response: [{200, {OpenAi.Project.ServiceAccount, :t}}],
      opts: opts
    })
  end

  @doc """
  Retrieves a user in the project.
  """
  @spec retrieve_project_user(project_id :: String.t(), user_id :: String.t(), opts :: keyword) ::
          {:ok, OpenAi.Project.User.t()} | {:error, OpenAi.Error.error()}
  def retrieve_project_user(project_id, user_id, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, user_id: user_id],
      call: {OpenAi.Projects, :retrieve_project_user},
      url: "/organization/projects/#{project_id}/users/#{user_id}",
      method: :get,
      response: [{200, {OpenAi.Project.User, :t}}],
      opts: opts
    })
  end

  @doc """
  Updates a project rate limit.
  """
  @spec update_project_rate_limits(
          project_id :: String.t(),
          rate_limit_id :: String.t(),
          body :: OpenAi.Project.RateLimitUpdateRequest.t(),
          opts :: keyword
        ) :: {:ok, OpenAi.Project.RateLimit.t()} | {:error, OpenAi.Error.error()}
  def update_project_rate_limits(project_id, rate_limit_id, body, opts \\ []) do
    client = opts[:client] || @default_client

    client.request(%{
      args: [project_id: project_id, rate_limit_id: rate_limit_id, body: body],
      call: {OpenAi.Projects, :update_project_rate_limits},
      url: "/organization/projects/#{project_id}/rate_limits/#{rate_limit_id}",
      body: body,
      method: :post,
      request: [{"application/json", {OpenAi.Project.RateLimitUpdateRequest, :t}}],
      response: [{200, {OpenAi.Project.RateLimit, :t}}, {400, {OpenAi.ErrorResponse, :t}}],
      opts: opts
    })
  end
end