thrifty

-module(thrifty@writer_highlevel).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/thrifty/writer_highlevel.gleam").
-export([new/0, write_bool/3, write_i8/3, write_i16/3, write_i32/3, write_i64/3, write_double/3, write_binary/3, write_string/3, write_list/5, write_map/6, write_field_bytes/4, finish/1]).
-export_type([struct_writer/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.

-type struct_writer() :: {struct_writer, integer(), thrifty@writer:buffer()}.

-file("src/thrifty/writer_highlevel.gleam", 23).
?DOC(
    " Create a new empty `StructWriter`.\n"
    "\n"
    " Outputs\n"
    " - A `StructWriter` initialised with last field id `0` and an empty buffer.\n"
    "\n"
    " Semantics\n"
    " - The writer tracks `last_field_id` to emit compact delta-encoded headers.\n"
).
-spec new() -> struct_writer().
new() ->
    {struct_writer, 0, thrifty@writer:buffer_new()}.

-file("src/thrifty/writer_highlevel.gleam", 252).
?DOC(
    " Internal helper that appends a field header and optional payload to the\n"
    " builder's buffer and returns the updated `StructWriter`.\n"
    "\n"
    " Inputs\n"
    " - `struct_writer`: current `StructWriter` state.\n"
    " - `field_id`: identifier for the field being appended.\n"
    " - `field_type`: type of the field.\n"
    " - `payload`: pre-encoded payload bytes for the field (may be empty).\n"
    "\n"
    " Outputs\n"
    " - `StructWriter` updated with the appended header/payload and the new\n"
    "   last_field_id set to `field_id`.\n"
).
-spec append_field(
    struct_writer(),
    integer(),
    thrifty@types:field_type(),
    bitstring()
) -> struct_writer().
append_field(Struct_writer, Field_id, Field_type, Payload) ->
    {struct_writer, Last_field_id, Buffer} = Struct_writer,
    Header = thrifty@writer:write_field_header(
        Field_id,
        Field_type,
        Last_field_id
    ),
    Buffer_with_header = thrifty@writer:buffer_append(Buffer, Header),
    Buffer_with_payload = case erlang:byte_size(Payload) of
        0 ->
            Buffer_with_header;

        _ ->
            thrifty@writer:buffer_append(Buffer_with_header, Payload)
    end,
    {struct_writer, Field_id, Buffer_with_payload}.

-file("src/thrifty/writer_highlevel.gleam", 40).
?DOC(
    " Append a boolean field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: boolean value to encode.\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with the boolean field header appended.\n"
    "\n"
    " Semantics\n"
    " - The boolean is encoded inline in the field header; no payload bytes are\n"
    "   appended beyond the header itself.\n"
).
-spec write_bool(struct_writer(), integer(), boolean()) -> struct_writer().
write_bool(Builder, Field_id, Value) ->
    Field_type = case Value of
        true ->
            bool_true;

        false ->
            bool_false
    end,
    append_field(Builder, Field_id, Field_type, <<>>).

-file("src/thrifty/writer_highlevel.gleam", 61).
?DOC(
    " Append an i8 field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: 8-bit signed integer to encode.\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with the field header and payload appended.\n"
).
-spec write_i8(struct_writer(), integer(), integer()) -> struct_writer().
write_i8(Builder, Field_id, Value) ->
    Payload = thrifty@writer:write_i8(Value),
    append_field(Builder, Field_id, byte, Payload).

-file("src/thrifty/writer_highlevel.gleam", 79).
?DOC(
    " Append an i16 field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: signed integer to encode as i16 (via zigzag + varint semantics).\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with header and encoded payload appended.\n"
).
-spec write_i16(struct_writer(), integer(), integer()) -> struct_writer().
write_i16(Builder, Field_id, Value) ->
    Payload = thrifty@writer:write_i16(Value),
    append_field(Builder, Field_id, i16, Payload).

-file("src/thrifty/writer_highlevel.gleam", 98).
?DOC(
    " Append an i32 field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: signed integer to encode as i32.\n"
    "\n"
    " Outputs\n"
    " - `Ok(StructWriter)` with the new state on success.\n"
    " - `Error(ZigzagRangeError)` when `value` does not fit in i32 range.\n"
).
-spec write_i32(struct_writer(), integer(), integer()) -> {ok, struct_writer()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_i32(Builder, Field_id, Value) ->
    case thrifty@writer:write_i32_checked(Value) of
        {error, Err} ->
            {error, Err};

        {ok, Payload} ->
            {ok, append_field(Builder, Field_id, i32, Payload)}
    end.

-file("src/thrifty/writer_highlevel.gleam", 119).
?DOC(
    " Append an i64 field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: signed integer to encode as i64.\n"
    "\n"
    " Outputs\n"
    " - `Ok(StructWriter)` with the new state on success.\n"
    " - `Error(ZigzagRangeError)` when `value` does not fit in i64 range.\n"
).
-spec write_i64(struct_writer(), integer(), integer()) -> {ok, struct_writer()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_i64(Builder, Field_id, Value) ->
    case thrifty@writer:write_i64_checked(Value) of
        {error, Err} ->
            {error, Err};

        {ok, Payload} ->
            {ok, append_field(Builder, Field_id, i64, Payload)}
    end.

-file("src/thrifty/writer_highlevel.gleam", 139).
?DOC(
    " Append a double (64-bit float) field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: floating point value to store.\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with the encoded field appended.\n"
).
-spec write_double(struct_writer(), integer(), float()) -> struct_writer().
write_double(Builder, Field_id, Value) ->
    Payload = thrifty@writer:write_double(Value),
    append_field(Builder, Field_id, double, Payload).

-file("src/thrifty/writer_highlevel.gleam", 157).
?DOC(
    " Append a binary/blob field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `bytes`: raw payload as `BitArray`.\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with header and length-prefixed payload appended.\n"
).
-spec write_binary(struct_writer(), integer(), bitstring()) -> struct_writer().
write_binary(Builder, Field_id, Bytes) ->
    Payload = thrifty@writer:write_binary(Bytes),
    append_field(Builder, Field_id, binary, Payload).

-file("src/thrifty/writer_highlevel.gleam", 175).
?DOC(
    " Append a UTF-8 string field to the struct under construction.\n"
    "\n"
    " Inputs\n"
    " - `builder`: current `StructWriter` state.\n"
    " - `field_id`: field identifier.\n"
    " - `value`: UTF-8 string to encode.\n"
    "\n"
    " Outputs\n"
    " - Returns an updated `StructWriter` with the encoded string appended.\n"
).
-spec write_string(struct_writer(), integer(), binary()) -> struct_writer().
write_string(Builder, Field_id, Value) ->
    Payload = thrifty@writer:write_string(Value),
    append_field(Builder, Field_id, binary, Payload).

-file("src/thrifty/writer_highlevel.gleam", 188).
?DOC(
    " Write a list field using a pre-encoded payload of elements.\n"
    "\n"
    " The payload must contain the concatenated element encodings. The size is used\n"
    " to emit the list header with the correct short/long encoding.\n"
).
-spec write_list(
    struct_writer(),
    integer(),
    integer(),
    thrifty@container:element_type(),
    bitstring()
) -> struct_writer().
write_list(Builder, Field_id, Size, Element_type, Payload) ->
    Body = thrifty@writer:write_list(Size, Element_type, Payload),
    append_field(Builder, Field_id, list, Body).

-file("src/thrifty/writer_highlevel.gleam", 203).
?DOC(
    " Write a map field using a pre-encoded payload of key/value pairs.\n"
    "\n"
    " The payload must contain the concatenated encodings for keys and values in\n"
    " sequence.\n"
).
-spec write_map(
    struct_writer(),
    integer(),
    integer(),
    thrifty@container:element_type(),
    thrifty@container:element_type(),
    bitstring()
) -> struct_writer().
write_map(Builder, Field_id, Size, Key_type, Value_type, Payload) ->
    Body = thrifty@writer:write_map(Size, Key_type, Value_type, Payload),
    append_field(Builder, Field_id, map, Body).

-file("src/thrifty/writer_highlevel.gleam", 219).
?DOC(
    " Write an arbitrary field by supplying the field type and the payload bytes.\n"
    "\n"
    " This is useful for struct fields encoded by custom logic (e.g. nested\n"
    " structs) while still benefiting from automatic delta handling.\n"
).
-spec write_field_bytes(
    struct_writer(),
    integer(),
    thrifty@types:field_type(),
    bitstring()
) -> struct_writer().
write_field_bytes(Builder, Field_id, Field_type, Payload) ->
    append_field(Builder, Field_id, Field_type, Payload).

-file("src/thrifty/writer_highlevel.gleam", 233).
?DOC(
    " Finalise the `StructWriter` returning a compact protocol encoded `BitArray`.\n"
    "\n"
    " Outputs\n"
    " - A `BitArray` containing the concatenated headers and payloads for the\n"
    "   struct, with a stop field appended automatically.\n"
).
-spec finish(struct_writer()) -> bitstring().
finish(Builder) ->
    {struct_writer, Last_field_id, Buffer} = Builder,
    Stop = thrifty@writer:write_field_header(0, stop, Last_field_id),
    _pipe = thrifty@writer:buffer_append(Buffer, Stop),
    thrifty@writer:buffer_to_bitarray(_pipe).