gleam_decode

-module(decode).
-compile(no_auto_import).

-export([bool/0, atom/0, int/0, float/0, string/0, bit_string/0, element/2, field/2, atom_field/2, list/1, dynamic/0, succeed/1, fail/1, one_of/1, then/2, from_result/1, ok_error_tuple/2, map/2, map2/3, map3/4, map4/5, map5/6, map6/7, map7/8, map8/9, decode_dynamic/2]).
-export_type([decoder/1]).

-type decoder(CCP) :: {decoder,
                       fun((gleam@dynamic:dynamic()) -> {ok, CCP} |
                           {error, binary()})}.

-spec bool() -> decoder(boolean()).
bool() ->
    {decoder, fun gleam@dynamic:bool/1}.

-spec atom() -> decoder(gleam@atom:atom_()).
atom() ->
    {decoder, fun gleam@dynamic:atom/1}.

-spec int() -> decoder(integer()).
int() ->
    {decoder, fun gleam@dynamic:int/1}.

-spec float() -> decoder(float()).
float() ->
    {decoder, fun gleam@dynamic:float/1}.

-spec string() -> decoder(binary()).
string() ->
    {decoder, fun gleam@dynamic:string/1}.

-spec bit_string() -> decoder(bitstring()).
bit_string() ->
    {decoder, fun gleam@dynamic:bit_string/1}.

-spec element(integer(), decoder(CCY)) -> decoder(CCY).
element(Position, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Fun = fun(Dynamic) ->
        gleam@result:then(gleam@dynamic:element(Dynamic, Position), Decode_fun)
    end,
    {decoder, Fun}.

-spec field(any(), decoder(CDC)) -> decoder(CDC).
field(Named, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Fun = fun(Dynamic) ->
        gleam@result:then(gleam@dynamic:field(Dynamic, Named), Decode_fun)
    end,
    {decoder, Fun}.

-spec atom_field(binary(), decoder(CDF)) -> decoder(CDF).
atom_field(Named, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Named_result = gleam@result:map_error(
        gleam@atom:from_string(Named),
        fun(_) ->
            gleam@string:append(
                gleam@string:append(<<"No atom key by name of `"/utf8>>, Named),
                <<"` found"/utf8>>
            )
        end
    ),
    Fun = fun(Dynamic) ->
        gleam@result:then(
            gleam@result:then(
                Named_result,
                fun(Gleam@capture_variable) ->
                    gleam@dynamic:field(Dynamic, Gleam@capture_variable)
                end
            ),
            Decode_fun
        )
    end,
    {decoder, Fun}.

-spec list(decoder(CDI)) -> decoder(list(CDI)).
list(Decoder) ->
    {decoder, Decode_fun} = Decoder,
    List_fun = fun(Gleam@capture_variable) ->
        gleam@dynamic:typed_list(Gleam@capture_variable, Decode_fun)
    end,
    {decoder, List_fun}.

-spec dynamic() -> decoder(gleam@dynamic:dynamic()).
dynamic() ->
    {decoder, fun(Dynamic) -> {ok, Dynamic} end}.

-spec succeed(CDO) -> decoder(CDO).
succeed(A) ->
    {decoder, fun(_) -> {ok, A} end}.

-spec fail(binary()) -> decoder(any()).
fail(Error) ->
    {decoder, fun(_) -> {error, Error} end}.

-spec try_decoders(gleam@dynamic:dynamic(), list(decoder(CDS))) -> {ok, CDS} |
    {error, binary()}.
try_decoders(Dynamic, Decoders) ->
    case Decoders of
        [{decoder, Decode_fun} | Remaining_decoders] ->
            case Decode_fun(Dynamic) of
                {ok, Val} ->
                    {ok, Val};

                {error, _} ->
                    try_decoders(Dynamic, Remaining_decoders)
            end;

        [] ->
            {error, <<"All decoders failed"/utf8>>}
    end.

-spec one_of(list(decoder(CDX))) -> decoder(CDX).
one_of(Decoders) ->
    {decoder, fun(Dynamic) -> try_decoders(Dynamic, Decoders) end}.

-spec unwrap(decoder(CEB)) -> fun((gleam@dynamic:dynamic()) -> {ok, CEB} |
    {error, binary()}).
unwrap(Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Decode_fun.

-spec then(decoder(CEF), fun((CEF) -> decoder(CEH))) -> decoder(CEH).
then(Decoder, Fun) ->
    {decoder, Decode_fun} = Decoder,
    Unwrapped_decoder_fun = gleam@function:compose(Fun, fun unwrap/1),
    {decoder,
     fun(Dynamic) ->
         gleam@result:then(
             Decode_fun(Dynamic),
             fun(A) -> (Unwrapped_decoder_fun(A))(Dynamic) end
         )
     end}.

-spec from_result({ok, CEK} | {error, binary()}) -> decoder(CEK).
from_result(Result) ->
    case Result of
        {ok, Value} ->
            succeed(Value);

        {error, Error} ->
            fail(Error)
    end.

-spec ok_error_tuple(decoder(CEO), decoder(CEO)) -> decoder(CEO).
ok_error_tuple(Ok_decoder, Error_decoder) ->
    Failure_decoder = fun(Atom_as_string) ->
        fail(
            gleam@string:append(
                gleam@string:append(
                    <<"Expected 'ok' or 'error' atom in first position of tuple, got '"/utf8>>,
                    Atom_as_string
                ),
                <<"' atom instead"/utf8>>
            )
        )
    end,
    Success_or_failure_fun = fun(Result_atom) ->
        case gleam@atom:to_string(Result_atom) of
            <<"ok"/utf8>> ->
                Ok_decoder;

            <<"error"/utf8>> ->
                Error_decoder;

            Atom_as_string@1 ->
                Failure_decoder(Atom_as_string@1)
        end
    end,
    then(element(0, atom()), Success_or_failure_fun).

-spec map(fun((CES) -> CET), decoder(CES)) -> decoder(CET).
map(Fun, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Mapped_fun = fun(Dynamic) -> gleam@result:map(Decode_fun(Dynamic), Fun) end,
    {decoder, Mapped_fun}.

-spec map2(fun((CEW, CEX) -> CEY), decoder(CEW), decoder(CEX)) -> decoder(CEY).
map2(Fun, Decoder1, Decoder2) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic), Decode_fun2(Dynamic)} of
            {{ok, A}, {ok, B}} ->
                {ok, Fun(A, B)};

            {{error, Str}, _} ->
                {error, Str};

            {_, {error, Str@1}} ->
                {error, Str@1}
        end
    end,
    {decoder, Mapped_fun}.

-spec map3(
    fun((CFC, CFD, CFE) -> CFF),
    decoder(CFC),
    decoder(CFD),
    decoder(CFE)
) -> decoder(CFF).
map3(Fun, Decoder1, Decoder2, Decoder3) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic), Decode_fun2(Dynamic), Decode_fun3(Dynamic)} of
            {{ok, A}, {ok, B}, {ok, C}} ->
                {ok, Fun(A, B, C)};

            {{error, Str}, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}} ->
                {error, Str@2}
        end
    end,
    {decoder, Mapped_fun}.

