-module(metamon@internal@regression).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/metamon/internal/regression.gleam").
-export([parse/1, render/1]).
-export_type([entry/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.

?MODULEDOC(false).

-type entry() :: {entry,
        binary(),
        integer(),
        integer(),
        integer(),
        gleam@option:option(integer()),
        gleam@option:option(binary()),
        binary()}.

-file("src/metamon/internal/regression.gleam", 130).
?DOC(false).
-spec parse_pair(binary()) -> {ok, {binary(), binary()}} | {error, nil}.
parse_pair(Line) ->
    case gleam@string:split_once(Line, <<"="/utf8>>) of
        {ok, {Left, Right}} ->
            {ok, {gleam@string:trim(Left), gleam@string:trim(Right)}};

        {error, _} ->
            {error, nil}
    end.

-file("src/metamon/internal/regression.gleam", 125).
?DOC(false).
-spec parse_lines(binary()) -> list({binary(), binary()}).
parse_lines(Block) ->
    _pipe = gleam@string:split(Block, <<"\n"/utf8>>),
    gleam@list:filter_map(_pipe, fun parse_pair/1).

-file("src/metamon/internal/regression.gleam", 137).
?DOC(false).
-spec lookup(list({binary(), binary()}), binary()) -> {ok, binary()} |
    {error, nil}.
lookup(Pairs, Key) ->
    case Pairs of
        [] ->
            {error, nil};

        [{K, V} | Rest] ->
            case K =:= Key of
                true ->
                    {ok, V};

                false ->
                    lookup(Rest, Key)
            end
    end.

-file("src/metamon/internal/regression.gleam", 148).
?DOC(false).
-spec parse_edge(binary()) -> {ok, gleam@option:option(integer())} |
    {error, nil}.
parse_edge(Value) ->
    case Value of
        <<"none"/utf8>> ->
            {ok, none};

        Raw ->
            case gleam_stdlib:parse_int(Raw) of
                {ok, N} ->
                    {ok, {some, N}};

                {error, _} ->
                    {error, nil}
            end
    end.

-file("src/metamon/internal/regression.gleam", 159).
?DOC(false).
-spec strip_quotes(binary()) -> binary().
strip_quotes(Value) ->
    case {gleam_stdlib:string_starts_with(Value, <<"\""/utf8>>),
        gleam_stdlib:string_ends_with(Value, <<"\""/utf8>>)} of
        {true, true} ->
            _pipe = Value,
            _pipe@1 = gleam@string:drop_start(_pipe, 1),
            gleam@string:drop_end(_pipe@1, 1);

        {_, _} ->
            Value
    end.

-file("src/metamon/internal/regression.gleam", 118).
?DOC(false).
-spec lookup_note(list({binary(), binary()})) -> gleam@option:option(binary()).
lookup_note(Pairs) ->
    case lookup(Pairs, <<"note"/utf8>>) of
        {ok, Text} ->
            {some, strip_quotes(Text)};

        {error, _} ->
            none
    end.

-file("src/metamon/internal/regression.gleam", 89).
?DOC(false).
-spec build_entry(
    list({binary(), binary()}),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary()
) -> {ok, entry()} | {error, nil}.
build_entry(Pairs, Mr, Seed_str, Run_str, Size_str, Edge_str, Rec) ->
    case {gleam_stdlib:parse_int(Seed_str),
        gleam_stdlib:parse_int(Run_str),
        gleam_stdlib:parse_int(Size_str),
        parse_edge(Edge_str)} of
        {{ok, Seed_value}, {ok, Run_value}, {ok, Size_value}, {ok, Edge}} ->
            {ok,
                {entry,
                    strip_quotes(Mr),
                    Seed_value,
                    Run_value,
                    Size_value,
                    Edge,
                    lookup_note(Pairs),
                    strip_quotes(Rec)}};

        {_, _, _, _} ->
            {error, nil}
    end.

-file("src/metamon/internal/regression.gleam", 74).
?DOC(false).
-spec parse_block_body(list({binary(), binary()})) -> {ok, entry()} |
    {error, nil}.
parse_block_body(Pairs) ->
    case {lookup(Pairs, <<"mr"/utf8>>),
        lookup(Pairs, <<"config_seed"/utf8>>),
        lookup(Pairs, <<"run_index"/utf8>>),
        lookup(Pairs, <<"size"/utf8>>),
        lookup(Pairs, <<"edge_index"/utf8>>),
        lookup(Pairs, <<"recorded"/utf8>>)} of
        {{ok, Mr},
            {ok, Seed_str},
            {ok, Run_str},
            {ok, Size_str},
            {ok, Edge_str},
            {ok, Rec}} ->
            build_entry(Pairs, Mr, Seed_str, Run_str, Size_str, Edge_str, Rec);

        {_, _, _, _, _, _} ->
            {error, nil}
    end.

-file("src/metamon/internal/regression.gleam", 67).
?DOC(false).
-spec parse_block(binary()) -> {ok, entry()} | {error, nil}.
parse_block(Raw) ->
    case gleam@string:trim(Raw) of
        <<""/utf8>> ->
            {error, nil};

        Trimmed ->
            parse_block_body(parse_lines(Trimmed))
    end.

-file("src/metamon/internal/regression.gleam", 62).
?DOC(false).
-spec parse(binary()) -> list(entry()).
parse(Contents) ->
    _pipe = gleam@string:split(Contents, <<"[[failures]]"/utf8>>),
    gleam@list:filter_map(_pipe, fun parse_block/1).

-file("src/metamon/internal/regression.gleam", 169).
?DOC(false).
-spec escape_string(binary()) -> binary().
escape_string(Value) ->
    <<<<"\""/utf8,
            (gleam@string:replace(Value, <<"\""/utf8>>, <<"\\\""/utf8>>))/binary>>/binary,
        "\""/utf8>>.

-file("src/metamon/internal/regression.gleam", 28).
?DOC(false).
-spec render(entry()) -> binary().
render(Entry) ->
    Edge_part = case erlang:element(6, Entry) of
        none ->
            <<"edge_index = none"/utf8>>;

        {some, I} ->
            <<"edge_index = "/utf8, (erlang:integer_to_binary(I))/binary>>
    end,
    Note_part = case erlang:element(7, Entry) of
        none ->
            <<""/utf8>>;

        {some, Text} ->
            <<"\nnote        = "/utf8, (escape_string(Text))/binary>>
    end,
    erlang:list_to_binary(
        [<<"[[failures]]\n"/utf8>>,
            <<"mr          = "/utf8>>,
            escape_string(erlang:element(2, Entry)),
            <<"\n"/utf8>>,
            <<"config_seed = "/utf8>>,
            erlang:integer_to_binary(erlang:element(3, Entry)),
            <<"\n"/utf8>>,
            <<"run_index   = "/utf8>>,
            erlang:integer_to_binary(erlang:element(4, Entry)),
            <<"\n"/utf8>>,
            <<"size        = "/utf8>>,
            erlang:integer_to_binary(erlang:element(5, Entry)),
            <<"\n"/utf8>>,
            Edge_part,
            Note_part,
            <<"\nrecorded    = "/utf8>>,
            escape_string(erlang:element(8, Entry)),
            <<"\n"/utf8>>]
    ).