%% @author Marc Worrell <marc@worrell.nl>
%% @copyright 2016-2023 Marc Worrell
%% @doc Compile expressions to erl_syntax trees.
%% @end

%% Copyright 2016-2023 Marc Worrell
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%% 
%%     http://www.apache.org/licenses/LICENSE-2.0
%% 
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.

-module(template_compiler_expr).
-author('Marc Worrell <marc@worrell.nl>').

-export([
    compile/3
    ]).

-include_lib("syntax_tools/include/merl.hrl").
-include("template_compiler_internal.hrl").


-spec compile(element(), #cs{}, #ws{}) -> {#ws{}, erl_syntax:syntaxTree()}.
compile({ast, Ast}, _CState, Ws) ->
    {Ws, Ast};
compile(true, _CState, Ws) ->
    {Ws, erl_syntax:atom(true)};
compile(false, _CState, Ws) ->
    {Ws, erl_syntax:atom(false)};
compile(undefined, _CState, Ws) ->
    {Ws, erl_syntax:atom(undefined)};
compile({string_literal, SrcPos, Text}, _CState, Ws) when is_binary(Text) ->
    {Ws, template_compiler_utils:set_pos(SrcPos, erl_syntax:abstract(Text))};
compile({trans_literal, SrcPos, {trans, _} = Tr}, #cs{runtime=Runtime} = CState, Ws) ->
    Ast = erl_syntax:application(
            erl_syntax:atom(Runtime),
            erl_syntax:atom(lookup_translation),
            [
                erl_syntax:abstract(Tr),
                erl_syntax:variable(CState#cs.vars_var),
                erl_syntax:variable(CState#cs.context_var)
            ]),
    {Ws, template_compiler_utils:set_pos(SrcPos, Ast)};
compile({number_literal, _SrcPos, Nr}, _CState, Ws) ->
    {Ws, erl_syntax:abstract(z_convert:to_integer(Nr))};
compile({atom_literal, _SrcPos, Atom}, _CState, Ws) ->
    {Ws, erl_syntax:abstract(template_compiler_utils:to_atom(Atom))};
compile({find_value, LookupList}, CState, Ws) ->
    find_value_lookup(LookupList, CState, Ws);
compile({auto_id, {{identifier, SrcPos, Name}, {identifier, _, Var}}}, #cs{runtime=Runtime} = CState, Ws) ->
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "iolist_to_binary([ "
                "maps:get('$autoid', _@vars),"
                "$-, _@name,"
                "$-, z_convert:to_binary("
                        "_@runtime:find_value(_@varname, _@vars, _@vars, _@context)"
                    ")"
            "])",
            [
                {runtime, erl_syntax:atom(Runtime)},
                {name, erl_syntax:abstract(Name)},
                {varname, erl_syntax:atom(template_compiler_utils:to_atom(Var))},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {vars, erl_syntax:variable(CState#cs.vars_var)}
            ]),
    {Ws#ws{is_autoid_var=true}, Ast};
compile({auto_id, {identifier, SrcPos, Name}}, #cs{vars_var=Vars}, Ws) ->
    Ast = merl:qquote(
                template_compiler_utils:pos(SrcPos),
                "iolist_to_binary([ maps:get('$autoid', _@vars), $-, _@name ])",
                [
                    {name, erl_syntax:abstract(Name)},
                    {vars, erl_syntax:variable(Vars)}
                ]),
    {Ws#ws{is_autoid_var=true}, Ast};
compile({map_value, Args}, Cs, Ws) ->
    {WsProps, PropsAst} = mapfields_ast(Args, Cs, Ws),
    Ast = erl_syntax:map_expr(PropsAst),
    {WsProps, Ast};
compile({tuple_value, {identifier, _, Name}, Args}, Cs, Ws) ->
    TupleName = erl_syntax:atom(template_compiler_utils:to_atom(Name)),
    {WsProps, PropsAst} = proplist_ast(Args, Cs, Ws),
    Ast = ?Q("{ _@TupleName, _@PropsAst }"),
    {WsProps, Ast};
compile({value_list, Exprs}, Cs, Ws) ->
    list_ast(Exprs, Cs, Ws);
compile({expr, {Op, {_, SrcPos, _}}, Arg}, #cs{runtime=Runtime} = CState, Ws) when is_atom(Op) ->
    {Ws1, ArgAst} = compile(Arg, CState, Ws),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "template_compiler_operators:_@op(_@args, _@runtime, _@context)",
            [
                {op, erl_syntax:abstract(Op)},
                {args, ArgAst},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {runtime, erl_syntax:atom(Runtime)}
            ]),
    {Ws1, Ast};
compile({expr, {'or', {_, SrcPos, _}}, Arg1, Arg2}, #cs{runtime=Runtime} = CState, Ws) ->
    {Ws1, Arg1Ast} = compile(Arg1, CState, Ws),
    {Ws2, Arg2Ast} = compile(Arg2, CState, Ws1),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "case _@runtime:to_bool(_@runtime:to_simple_value(_@arg1, _@context), _@context) of "
            "  true -> true; "
            "  false -> _@runtime:to_bool(_@runtime:to_simple_value(_@arg2, _@context), _@context) "
            "end",
            [
                {arg1, Arg1Ast},
                {arg2, Arg2Ast},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {runtime, erl_syntax:atom(Runtime)}
            ]),
    {Ws2, Ast};
compile({expr, {'and', {_, SrcPos, _}}, Arg1, Arg2}, #cs{runtime=Runtime} = CState, Ws) ->
    {Ws1, Arg1Ast} = compile(Arg1, CState, Ws),
    {Ws2, Arg2Ast} = compile(Arg2, CState, Ws1),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "case _@runtime:to_bool(_@runtime:to_simple_value(_@arg1, _@context), _@context) of "
            "  true -> _@runtime:to_bool(_@runtime:to_simple_value(_@arg2, _@context), _@context); "
            "  false -> false "
            "end",
            [
                {arg1, Arg1Ast},
                {arg2, Arg2Ast},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {runtime, erl_syntax:atom(Runtime)}
            ]),
    {Ws2, Ast};
compile({expr, {Op, {_, SrcPos, _}}, Arg1, Arg2}, #cs{runtime=Runtime} = CState, Ws) when is_atom(Op) ->
    {Ws1, Arg1Ast} = compile(Arg1, CState, Ws),
    {Ws2, Arg2Ast} = compile(Arg2, CState, Ws1),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "template_compiler_operators:_@op(_@arg1, _@arg2, _@runtime, _@context)",
            [
                {op, erl_syntax:abstract(Op)},
                {arg1, Arg1Ast},
                {arg2, Arg2Ast},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {runtime, erl_syntax:atom(Runtime)}
            ]),
    {Ws2, Ast};
compile({apply_filter, Expr, {filter, {identifier, SrcPos, <<"default">>}, [Arg]}}, CState, Ws) ->
    filter_default(Expr, Arg, SrcPos, CState, Ws);
compile({apply_filter, Expr, {filter, {identifier, SrcPos, <<"default_if_none">>}, [Arg]}}, CState, Ws) ->
    filter_default_if_none(Expr, Arg, SrcPos, CState, Ws);
compile({apply_filter, Expr, {filter, {identifier, SrcPos, <<"default_if_undefined">>}, [Arg]}}, CState, Ws) ->
    filter_default_if_none(Expr, Arg, SrcPos, CState, Ws);
compile({apply_filter, Expr, {filter, {identifier, SrcPos, Filter}, FilterArgs}}, CState, Ws) ->
    FilterName = template_compiler_utils:to_atom(Filter),
    FilterModule = template_compiler_utils:to_atom(<<"filter_", Filter/binary>>),
    {Ws1, ExprAst} = compile(Expr, CState, Ws),
    {Ws2, AstList} = list_1(FilterArgs, CState, Ws1, []),
    Args = [ExprAst | AstList ] ++ [erl_syntax:variable(CState#cs.context_var)],
    Ast = template_compiler_utils:set_pos(
                SrcPos,
                erl_syntax:application(
                         erl_syntax:atom(FilterModule),
                         erl_syntax:atom(FilterName),
                         Args)),
    {Ws2, Ast};
compile({model, [{identifier, SrcPos, Model} | Path ], OptPayload}, #cs{runtime=Runtime, vars_var=Vars} = CState, Ws) ->
    {Ws1, PathAsts} = value_lookup_asts(Path, CState, Ws, []),
    {Ws2, PayloadAst} = case OptPayload of
        none -> {Ws1, erl_syntax:abstract(undefined)};
        Expr -> compile(Expr, CState, Ws1)
    end,
    {Ws3, V1} = template_compiler_utils:var(Ws2),
    {Ws4, V2} = template_compiler_utils:var(Ws3),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "case _@runtime:model_call(_@model, _@path, _@payload, _@context) of "
            "  {ok, {_@v1, []}} -> _@v1;"
            "  {ok, {_@v1, _@v2}} when is_list(_@v2) -> "
            "       _@runtime:find_nested_value(_@v1, _@v2, _@vars, _@context); "
            "  {error, _} -> undefined "
            "end",
            [
                {model, erl_syntax:atom(binary_to_atom(Model, 'utf8'))},
                {path, erl_syntax:list(PathAsts)},
                {payload, PayloadAst},
                {v1, erl_syntax:variable(V1)},
                {v2, erl_syntax:variable(V2)},
                {vars, erl_syntax:variable(Vars)},
                {context, erl_syntax:variable(CState#cs.context_var)},
                {runtime, erl_syntax:atom(Runtime)}
            ]),
    {Ws4, Ast}.


find_value_lookup([{identifier, SrcPos, <<"now">>}], _CState, Ws) ->
    Ast = template_compiler_utils:set_pos(
            SrcPos,
            erl_syntax:application(
                 erl_syntax:atom(erlang),
                 erl_syntax:atom(universaltime),
                 [])),
    {Ws, Ast};
find_value_lookup([{identifier, SrcPos, <<"true">>}], _CState, Ws) ->
    {Ws, template_compiler_utils:set_pos(SrcPos, erl_syntax:atom(true))};
find_value_lookup([{identifier, SrcPos, <<"false">>}], _CState, Ws) ->
    {Ws, template_compiler_utils:set_pos(SrcPos, erl_syntax:atom(false))};
find_value_lookup([{identifier, SrcPos, <<"undefined">>}], _CState, Ws) ->
    {Ws, template_compiler_utils:set_pos(SrcPos, erl_syntax:atom(undefined))};
find_value_lookup([
            {identifier, SrcPos, <<"forloop">>},
            {identifier, _, Key}
        ], #cs{runtime=Runtime, vars_var=Vars} = CState, Ws) ->
    Ws1 = Ws#ws{is_forloop_var=true},
    ValueLookupAsts = [
        erl_syntax:atom(forloop),
        erl_syntax:atom(binary_to_atom(Key, utf8))
    ],
    Ast = merl:qquote(
            erl_syntax:get_pos(SrcPos),
            "_@runtime:find_nested_value(_@list, _@vars, _@context)",
            [
                {runtime, erl_syntax:atom(Runtime)},
                {list, erl_syntax:list(ValueLookupAsts)},
                {vars, erl_syntax:variable(Vars)},
                {context, erl_syntax:variable(CState#cs.context_var)}
            ]),
    {Ws1, Ast};
find_value_lookup([{_, SrcPos, _}|_] = ValueLookup, #cs{runtime=Runtime, vars_var=Vars} = CState, Ws) ->
    case Runtime:compile_map_nested_value(ValueLookup, CState#cs.context_var, CState#cs.context) of
        [{mfa, M, F, As}] ->
            {Ws1, ValueLookupAsts} = value_lookup_asts(As, CState, Ws, []),
            {Ws2, V1} = template_compiler_utils:var(Ws1),
            {Ws3, V2} = template_compiler_utils:var(Ws2),
            Ast = merl:qquote(
                    template_compiler_utils:pos(SrcPos),
                    "case _@module:_@func(_@mfargs, _@context) of "
                    "  {ok, {_@v1, []}} -> _@v1;"
                    "  {ok, {_@v1, _@v2}} when is_list(_@v2) -> "
                    "       _@runtime:find_nested_value(_@v1, _@v2, _@vars, _@context); "
                    "  {error, _} -> undefined "
                    "end",
                    [
                        {module, erl_syntax:atom(M)},
                        {func, erl_syntax:atom(F)},
                        {mfargs, erl_syntax:list(ValueLookupAsts)},
                        {v1, erl_syntax:variable(V1)},
                        {v2, erl_syntax:variable(V2)},
                        {runtime, erl_syntax:atom(Runtime)},
                        {vars, erl_syntax:variable(Vars)},
                        {context, erl_syntax:variable(CState#cs.context_var)}
                    ]),
            {Ws3, Ast};
        [{mfa2, M, F, As, ExtraArg}] ->
            {Ws1, ValueLookupAsts} = value_lookup_asts(As, CState, Ws, []),
            {Ws2, V1} = template_compiler_utils:var(Ws1),
            {Ws3, V2} = template_compiler_utils:var(Ws2),
            Ast = merl:qquote(
                    template_compiler_utils:pos(SrcPos),
                    "case _@module:_@func(_@mfargs, _@extra, _@context) of "
                    "  {ok, {_@v1, []}} -> _@v1;"
                    "  {ok, {_@v1, _@v2}} when is_list(_@v2) -> "
                    "       _@runtime:find_nested_value(_@v1, _@v2, _@vars, _@context); "
                    "  {error, _} -> undefined "
                    "end",
                    [
                        {module, erl_syntax:atom(M)},
                        {func, erl_syntax:atom(F)},
                        {mfargs, erl_syntax:list(ValueLookupAsts)},
                        {extra, erl_syntax:abstract(ExtraArg)},
                        {v1, erl_syntax:variable(V1)},
                        {v2, erl_syntax:variable(V2)},
                        {runtime, erl_syntax:atom(Runtime)},
                        {vars, erl_syntax:variable(Vars)},
                        {context, erl_syntax:variable(CState#cs.context_var)}
                    ]),
            {Ws3, Ast};
        [{ast, Ast}] ->
            {Ws, Ast};
        [{ast, Ast} | ValueLookup1 ] ->
            {Ws1, ValueLookupAsts} = value_lookup_asts(ValueLookup1, CState, Ws, []),
            Ast1 = merl:qquote(
                    erl_syntax:get_pos(hd(ValueLookupAsts)),
                    "_@runtime:find_nested_value(_@list, _@vars, _@context)",
                    [
                        {runtime, erl_syntax:atom(Runtime)},
                        {list, erl_syntax:list(ValueLookupAsts)},
                        {vars, Ast},
                        {context, erl_syntax:variable(CState#cs.context_var)}
                    ]),
            {Ws1, Ast1};
        [{identifier, SrcPosIdn, Var}] ->
            VarName = template_compiler_utils:to_atom(Var),
            Ast = merl:qquote(
                    template_compiler_utils:pos(SrcPosIdn),
                    "_@runtime:find_value(_@varname, _@vars, _@vars, _@context)",
                    [
                        {runtime, erl_syntax:atom(Runtime)},
                        {varname, erl_syntax:atom(VarName)},
                        {vars, erl_syntax:variable(Vars)},
                        {context, erl_syntax:variable(CState#cs.context_var)}
                    ]),
            {Ws, Ast};
        ValueLookup1 ->
            {Ws1, ValueLookupAsts} = value_lookup_asts(ValueLookup1, CState, Ws, []),
            Ast = merl:qquote(
                    erl_syntax:get_pos(hd(ValueLookupAsts)),
                    "_@runtime:find_nested_value(_@list, _@vars, _@context)",
                    [
                        {runtime, erl_syntax:atom(Runtime)},
                        {list, erl_syntax:list(ValueLookupAsts)},
                        {vars, erl_syntax:variable(Vars)},
                        {context, erl_syntax:variable(CState#cs.context_var)}
                    ]),
            {Ws1, Ast}
    end.

value_lookup_asts([], _CState, Ws, Acc) ->
    {Ws, lists:reverse(Acc)};
value_lookup_asts([{identifier, _, Var}|Vs], CState, Ws, Acc) ->
    value_lookup_asts(Vs, CState, Ws, [erl_syntax:abstract(Var)|Acc]);
value_lookup_asts([{ast, Ast}|Vs], CState, Ws, Acc) ->
    value_lookup_asts(Vs, CState, Ws, [Ast|Acc]);
value_lookup_asts([{expr, Expr}|Vs], CState, Ws, Acc) ->
    {Ws1, ExprAst} = compile(Expr, CState, Ws),
    value_lookup_asts(Vs, CState, Ws1, [ExprAst|Acc]).


filter_default(Expr, Arg, SrcPos, #cs{runtime=Runtime} = CState, Ws) ->
    {Ws1, ExprAst} = compile(Expr, CState, Ws),
    {Ws2, ArgAst} = compile(Arg, CState, Ws1),
    {Ws3, V} = template_compiler_utils:var(Ws2),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "begin "
                "_@v = _@expr,"
                "case _@runtime:to_bool(_@v, _@context) of "
                    "false -> _@arg;"
                    "true -> _@v "
                "end "
            "end",
            [
                {v, erl_syntax:variable(V)},
                {expr, ExprAst},
                {arg, ArgAst},
                {runtime, erl_syntax:atom(Runtime)},
                {context, erl_syntax:variable(CState#cs.context_var)}
            ]),
    {Ws3, Ast}.


filter_default_if_none(Expr, Arg, SrcPos, CState, Ws) ->
    {Ws1, ExprAst} = compile(Expr, CState, Ws),
    {Ws2, ArgAst} = compile(Arg, CState, Ws1),
    {Ws3, V} = template_compiler_utils:var(Ws2),
    Ast = merl:qquote(
            template_compiler_utils:pos(SrcPos),
            "case _@expr of undefined -> _@arg; _@v -> _@v end",
            [
                {v, erl_syntax:variable(V)},
                {expr, ExprAst},
                {arg, ArgAst}
            ]),
    {Ws3, Ast}.


list_ast(List, Cs, Ws) ->
    {Ws1, AstList} = list_1(List, Cs, Ws, []),
    {Ws1, erl_syntax:list(AstList)}.

list_1([], _Cs, Ws, Acc) ->
    {Ws, lists:reverse(Acc)};
list_1([Expr|List], Cs, Ws, Acc) ->
    {Ws1, Ast} = compile(Expr, Cs, Ws),
    list_1(List, Cs, Ws1, [Ast|Acc]).


proplist_ast(Args, Cs, Ws) ->
    {Ws1, List} = proplist_1(Args, Cs, Ws, []),
    {Ws1, erl_syntax:list(List)}.

proplist_1([], _Cs, Ws, Acc) ->
    {Ws, lists:reverse(Acc)};
proplist_1([{{identifier, _, Arg}, Expr}|Args], Cs, Ws, Acc) ->
    ArgName = template_compiler_utils:to_atom(Arg),
    {Ws1, ExprAst} = compile(Expr, Cs, Ws),
    Ast = erl_syntax:tuple([erl_syntax:atom(ArgName), ExprAst]),
    proplist_1(Args, Cs, Ws1, [Ast|Acc]).


mapfields_ast(Args, Cs, Ws) ->
    mapfields_1(Args, Cs, Ws, []).

mapfields_1([], _Cs, Ws, Acc) ->
    {Ws, lists:reverse(Acc)};
mapfields_1([{{identifier, _, Arg}, Expr}|Args], Cs, Ws, Acc) ->
    {Ws1, ExprAst} = compile(Expr, Cs, Ws),
    Ast = erl_syntax:map_field_assoc(erl_syntax:abstract(Arg), ExprAst),
    mapfields_1(Args, Cs, Ws1, [Ast|Acc]);
mapfields_1([{{string_literal, _, Text}, Expr}|Args], Cs, Ws, Acc) ->
    {Ws1, ExprAst} = compile(Expr, Cs, Ws),
    Ast = erl_syntax:map_field_assoc(erl_syntax:abstract(Text), ExprAst),
    mapfields_1(Args, Cs, Ws1, [Ast|Acc]).