-module(lily@protocol).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lily/protocol.gleam").
-export([encode/2, decode/2]).
-export_type([protocol/2, serialiser/2]).

-type protocol(FSX, FSY) :: {acknowledge, integer()} |
    {client_message, FSY} |
    {resync, integer()} |
    {server_message, integer(), FSY} |
    {snapshot, integer(), FSX}.

-type serialiser(FSZ, FTA) :: {serialiser,
        fun((FTA) -> gleam@json:json()),
        gleam@dynamic@decode:decoder(FTA),
        fun((FSZ) -> gleam@json:json()),
        gleam@dynamic@decode:decoder(FSZ)}.

-file("src/lily/protocol.gleam", 37).
-spec encode(protocol(FTJ, FTK), serialiser(FTJ, FTK)) -> binary().
encode(Protocol, Serialiser) ->
    _pipe = case Protocol of
        {client_message, Payload} ->
            gleam@json:object(
                [{<<"type"/utf8>>, gleam@json:string(<<"client_message"/utf8>>)},
                    {<<"payload"/utf8>>,
                        (erlang:element(2, Serialiser))(Payload)}]
            );

        {server_message, Sequence, Payload@1} ->
            gleam@json:object(
                [{<<"type"/utf8>>, gleam@json:string(<<"server_message"/utf8>>)},
                    {<<"sequence"/utf8>>, gleam@json:int(Sequence)},
                    {<<"payload"/utf8>>,
                        (erlang:element(2, Serialiser))(Payload@1)}]
            );

        {snapshot, Sequence@1, State} ->
            gleam@json:object(
                [{<<"type"/utf8>>, gleam@json:string(<<"snapshot"/utf8>>)},
                    {<<"sequence"/utf8>>, gleam@json:int(Sequence@1)},
                    {<<"state"/utf8>>, (erlang:element(4, Serialiser))(State)}]
            );

        {resync, After_sequence} ->
            gleam@json:object(
                [{<<"type"/utf8>>, gleam@json:string(<<"resync"/utf8>>)},
                    {<<"after_sequence"/utf8>>, gleam@json:int(After_sequence)}]
            );

        {acknowledge, Sequence@2} ->
            gleam@json:object(
                [{<<"type"/utf8>>, gleam@json:string(<<"acknowledge"/utf8>>)},
                    {<<"sequence"/utf8>>, gleam@json:int(Sequence@2)}]
            )
    end,
    gleam@json:to_string(_pipe).

-file("src/lily/protocol.gleam", 79).
-spec acknowledge_decoder() -> gleam@dynamic@decode:decoder(protocol(any(), any())).
acknowledge_decoder() ->
    gleam@dynamic@decode:field(
        <<"sequence"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Sequence) ->
            gleam@dynamic@decode:success({acknowledge, Sequence})
        end
    ).

-file("src/lily/protocol.gleam", 28).
-spec decode(binary(), serialiser(FTB, FTC)) -> {ok, protocol(FTB, FTC)} |
    {error, nil}.
decode(Text, Serialiser) ->
    Decoder = protocol_decoder(Serialiser),
    _pipe = gleam@json:parse(Text, Decoder),
    gleam@result:replace_error(_pipe, nil).

-file("src/lily/protocol.gleam", 91).
-spec protocol_decoder(serialiser(FUB, FUC)) -> gleam@dynamic@decode:decoder(protocol(FUB, FUC)).
protocol_decoder(Serialiser) ->
    gleam@dynamic@decode:then(
        gleam@dynamic@decode:at(
            [<<"type"/utf8>>],
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Protocol_type) -> case Protocol_type of
                <<"client_message"/utf8>> ->
                    client_message_decoder(Serialiser);

                <<"server_message"/utf8>> ->
                    server_message_decoder(Serialiser);

                <<"snapshot"/utf8>> ->
                    snapshot_decoder(Serialiser);

                <<"resync"/utf8>> ->
                    resync_decoder();

                <<"acknowledge"/utf8>> ->
                    acknowledge_decoder();

                _ ->
                    gleam@dynamic@decode:failure(
                        {acknowledge, 0},
                        <<"Protocol"/utf8>>
                    )
            end end
    ).

-file("src/lily/protocol.gleam", 84).
-spec client_message_decoder(serialiser(FTU, FTV)) -> gleam@dynamic@decode:decoder(protocol(FTU, FTV)).
client_message_decoder(Serialiser) ->
    gleam@dynamic@decode:field(
        <<"payload"/utf8>>,
        erlang:element(3, Serialiser),
        fun(Payload) ->
            gleam@dynamic@decode:success({client_message, Payload})
        end
    ).

-file("src/lily/protocol.gleam", 105).
-spec resync_decoder() -> gleam@dynamic@decode:decoder(protocol(any(), any())).
resync_decoder() ->
    gleam@dynamic@decode:field(
        <<"after_sequence"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(After_sequence) ->
            gleam@dynamic@decode:success({resync, After_sequence})
        end
    ).

-file("src/lily/protocol.gleam", 110).
-spec server_message_decoder(serialiser(FUN, FUO)) -> gleam@dynamic@decode:decoder(protocol(FUN, FUO)).
server_message_decoder(Serialiser) ->
    gleam@dynamic@decode:field(
        <<"sequence"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Sequence) ->
            gleam@dynamic@decode:field(
                <<"payload"/utf8>>,
                erlang:element(3, Serialiser),
                fun(Payload) ->
                    gleam@dynamic@decode:success(
                        {server_message, Sequence, Payload}
                    )
                end
            )
        end
    ).

-file("src/lily/protocol.gleam", 118).
-spec snapshot_decoder(serialiser(FUU, FUV)) -> gleam@dynamic@decode:decoder(protocol(FUU, FUV)).
snapshot_decoder(Serialiser) ->
    gleam@dynamic@decode:field(
        <<"sequence"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Sequence) ->
            gleam@dynamic@decode:field(
                <<"state"/utf8>>,
                erlang:element(5, Serialiser),
                fun(State) ->
                    gleam@dynamic@decode:success({snapshot, Sequence, State})
                end
            )
        end
    ).