gleam_decode

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

-export([bool/0, atom/0, int/0, float/0, 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 element(integer(), decoder(CCX)) -> decoder(CCX).
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(CDB)) -> decoder(CDB).
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(CDE)) -> decoder(CDE).
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(CDH)) -> decoder(list(CDH)).
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(CDN) -> decoder(CDN).
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(CDR))) -> {ok, CDR} |
    {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(CDW))) -> decoder(CDW).
one_of(Decoders) ->
    {decoder, fun(Dynamic) -> try_decoders(Dynamic, Decoders) end}.

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

-spec then(decoder(CEE), fun((CEE) -> decoder(CEG))) -> decoder(CEG).
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, CEJ} | {error, binary()}) -> decoder(CEJ).
from_result(Result) ->
    case Result of
        {ok, Value} ->
            succeed(Value);

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

-spec ok_error_tuple(decoder(CEN), decoder(CEN)) -> decoder(CEN).
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((CER) -> CES), decoder(CER)) -> decoder(CES).
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((CEV, CEW) -> CEX), decoder(CEV), decoder(CEW)) -> decoder(CEX).
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((CFB, CFC, CFD) -> CFE),
    decoder(CFB),
    decoder(CFC),
    decoder(CFD)
) -> decoder(CFE).
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((CFJ, CFK, CFL, CFM) -> CFN),
    decoder(CFJ),
    decoder(CFK),
    decoder(CFL),
    decoder(CFM)
) -> decoder(CFN).
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((CFT, CFU, CFV, CFW, CFX) -> CFY),
    decoder(CFT),
    decoder(CFU),
    decoder(CFV),
    decoder(CFW),
    decoder(CFX)
) -> decoder(CFY).
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((CGF, CGG, CGH, CGI, CGJ, CGK) -> CGL),
    decoder(CGF),
    decoder(CGG),
    decoder(CGH),
    decoder(CGI),
    decoder(CGJ),
    decoder(CGK)
) -> decoder(CGL).
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((CGT, CGU, CGV, CGW, CGX, CGY, CGZ) -> CHA),
    decoder(CGT),
    decoder(CGU),
    decoder(CGV),
    decoder(CGW),
    decoder(CGX),
    decoder(CGY),
    decoder(CGZ)
) -> decoder(CHA).
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((CHJ, CHK, CHL, CHM, CHN, CHO, CHP, CHQ) -> CHR),
    decoder(CHJ),
    decoder(CHK),
    decoder(CHL),
    decoder(CHM),
    decoder(CHN),
    decoder(CHO),
    decoder(CHP),
    decoder(CHQ)
) -> decoder(CHR).
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(CIB)) -> {ok, CIB} |
    {error, binary()}.
decode_dynamic(Dynamic, Decoder) ->
    {decoder, Decode_fun} = Decoder,
    Decode_fun(Dynamic).