pokemon_names

-module(pokemon).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pokemon.gleam").
-export([language_id/1, get_all/0, get_pokemon/2, get_random/0, get_random_with_lang/1, get_name/1, get_name_with_lang/2, main/0]).
-export_type([pokemon_error/0, language/0, pokemon/0]).

-type pokemon_error() :: read_error |
    parse_error |
    invalid_row |
    invalid_int |
    not_found.

-type language() :: japanese |
    japanese_romanized |
    korean |
    chinese |
    french |
    german |
    spanish |
    italian |
    english.

-type pokemon() :: {pokemon, integer(), integer(), binary(), binary()}.

-file("src/pokemon.gleam", 38).
-spec table_atom(binary()) -> gleam@erlang@atom:atom_().
table_atom(Name) ->
    erlang:binary_to_atom(Name).

-file("src/pokemon.gleam", 42).
-spec ets_exists(gleam@erlang@atom:atom_()) -> boolean().
ets_exists(Name) ->
    _pipe = ets:info(Name, erlang:binary_to_atom(<<"size"/utf8>>)),
    erlang:is_integer(_pipe).

-file("src/pokemon.gleam", 145).
-spec language_id(language()) -> integer().
language_id(Lang) ->
    case Lang of
        japanese ->
            1;

        japanese_romanized ->
            2;

        korean ->
            3;

        chinese ->
            4;

        french ->
            5;

        german ->
            6;

        spanish ->
            7;

        italian ->
            8;

        english ->
            9
    end.

-file("src/pokemon.gleam", 163).
-spec row_to_pokemon(list(binary()), list(binary())) -> {ok, pokemon()} |
    {error, pokemon_error()}.
row_to_pokemon(Row, _) ->
    case Row of
        [Species_id_str, Lang_id_str, Name, Genus] ->
            case {gleam_stdlib:parse_int(Species_id_str),
                gleam_stdlib:parse_int(Lang_id_str)} of
                {{ok, Species_id}, {ok, Local_language_id}} ->
                    {ok, {pokemon, Species_id, Local_language_id, Name, Genus}};

                {_, _} ->
                    {error, invalid_int}
            end;

        _ ->
            {error, invalid_row}
    end.

-file("src/pokemon.gleam", 180).
-spec sequence_results(list({ok, ORA} | {error, ORB})) -> {ok, list(ORA)} |
    {error, ORB}.
sequence_results(Results) ->
    _pipe = gleam@list:fold(
        Results,
        {ok, []},
        fun(Acc, Next) -> case {Acc, Next} of
                {{ok, Xs}, {ok, X}} ->
                    {ok, [X | Xs]};

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

                {_, {error, E@1}} ->
                    {error, E@1}
            end end
    ),
    gleam@result:map(_pipe, fun lists:reverse/1).

-file("src/pokemon.gleam", 191).
-spec parse_header(list(binary())) -> {ok, nil} | {error, pokemon_error()}.
parse_header(Header) ->
    case Header of
        [<<"pokemon_species_id"/utf8>>,
            <<"local_language_id"/utf8>>,
            <<"name"/utf8>>,
            <<"genus"/utf8>>] ->
            {ok, nil};

        _ ->
            {error, parse_error}
    end.

-file("src/pokemon.gleam", 198).
-spec data_rows_to_pokemon(list(list(binary())), list(binary())) -> {ok,
        list(pokemon())} |
    {error, pokemon_error()}.
data_rows_to_pokemon(Data_rows, Langs) ->
    _pipe = Data_rows,
    _pipe@1 = gleam@list:map(_pipe, fun(Row) -> row_to_pokemon(Row, Langs) end),
    sequence_results(_pipe@1).

-file("src/pokemon.gleam", 207).
-spec rows_to_pokemon(list(list(binary()))) -> {ok, list(pokemon())} |
    {error, pokemon_error()}.
