dream_http_client

-module(dream_http_client@client).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dream_http_client/client.gleam").
-export([method/2, scheme/2, host/2, port/2, path/2, 'query'/2, headers/2, body/2, add_header/3]).
-export_type([client_request/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " HTTP client for making requests\n"
    "\n"
    " Gleam doesn't have a built-in HTTPS client, so Dream wraps Erlang's battle-hardened\n"
    " `httpc`. Use this for calling external APIs, downloading files, or streaming AI responses.\n"
    "\n"
    " ## Quick Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    " import dream_http_client/fetch\n"
    " import gleam/http\n"
    "\n"
    " pub fn call_api() {\n"
    "   client.new\n"
    "   |> client.host(\"api.example.com\")\n"
    "   |> client.path(\"/users/123\")\n"
    "   |> client.header(\"Authorization\", \"Bearer \" <> token)\n"
    "   |> fetch.send()\n"
    " }\n"
    " ```\n"
    "\n"
    " ## Streaming vs Fetch\n"
    "\n"
    " - `fetch`: Get the whole response at once. Good for API calls, JSON responses.\n"
    " - `stream`: Get a yielder that streams chunks. Good for large files, AI responses.\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/stream\n"
    "\n"
    " // Stream large file\n"
    " client.new\n"
    " |> client.host(\"cdn.example.com\")\n"
    " |> client.path(\"/large-file.zip\")\n"
    " |> stream.send()\n"
    " |> yielder.each(process_chunk)\n"
    " ```\n"
).

-type client_request() :: {client_request,
        gleam@http:method(),
        gleam@http:scheme(),
        binary(),
        gleam@option:option(integer()),
        binary(),
        gleam@option:option(binary()),
        list({binary(), binary()}),
        binary()}.

-file("src/dream_http_client/client.gleam", 127).
?DOC(
    " Set the HTTP method for the request\n"
    "\n"
    " Configures the HTTP method (GET, POST, PUT, DELETE, etc.) for the request.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `method_value`: The HTTP method to use\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the method updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    " import gleam/http\n"
    "\n"
    " client.new\n"
    " |> client.method(http.Post)\n"
    " ```\n"
).
-spec method(client_request(), gleam@http:method()) -> client_request().
method(Client_request, Method_value) ->
    {client_request,
        Method_value,
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 156).
?DOC(
    " Set the scheme (protocol) for the request\n"
    "\n"
    " Configures whether to use HTTP or HTTPS. Defaults to HTTPS for security.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `scheme_value`: The protocol scheme (`http.Http` or `http.Https`)\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the scheme updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    " import gleam/http\n"
    "\n"
    " client.new\n"
    " |> client.scheme(http.Http)  // Use HTTP instead of HTTPS\n"
    " ```\n"
).
-spec scheme(client_request(), gleam@http:scheme()) -> client_request().
scheme(Client_request, Scheme_value) ->
    {client_request,
        erlang:element(2, Client_request),
        Scheme_value,
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 184).
?DOC(
    " Set the host for the request\n"
    "\n"
    " Sets the server hostname or IP address. This is required for all requests.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `host_value`: The hostname (e.g., \"api.example.com\" or \"192.168.1.1\")\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the host updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.host(\"api.example.com\")\n"
    " ```\n"
).
-spec host(client_request(), binary()) -> client_request().
host(Client_request, Host_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        Host_value,
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 211).
?DOC(
    " Set the port for the request\n"
    "\n"
    " Sets a custom port number. If not set, defaults to 80 for HTTP and 443\n"
    " for HTTPS. Only set this if you're using a non-standard port.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `port_value`: The port number (e.g., 8080, 3000)\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the port updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.host(\"localhost\")\n"
    " |> client.port(3000)  // Use port 3000 instead of default\n"
    " ```\n"
).
-spec port(client_request(), integer()) -> client_request().
port(Client_request, Port_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        {some, Port_value},
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 236).
?DOC(
    " Set the path for the request\n"
    "\n"
    " Sets the request path. Should start with \"/\" for absolute paths.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `path_value`: The path (e.g., \"/api/users\" or \"/api/users/123\")\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the path updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.path(\"/api/users/123\")\n"
    " ```\n"
).
-spec path(client_request(), binary()) -> client_request().
path(Client_request, Path_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        Path_value,
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 262).
?DOC(
    " Set the query string for the request\n"
    "\n"
    " Sets the query string portion of the URL. Do not include the leading \"?\".\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `query_value`: The query string (e.g., \"page=1&limit=10\")\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the query string updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.path(\"/api/users\")\n"
    " |> client.query(\"page=1&limit=10\")\n"
    " ```\n"
).
-spec 'query'(client_request(), binary()) -> client_request().
'query'(Client_request, Query_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        {some, Query_value},
        erlang:element(8, Client_request),
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 294).
?DOC(
    " Set the headers for the request\n"
    "\n"
    " Replaces all existing headers with the provided list. Use `add_header()`\n"
    " to add a single header without replacing existing ones.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `headers_value`: List of header tuples `#(name, value)`\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with headers replaced.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.headers([\n"
    "   #(\"Authorization\", \"Bearer \" <> token),\n"
    "   #(\"Content-Type\", \"application/json\"),\n"
    " ])\n"
    " ```\n"
).
-spec headers(client_request(), list({binary(), binary()})) -> client_request().
headers(Client_request, Headers_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        Headers_value,
        erlang:element(9, Client_request)}.

-file("src/dream_http_client/client.gleam", 330).
?DOC(
    " Set the body for the request\n"
    "\n"
    " Sets the request body as a string. Typically used for POST, PUT, and PATCH\n"
    " requests. For JSON, serialize your data first.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `body_value`: The request body as a string\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the body updated.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    " import gleam/json\n"
    "\n"
    " let json_body = json.object([\n"
    "   #(\"name\", json.string(\"Alice\")),\n"
    "   #(\"email\", json.string(\"alice@example.com\")),\n"
    " ])\n"
    "\n"
    " client.new\n"
    " |> client.method(http.Post)\n"
    " |> client.body(json.to_string(json_body))\n"
    " ```\n"
).
-spec body(client_request(), binary()) -> client_request().
body(Client_request, Body_value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        erlang:element(8, Client_request),
        Body_value}.

-file("src/dream_http_client/client.gleam", 359).
?DOC(
    " Add a header to the request\n"
    "\n"
    " Adds a single header to the existing headers list without replacing them.\n"
    " The new header is prepended to the list, so it will take precedence if\n"
    " there's a duplicate header name.\n"
    "\n"
    " ## Parameters\n"
    "\n"
    " - `client_request`: The request to modify\n"
    " - `name`: The header name (e.g., \"Authorization\", \"Content-Type\")\n"
    " - `value`: The header value\n"
    "\n"
    " ## Returns\n"
    "\n"
    " A new `ClientRequest` with the header added.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import dream_http_client/client\n"
    "\n"
    " client.new\n"
    " |> client.add_header(\"Authorization\", \"Bearer \" <> token)\n"
    " |> client.add_header(\"Content-Type\", \"application/json\")\n"
    " ```\n"
).
-spec add_header(client_request(), binary(), binary()) -> client_request().
add_header(Client_request, Name, Value) ->
    {client_request,
        erlang:element(2, Client_request),
        erlang:element(3, Client_request),
        erlang:element(4, Client_request),
        erlang:element(5, Client_request),
        erlang:element(6, Client_request),
        erlang:element(7, Client_request),
        [{Name, Value} | erlang:element(8, Client_request)],
        erlang:element(9, Client_request)}.