parser_gleam

-module(parser_gleam@parse_result).
-compile(no_auto_import).

-export([success/3, error/3, with_expected/2, escalate/1, extend/2]).
-export_type([parse_success/2, parse_error/1]).

-type parse_success(KAM, KAN) :: {parse_success,
                                  KAN,
                                  parser_gleam@stream:stream(KAM),
                                  parser_gleam@stream:stream(KAM)}.

-type parse_error(KAO) :: {parse_error,
                           parser_gleam@stream:stream(KAO),
                           list(binary()),
                           boolean()}.

-spec success(
    KBE,
    parser_gleam@stream:stream(KBF),
    parser_gleam@stream:stream(KBF)
) -> {ok, parse_success(KBF, KBE)} | {error, parse_error(KBF)}.
success(Value, Next, Start) ->
    {ok, {parse_success, Value, Next, Start}}.

-spec error(
    parser_gleam@stream:stream(KBK),
    gleam@option:option(list(binary())),
    gleam@option:option(boolean())
) -> {ok, parse_success(KBK, any())} | {error, parse_error(KBK)}.
error(Input, Expected, Fatal) ->
    {error,
     {parse_error,
      Input,
      begin
          _pipe = Expected,
          gleam@option:unwrap(_pipe, [])
      end,
      begin
          _pipe@1 = Fatal,
          gleam@option:unwrap(_pipe@1, false)
      end}}.

-spec with_expected(parse_error(KBS), list(binary())) -> parse_error(KBS).
with_expected(Err, Expected) ->
    {parse_error, erlang:element(2, Err), Expected, erlang:element(4, Err)}.

-spec escalate(parse_error(KBW)) -> parse_error(KBW).
escalate(Err) ->
    {parse_error, erlang:element(2, Err), erlang:element(3, Err), true}.

-spec extend(parse_error(KBZ), parse_error(KBZ)) -> parse_error(KBZ).
extend(Err1, Err2) ->
    (erlang:element(2, get_semigroup()))(Err1, Err2).

-spec get_semigroup() -> fp_gl@models:semigroup(parse_error(any())).
get_semigroup() ->
    {semigroup,
     fun(X, Y) ->
         case erlang:element(3, erlang:element(2, X))
         < erlang:element(3, erlang:element(2, Y)) of
             true ->
                 Y;

             false ->
                 case erlang:element(3, erlang:element(2, X))
                 > erlang:element(3, erlang:element(2, Y)) of
                     true ->
                         X;

                     false ->
                         {parse_error,
                          erlang:element(2, X),
                          gleam@list:append(
                              erlang:element(3, X),
                              erlang:element(3, Y)
                          ),
                          erlang:element(4, X)}
                 end
         end
     end}.