-spec map4(
    fun((CFK, CFL, CFM, CFN) -> CFO),
    decoder(CFK),
    decoder(CFL),
    decoder(CFM),
    decoder(CFN)
) -> decoder(CFO).
map4(Fun, Decoder1, Decoder2, Decoder3, Decoder4) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    {decoder, Decode_fun4} = Decoder4,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic),
              Decode_fun2(Dynamic),
              Decode_fun3(Dynamic),
              Decode_fun4(Dynamic)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}} ->
                {ok, Fun(A, B, C, D)};

            {{error, Str}, _, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}, _} ->
                {error, Str@2};

            {_, _, _, {error, Str@3}} ->
                {error, Str@3}
        end
    end,
    {decoder, Mapped_fun}.

-spec map5(
    fun((CFU, CFV, CFW, CFX, CFY) -> CFZ),
    decoder(CFU),
    decoder(CFV),
    decoder(CFW),
    decoder(CFX),
    decoder(CFY)
) -> decoder(CFZ).
map5(Fun, Decoder1, Decoder2, Decoder3, Decoder4, Decoder5) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    {decoder, Decode_fun4} = Decoder4,
    {decoder, Decode_fun5} = Decoder5,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic),
              Decode_fun2(Dynamic),
              Decode_fun3(Dynamic),
              Decode_fun4(Dynamic),
              Decode_fun5(Dynamic)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}} ->
                {ok, Fun(A, B, C, D, E)};

            {{error, Str}, _, _, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _, _, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}, _, _} ->
                {error, Str@2};

            {_, _, _, {error, Str@3}, _} ->
                {error, Str@3};

            {_, _, _, _, {error, Str@4}} ->
                {error, Str@4}
        end
    end,
    {decoder, Mapped_fun}.

-spec map6(
    fun((CGG, CGH, CGI, CGJ, CGK, CGL) -> CGM),
    decoder(CGG),
    decoder(CGH),
    decoder(CGI),
    decoder(CGJ),
    decoder(CGK),
    decoder(CGL)
) -> decoder(CGM).
map6(Fun, Decoder1, Decoder2, Decoder3, Decoder4, Decoder5, Decoder6) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    {decoder, Decode_fun4} = Decoder4,
    {decoder, Decode_fun5} = Decoder5,
    {decoder, Decode_fun6} = Decoder6,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic),
              Decode_fun2(Dynamic),
              Decode_fun3(Dynamic),
              Decode_fun4(Dynamic),
              Decode_fun5(Dynamic),
              Decode_fun6(Dynamic)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}, {ok, F}} ->
                {ok, Fun(A, B, C, D, E, F)};

            {{error, Str}, _, _, _, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _, _, _, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}, _, _, _} ->
                {error, Str@2};

            {_, _, _, {error, Str@3}, _, _} ->
                {error, Str@3};

            {_, _, _, _, {error, Str@4}, _} ->
                {error, Str@4};

            {_, _, _, _, _, {error, Str@5}} ->
                {error, Str@5}
        end
    end,
    {decoder, Mapped_fun}.