rows_to_pokemon(Rows) ->
    case Rows of
        [] ->
            {ok, []};

        [Header | Data_rows] ->
            case parse_header(Header) of
                {error, E} ->
                    {error, E};

                {ok, _} ->
                    data_rows_to_pokemon(Data_rows, [])
            end
    end.

-file("src/pokemon.gleam", 221).
-spec parse_csv(binary()) -> {ok, list(pokemon())} | {error, pokemon_error()}.
parse_csv(Contents) ->
    _pipe = gsv:to_lists(Contents, <<","/utf8>>),
    _pipe@1 = gleam@result:map_error(_pipe, fun(_) -> parse_error end),
    gleam@result:'try'(_pipe@1, fun rows_to_pokemon/1).

-file("src/pokemon.gleam", 111).
-spec get_all_from_csv() -> {ok, list(pokemon())} | {error, pokemon_error()}.
get_all_from_csv() ->
    case simplifile:read(<<"data/pokemon.csv"/utf8>>) of
        {ok, Contents} ->
            parse_csv(Contents);

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

-file("src/pokemon.gleam", 118).
-spec get_all_from_ets() -> {ok, list(pokemon())} | {error, pokemon_error()}.
get_all_from_ets() ->
    case ets:lookup(
        table_atom(<<"pokemon_all"/utf8>>),
        erlang:binary_to_atom(<<"all"/utf8>>)
    ) of
        [{_, All}] ->
            {ok, All};

        _ ->
            {error, not_found}
    end.

-file("src/pokemon.gleam", 85).
-spec populate_tables(list(pokemon())) -> nil.
populate_tables(All) ->
    By_key = table_atom(<<"pokemon_by_key"/utf8>>),
    _pipe = All,
    gleam@list:each(
        _pipe,
        fun(P) ->
            Key = {erlang:element(2, P), erlang:element(3, P)},
            _ = ets:insert(By_key, {Key, P}),
            nil
        end
    ),
    _ = ets:insert(
        table_atom(<<"pokemon_all"/utf8>>),
        {erlang:binary_to_atom(<<"all"/utf8>>), All}
    ),
    Langs = [1, 2, 3, 4, 5, 6, 7, 8, 9],
    _pipe@1 = Langs,
    gleam@list:each(
        _pipe@1,
        fun(Lang_id) ->
            Filtered = begin
                _pipe@2 = All,
                gleam@list:filter(
                    _pipe@2,
                    fun(P@1) -> erlang:element(3, P@1) =:= Lang_id end
                )
            end,
            _ = ets:insert(
                table_atom(<<"pokemon_by_lang"/utf8>>),
                {erlang:binary_to_atom(erlang:integer_to_binary(Lang_id)),
                    Filtered}
            ),
            nil
        end
    ).

-file("src/pokemon.gleam", 47).
-spec ensure_loaded() -> {ok, nil} | {error, pokemon_error()}.
ensure_loaded() ->
    By_key = table_atom(<<"pokemon_by_key"/utf8>>),
    case ets_exists(By_key) of
        true ->
            {ok, nil};

        false ->
            _ = ets:new(
                By_key,
                [erlang:binary_to_atom(<<"named_table"/utf8>>),
                    erlang:binary_to_atom(<<"set"/utf8>>),
                    erlang:binary_to_atom(<<"public"/utf8>>)]
            ),
            _ = ets:new(
                table_atom(<<"pokemon_all"/utf8>>),
                [erlang:binary_to_atom(<<"named_table"/utf8>>),
                    erlang:binary_to_atom(<<"set"/utf8>>),
                    erlang:binary_to_atom(<<"public"/utf8>>)]
            ),
            _ = ets:new(
                table_atom(<<"pokemon_by_lang"/utf8>>),
                [erlang:binary_to_atom(<<"named_table"/utf8>>),
                    erlang:binary_to_atom(<<"set"/utf8>>),
                    erlang:binary_to_atom(<<"public"/utf8>>)]
            ),
            rand:seed(erlang:binary_to_atom(<<"exsplus"/utf8>>)),
            _pipe = get_all_from_csv(),
            gleam@result:map(
                _pipe,
                fun(All) ->
                    populate_tables(All),
                    nil
                end
            )
    end.

