-module(caffeine_query_language@resolver).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_query_language/resolver.gleam").
-export([comparator_to_string/1, resolve_primitives/1]).
-export_type([primitives/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.

-type primitives() :: {good_over_total,
        caffeine_query_language@ast:exp(caffeine_query_language@ast:cql_parsed()),
        caffeine_query_language@ast:exp(caffeine_query_language@ast:cql_parsed())} |
    {time_slice,
        caffeine_query_language@ast:comparator(),
        integer(),
        float(),
        binary()}.

-file("src/caffeine_query_language/resolver.gleam", 23).
?DOC(false).
-spec comparator_to_string(caffeine_query_language@ast:comparator()) -> binary().
comparator_to_string(Comparator) ->
    case Comparator of
        less_than ->
            <<"\"<\""/utf8>>;

        less_than_or_equal_to ->
            <<"\"<=\""/utf8>>;

        greater_than ->
            <<"\">\""/utf8>>;

        greater_than_or_equal_to ->
            <<"\">=\""/utf8>>
    end.

-file("src/caffeine_query_language/resolver.gleam", 65).
?DOC(" Checks if an expression contains a time_slice expression anywhere.\n").
-spec contains_time_slice(caffeine_query_language@ast:exp(any())) -> boolean().
contains_time_slice(Exp) ->
    case Exp of
        {time_slice_expr, _} ->
            true;

        {operator_expr, Left, Right, _} ->
            contains_time_slice(Left) orelse contains_time_slice(Right);

        {primary, {primary_exp, Inner}} ->
            contains_time_slice(Inner);

        {primary, {primary_word, _}} ->
            false
    end.

-file("src/caffeine_query_language/resolver.gleam", 36).
?DOC(false).
-spec resolve_primitives(
    caffeine_query_language@ast:exp(caffeine_query_language@ast:cql_parsed())
) -> {ok, primitives()} | {error, caffeine_lang@errors:compilation_error()}.
resolve_primitives(Exp) ->
    case Exp of
        {operator_expr, Left, Right, 'div'} ->
            gleam@bool:guard(
                contains_time_slice(Left) orelse contains_time_slice(Right),
                {error,
                    caffeine_lang@errors:cql_resolver_error(
                        <<"time_slice cannot be used as an operand. It must be the entire expression."/utf8>>
                    )},
                fun() -> {ok, {good_over_total, Left, Right}} end
            );

        {time_slice_expr, Spec} ->
            {ok,
                {time_slice,
                    erlang:element(3, Spec),
                    erlang:trunc(erlang:element(5, Spec)),
                    erlang:element(4, Spec),
                    erlang:element(2, Spec)}};

        _ ->
            {error,
                caffeine_lang@errors:cql_resolver_error(
                    <<"Invalid expression. Expected a top level division operator or time_slice."/utf8>>
                )}
    end.