-spec map7(
    fun((CGU, CGV, CGW, CGX, CGY, CGZ, CHA) -> CHB),
    decoder(CGU),
    decoder(CGV),
    decoder(CGW),
    decoder(CGX),
    decoder(CGY),
    decoder(CGZ),
    decoder(CHA)
) -> decoder(CHB).
map7(Fun, Decoder1, Decoder2, Decoder3, Decoder4, Decoder5, Decoder6, Decoder7) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    {decoder, Decode_fun4} = Decoder4,
    {decoder, Decode_fun5} = Decoder5,
    {decoder, Decode_fun6} = Decoder6,
    {decoder, Decode_fun7} = Decoder7,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic),
              Decode_fun2(Dynamic),
              Decode_fun3(Dynamic),
              Decode_fun4(Dynamic),
              Decode_fun5(Dynamic),
              Decode_fun6(Dynamic),
              Decode_fun7(Dynamic)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}, {ok, F}, {ok, G}} ->
                {ok, Fun(A, B, C, D, E, F, G)};

            {{error, Str}, _, _, _, _, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _, _, _, _, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}, _, _, _, _} ->
                {error, Str@2};

            {_, _, _, {error, Str@3}, _, _, _} ->
                {error, Str@3};

            {_, _, _, _, {error, Str@4}, _, _} ->
                {error, Str@4};

            {_, _, _, _, _, {error, Str@5}, _} ->
                {error, Str@5};

            {_, _, _, _, _, _, {error, Str@6}} ->
                {error, Str@6}
        end
    end,
    {decoder, Mapped_fun}.

-spec map8(
    fun((CHK, CHL, CHM, CHN, CHO, CHP, CHQ, CHR) -> CHS),
    decoder(CHK),
    decoder(CHL),
    decoder(CHM),
    decoder(CHN),
    decoder(CHO),
    decoder(CHP),
    decoder(CHQ),
    decoder(CHR)
) -> decoder(CHS).
map8(
    Fun,
    Decoder1,
    Decoder2,
    Decoder3,
    Decoder4,
    Decoder5,
    Decoder6,
    Decoder7,
    Decoder8
) ->
    {decoder, Decode_fun1} = Decoder1,
    {decoder, Decode_fun2} = Decoder2,
    {decoder, Decode_fun3} = Decoder3,
    {decoder, Decode_fun4} = Decoder4,
    {decoder, Decode_fun5} = Decoder5,
    {decoder, Decode_fun6} = Decoder6,
    {decoder, Decode_fun7} = Decoder7,
    {decoder, Decode_fun8} = Decoder8,
    Mapped_fun = fun(Dynamic) ->
        case {Decode_fun1(Dynamic),
              Decode_fun2(Dynamic),
              Decode_fun3(Dynamic),
              Decode_fun4(Dynamic),
              Decode_fun5(Dynamic),
              Decode_fun6(Dynamic),
              Decode_fun7(Dynamic),
              Decode_fun8(Dynamic)} of
            {{ok, A},
             {ok, B},
             {ok, C},
             {ok, D},
             {ok, E},
             {ok, F},
             {ok, G},
             {ok, H}} ->
                {ok, Fun(A, B, C, D, E, F, G, H)};

            {{error, Str}, _, _, _, _, _, _, _} ->
                {error, Str};

            {_, {error, Str@1}, _, _, _, _, _, _} ->
                {error, Str@1};

            {_, _, {error, Str@2}, _, _, _, _, _} ->
                {error, Str@2};

            {_, _, _, {error, Str@3}, _, _, _, _} ->
                {error, Str@3};

            {_, _, _, _, {error, Str@4}, _, _, _} ->
                {error, Str@4};

            {_, _, _, _, _, {error, Str@5}, _, _} ->
                {error, Str@5};

            {_, _, _, _, _, _, {error, Str@6}, _} ->
                {error, Str@6};

            {_, _, _, _, _, _, _, {error, Str@7}} ->
                {error, Str@7}
        end
    end,
    {decoder, Mapped_fun}.

-spec decode_dynamic(gleam@dynamic:dynamic(), decoder(CIC)) -> {ok, CIC} |
    {error, binary()}.
decode_dynamic(Dynamic, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Decode_fun(Dynamic).