-file("src/pokemon.gleam", 227).
-spec get_all() -> {ok, list(pokemon())} | {error, pokemon_error()}.
get_all() ->
    _pipe = ensure_loaded(),
    gleam@result:'try'(_pipe, fun(_) -> get_all_from_ets() end).

-file("src/pokemon.gleam", 232).
-spec get_pokemon(integer(), language()) -> {ok, pokemon()} |
    {error, pokemon_error()}.
get_pokemon(Id, Lang) ->
    _pipe = ensure_loaded(),
    gleam@result:'try'(
        _pipe,
        fun(_) ->
            Lang_id = language_id(Lang),
            Key = {Id, Lang_id},
            case ets:lookup(table_atom(<<"pokemon_by_key"/utf8>>), Key) of
                [{_, Pokemon}] ->
                    {ok, Pokemon};

                _ ->
                    {error, not_found}
            end
        end
    ).

-file("src/pokemon.gleam", 245).
-spec get_random() -> {ok, pokemon()} | {error, pokemon_error()}.
get_random() ->
    _pipe = ensure_loaded(),
    gleam@result:'try'(_pipe, fun(_) -> _pipe@1 = get_all_from_ets(),
            gleam@result:'try'(_pipe@1, fun(All) -> case All of
                        [] ->
                            {error, not_found};

                        _ ->
                            Idx = rand:uniform(erlang:length(All)) - 1,
                            case gleam@list:drop(All, Idx) of
                                [Pokemon | _] ->
                                    {ok, Pokemon};

                                _ ->
                                    {error, not_found}
                            end
                    end end) end).

-file("src/pokemon.gleam", 264).
-spec get_random_with_lang(language()) -> {ok, pokemon()} |
    {error, pokemon_error()}.
get_random_with_lang(Lang) ->
    _pipe = ensure_loaded(),
    gleam@result:'try'(
        _pipe,
        fun(_) ->
            Lang_id = language_id(Lang),
            case ets:lookup(
                table_atom(<<"pokemon_by_lang"/utf8>>),
                erlang:binary_to_atom(erlang:integer_to_binary(Lang_id))
            ) of
                [{_, Filtered}] ->
                    case Filtered of
                        [] ->
                            {error, not_found};

                        _ ->
                            Idx = rand:uniform(erlang:length(Filtered)) - 1,
                            case gleam@list:drop(Filtered, Idx) of
                                [Pokemon | _] ->
                                    {ok, Pokemon};

                                _ ->
                                    {error, not_found}
                            end
                    end;

                _ ->
                    {error, not_found}
            end
        end
    ).

-file("src/pokemon.gleam", 289).
-spec get_name(integer()) -> {ok, binary()} | {error, pokemon_error()}.
get_name(Id) ->
    _pipe = get_pokemon(Id, english),
    gleam@result:map(_pipe, fun(Pokemon) -> erlang:element(4, Pokemon) end).

-file("src/pokemon.gleam", 294).
-spec get_name_with_lang(integer(), language()) -> {ok, binary()} |
    {error, pokemon_error()}.
get_name_with_lang(Id, Lang) ->
    _pipe = get_pokemon(Id, Lang),
    gleam@result:map(_pipe, fun(Pokemon) -> erlang:element(4, Pokemon) end).

-file("src/pokemon.gleam", 302).
-spec main() -> nil.
main() ->
    case get_all() of
        {ok, Pokemon} ->
            gleam_stdlib:println(gleam@string:inspect(Pokemon));

        {error, _} ->
            gleam_stdlib:println(<<"Failed to read data.csv"/utf8>>)
    end.