metamon

-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([render/1, version_header/0, parse_with_version/1, parse/1]).
-export_type([parse_error/0, 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 parse_error() :: {unsupported_schema_version, integer()} |
    {malformed_schema_version, binary()}.

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

-file("src/metamon/internal/regression.gleam", 152).
?DOC(false).
-spec version_value_of(binary()) -> gleam@option:option(binary()).
version_value_of(Line) ->
    case gleam@string:split_once(Line, <<"="/utf8>>) of
        {ok, {Key, Value}} ->
            case gleam@string:trim(Key) =:= <<"schema_version"/utf8>> of
                true ->
                    {some, gleam@string:trim(Value)};

                false ->
                    none
            end;

        {error, _} ->
            none
    end.

-file("src/metamon/internal/regression.gleam", 145).
?DOC(false).
-spec extract_version_line(binary()) -> gleam@option:option(binary()).
extract_version_line(Contents) ->
    case gleam@string:split_once(Contents, <<"\n"/utf8>>) of
        {ok, {First, _}} ->
            version_value_of(gleam@string:trim(First));

        {error, _} ->
            version_value_of(gleam@string:trim(Contents))
    end.

-file("src/metamon/internal/regression.gleam", 163).
?DOC(false).
-spec parse_version_value(binary()) -> {ok, integer()} | {error, nil}.
parse_version_value(Raw) ->
    gleam_stdlib:parse_int(Raw).

-file("src/metamon/internal/regression.gleam", 230).
?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", 225).
?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", 237).
?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", 248).
?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", 259).
?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", 218).
?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", 189).
?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", 174).
?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", 167).
?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", 269).
?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", 64).
?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>>]
    ).

-file("src/metamon/internal/regression.gleam", 126).
?DOC(false).
-spec version_header() -> binary().
version_header() ->
    <<"schema_version = "/utf8, (erlang:integer_to_binary(1))/binary>>.

-file("src/metamon/internal/regression.gleam", 130).
?DOC(false).
-spec check_schema_version(binary()) -> {ok, nil} | {error, parse_error()}.
check_schema_version(Contents) ->
    case extract_version_line(Contents) of
        none ->
            {ok, nil};

        {some, Raw} ->
            case parse_version_value(Raw) of
                {ok, N} ->
                    case N =:= 1 of
                        true ->
                            {ok, nil};

                        false ->
                            {error, {unsupported_schema_version, N}}
                    end;

                {error, _} ->
                    {error, {malformed_schema_version, Raw}}
            end
    end.

-file("src/metamon/internal/regression.gleam", 104).
?DOC(false).
-spec parse_with_version(binary()) -> {ok, list(entry())} |
    {error, parse_error()}.
parse_with_version(Contents) ->
    gleam@result:'try'(
        check_schema_version(Contents),
        fun(_) ->
            {ok,
                begin
                    _pipe = gleam@string:split(
                        Contents,
                        <<"[[failures]]"/utf8>>
                    ),
                    gleam@list:filter_map(_pipe, fun parse_block/1)
                end}
        end
    ).

-file("src/metamon/internal/regression.gleam", 116).
?DOC(false).
-spec parse(binary()) -> list(entry()).
parse(Contents) ->
    case parse_with_version(Contents) of
        {ok, Entries} ->
            Entries;

        {error, _} ->
            []
    end.