-module(nine_elli).

-export([generate/2]).

-type handler() :: {atom(), atom()}.
-type norm_route() :: {binary(), binary(), [handler()]}.
-type norm_routes() :: [norm_route()].

-spec generate(module(), norm_routes()) -> erl_parse:parse_tree().
generate(Module, Routes) ->
    {ok, Forms} = normalized_routes_to_forms(Module, Routes),
    Forms.

-spec normalized_routes_to_forms(module(), norm_routes()) -> {ok, erl_parse:parse_tree()}.
normalized_routes_to_forms(Module, NormRoutes) ->
    {ok,
     [codegen_module_form(Module)] ++ elli_exports() ++ routes_map_to_methods(NormRoutes)}.

-spec codegen_module_form(module()) -> erl_parse:erl_parse_tree().
codegen_module_form(Module) ->
    {attribute, 0, module, Module}.

-spec elli_exports() -> erl_parse:erl_parse_tree().
elli_exports() ->
    [{attribute, 0, export, [{handle, 2}, {handle_event, 3}]}].

-spec routes_map_to_methods(list()) -> list().
routes_map_to_methods(NormRoutes) ->
    codegen_handle() ++ codegen_handle_event() ++ codegen_routes(NormRoutes).

-spec codegen_handle_event() -> erl_parse:erl_parse_tree().
codegen_handle_event() ->
    [{function,
      0,
      handle_event,
      3,
      [{clause,
        0,
        [{var, 0, '_Event'}, {var, 0, '_Data'}, {var, 0, '_Args'}],
        [],
        [{atom, 0, ok}]}]}].

-spec codegen_handle() -> erl_parse:erl_parse_tree().
codegen_handle() ->
    [{function,
      0,
      handle,
      2,
      [{clause,
        0,
        [{var, 0, 'Req'}, {var, 0, '_Args'}],
        [],
        [{call,
          0,
          {atom, 0, handle},
          [{map,
            0,
            [{map_field_assoc, 0, {atom, 0, req}, {var, 0, 'Req'}},
             {map_field_assoc, 0, {atom, 0, method}, codegen_get_method()},
             {map_field_assoc, 0, {atom, 0, path}, codegen_get_path()}]}]}]}]}].

-spec codegen_get_method() -> erl_parse:erl_parse_tree().
codegen_get_method() ->
    {call, 1, {remote, 1, {atom, 1, nine_elli_util}, {atom, 1, get_method}}, [{var, 1, 'Req'}]}.

-spec codegen_get_path() -> erl_parse:erl_parse_tree().
codegen_get_path() ->
    {call, 0, {remote, 0, {atom, 0, elli_request}, {atom, 0, path}}, [{var, 0, 'Req'}]}.

-spec codegen_routes(list()) -> erl_parse:parse_tree().
codegen_routes(Routes) ->
    [{function, 0, handle, 1, lists:map(fun codegen_route/1, Routes)}].

-spec codegen_route({binary(), binary(), list()}) -> erl_parse:parse_tree().
codegen_route({Path0, Method, Middleware}) ->
    PathParsed = parse_path(Path0),
    Behavior = middleware_to_behavior(Middleware, filter_path_params(PathParsed)),
    Path = codegen_path(PathParsed),
    codegen_method_clause(Path, Method, Behavior).

-spec filter_path_params(list()) -> list().
filter_path_params(Path) ->
    lists:reverse(
        lists:foldl(fun(E, Acc) ->
                       case E of
                           all ->
                               Acc;
                           {all, Var} ->
                               [Var | Acc];
                           {_Prefix, Suffix} ->
                               [Suffix | Acc];
                           E2 when is_atom(E2) ->
                               [E2 | Acc];
                           _ ->
                               Acc
                       end
                    end,
                    [],
                    Path)).

-spec middleware_to_behavior(list(), list()) -> list().
middleware_to_behavior(Middleware, PathParams) ->
    Pp = codegen_path_params(PathParams),
    M = codegen_case_chain_init(enumerate_middleware(Middleware, 1)),
    [Pp, M].

-spec codegen_path_params(list()) -> erl_parse:parse_tree().
codegen_path_params(PathParams) ->
    {match,
     0,
     {var, 0, 'Req1'},
     {map,
      0,
      {var, 0, 'Req0'},
      [{map_field_assoc,
        0,
        {atom, 0, params},
        {map, 0, codegen_path_param_elements(PathParams)}}]}}.

-spec codegen_path_param_elements(list()) -> list().
codegen_path_param_elements(PathParams) ->
    lists:map(fun(P) ->
                 Lvar = binary_to_atom(string:lowercase(atom_to_binary(P))),
                 {map_field_assoc, 0, {atom, 0, Lvar}, {var, 0, P}}
              end,
              PathParams).

-spec enumerate_middleware([{atom(), atom()}], integer()) ->
                              [{atom(), atom(), integer()}].
enumerate_middleware(Middleware, Counter) ->
    enumerate_middleware(Middleware, [], Counter).

-spec enumerate_middleware([{atom(), atom()}],
                           [{atom(), atom(), integer()}],
                           integer()) ->
                              [{atom(), atom(), integer()}].
enumerate_middleware([], Acc, _Counter) ->
    Acc;
enumerate_middleware([{Module, Function} | Middleware], Acc, Counter) ->
    enumerate_middleware(Middleware, [{Module, Function, Counter} | Acc], Counter + 1).

-spec codegen_case_chain_init([{atom(), atom(), integer()}]) -> erl_parse:parse_tree().
codegen_case_chain_init([{Module, Function, Counter} | Rest]) ->
    codegen_case_chain(Rest,
                       codegen_case_wrapper(Module,
                                            Function,
                                            Counter,
                                            {var, 0, req_atom(Counter + 1)})).

-spec codegen_case_chain([{atom(), atom(), integer()}], erl_parse:parse_tree()) ->
                            erl_parse:parse_tree().
codegen_case_chain([], Acc) ->
    Acc;
codegen_case_chain([{Module, Function, Counter} | Mid], Acc) ->
    codegen_case_chain(Mid, codegen_case_wrapper(Module, Function, Counter, Acc)).

-spec codegen_case_wrapper(atom(), atom(), integer(), erl_parse:parse_tree()) ->
                              erl_parse:parse_tree().
codegen_case_wrapper(Module, Function, Counter, Behavior) ->
    {'case',
     0,
     codegen_handle_req(Module, Function, req_atom(Counter)),
     [{clause,
       0,
       [{map, 0, [{map_field_exact, 0, {atom, 0, resp}, {var, 0, resp_atom(Counter)}}]}],
       [],
       [{var, 0, resp_atom(Counter)}]},
      {clause, 0, [{var, 0, req_atom(Counter + 1)}], [], [Behavior]}]}.

-spec req_atom(integer()) -> atom().
req_atom(Counter) ->
    binary_to_atom(list_to_binary(["Req", integer_to_list(Counter)])).

-spec resp_atom(integer()) -> atom().
resp_atom(Counter) ->
    binary_to_atom(list_to_binary(["Resp", integer_to_list(Counter)])).

-spec codegen_handle_req(atom(), atom(), atom()) -> erl_parse:parse_tree().
codegen_handle_req(Module, Function, Req) ->
    {call, 0, {remote, 0, {atom, 0, Module}, {atom, 0, Function}}, [{var, 0, Req}]}.

-spec parse_path(binary()) ->
                    [atom() | binary() | {binary(), atom()} | {all, atom()} | all].
parse_path(Path0) ->
    [_ | Rest] = string:split(Path0, "/", all),
    lists:map(fun translate_path_param/1, Rest).

-spec translate_path_param(binary()) ->
                              binary() | atom() | {binary(), atom()} | {all, atom()} | all.
translate_path_param(<<"*">>) ->
    all;
translate_path_param(<<"*", Name/binary>>) ->
    {all, binary_to_var(Name)};
translate_path_param(S) ->
    case string:split(S, ":") of
        [_] ->
            S;
        [<<>>, Suffix] ->
            binary_to_var(Suffix);
        [Prefix, Suffix] ->
            {Prefix, binary_to_var(Suffix)}
    end.

-spec binary_to_var(binary()) -> atom().
binary_to_var(B) ->
    binary_to_atom(string:titlecase(B)).

-spec codegen_path(list()) -> erl_parse:parse_tree().
codegen_path([]) ->
    {var, 0, '_'};
codegen_path([<<>>]) ->
    {nil, 0};
codegen_path(Path) ->
    Path2 = lists:reverse(Path),
    case Path2 of
        [{all, Var} | Rest] ->
            codegen_path(Rest, {var, 0, Var});
        [all | Rest] ->
            codegen_path(Rest, {var, 0, '_'});
        _ ->
            codegen_path(Path2, {nil, 0})
    end.

-spec codegen_path(list(), erl_parse:parse_tree()) -> erl_parse:parse_tree().
codegen_path([], Acc) ->
    Acc;
codegen_path([E | Rest], Acc) ->
    codegen_path(Rest, {cons, 0, codegen_path_element(E), Acc}).

-spec codegen_path_element(binary() | atom() | {binary(), atom()}) ->
                              erl_parse:parse_tree().
codegen_path_element(E) ->
    case E of
        all ->
            {var, 0, '_'};
        {B, Var} ->
            codegen_binary_var(B, Var);
        E when is_atom(E) ->
            {var, 0, E};
        E when is_binary(E) ->
            codegen_binary(E)
    end.

-spec codegen_binary(binary()) -> erl_parse:parse_tree().
codegen_binary(B) ->
    {bin, 0, [{bin_element, 0, {string, 0, binary_to_list(B)}, default, default}]}.

-spec codegen_binary_var(binary(), atom()) -> erl_parse:parse_tree().
codegen_binary_var(B, Var) ->
    {bin,
     0,
     [{bin_element, 0, {string, 0, binary_to_list(B)}, default, default},
      {bin_element, 0, {var, 0, Var}, default, [binary]}]}.

%% TODO: change name method to something else
-spec codegen_method_clause(erl_parse:tree(), binary(), erl_parse:parse_tree()) ->
                               erl_parse:parse_tree().
codegen_method_clause(Path, Method, Behavior) ->
    {clause,
     0,
     [{match, 0, {var, 0, 'Req0'}, {map, 0, codegen_method_clause_helper(Path, Method)}}],
     [],
     Behavior}.

-spec codegen_method_clause_helper(erl_parse:tree(), binary()) -> erl_parse:parse_tree().
codegen_method_clause_helper(Path, Method) ->
    [{map_field_exact, 0, {atom, 0, method}, codegen_method_value(translate_method(Method))},
     {map_field_exact, 0, {atom, 0, path}, Path}].

-spec codegen_method_value(atom()) ->
                              {var, integer(), '_Method'} | {atom, integer(), atom()}.
codegen_method_value('_Method') ->
    {var, 0, '_Method'};
codegen_method_value(Method) ->
    {atom, 0, Method}.

-spec translate_method(binary()) -> atom().
translate_method(<<"GET">>) ->
    'GET';
translate_method(<<"POST">>) ->
    'POST';
translate_method(<<"PUT">>) ->
    'PUT';
translate_method(<<"PATCH">>) ->
    'PATCH';
translate_method(<<"DELETE">>) ->
    'DELETE';
translate_method(<<"_">>) ->
    '_Method'.

-ifdef(TEST).

-include_lib("eunit/include/eunit.hrl").

codegen_module_form_test() ->
    ?assertEqual({attribute, 0, module, foobar}, codegen_module_form(foobar)).

elli_exports_test() ->
    ?assertEqual([{attribute, 0, export, [{handle, 2}, {handle_event, 3}]}], elli_exports()).

codegen_handle_event_test() ->
    ?assertEqual([{function,
                   0,
                   handle_event,
                   3,
                   [{clause,
                     0,
                     [{var, 0, '_Event'}, {var, 0, '_Data'}, {var, 0, '_Args'}],
                     [],
                     [{atom, 0, ok}]}]}],
                 codegen_handle_event()).

codegen_get_method_test() ->
    ?assertEqual({call,
                  1,
                  {remote, 1, {atom, 1, nine_elli_util}, {atom, 1, get_method}},
                  [{var, 1, 'Req'}]},
                 codegen_get_method()).

codegen_get_path_test() ->
    ?assertEqual({call,
                  0,
                  {remote, 0, {atom, 0, elli_request}, {atom, 0, path}},
                  [{var, 0, 'Req'}]},
                 codegen_get_path()).

codegen_handle_test() ->
    ?assertEqual([{function,
                   0,
                   handle,
                   2,
                   [{clause,
                     0,
                     [{var, 0, 'Req'}, {var, 0, '_Args'}],
                     [],
                     [{call,
                       0,
                       {atom, 0, handle},
                       [{map,
                         0,
                         [{map_field_assoc, 0, {atom, 0, req}, {var, 0, 'Req'}},
                          {map_field_assoc, 0, {atom, 0, method}, codegen_get_method()},
                          {map_field_assoc, 0, {atom, 0, path}, codegen_get_path()}]}]}]}]}],
                 codegen_handle()).

codegen_case_init_test() ->
    Expected = codegen_case_wrapper(foo, bar, 0, {var, 0, 'Req1'}),
    ?assertEqual(Expected, codegen_case_chain_init([{foo, bar, 0}])).

codegen_case_chain_test() ->
    ?assertEqual({nil, 0}, codegen_case_chain([], {nil, 0})),
    Expected = codegen_case_wrapper(foo, bar, 0, {nil, 0}),
    ?assertEqual(Expected, codegen_case_chain([{foo, bar, 0}], {nil, 0})).

codegen_case_wrapper_test() ->
    Expected =
        {'case',
         0,
         codegen_handle_req(foo, bar, 'Req0'),
         [{clause,
           0,
           [{map, 0, [{map_field_exact, 0, {atom, 0, resp}, {var, 0, 'Resp0'}}]}],
           [],
           [{var, 0, 'Resp0'}]},
          {clause, 0, [{var, 0, 'Req1'}], [], [{nil, 0}]}]},
    ?assertEqual(Expected, codegen_case_wrapper(foo, bar, 0, {nil, 0})).

codegen_path_param_elements_test() ->
    Expected = [{map_field_assoc, 0, {atom, 0, foo}, {var, 0, 'Foo'}}],
    ?assertEqual(Expected, codegen_path_param_elements(['Foo'])).

codegen_path_params_test() ->
    Expected =
        {match,
         0,
         {var, 0, 'Req1'},
         {map,
          0,
          {var, 0, 'Req0'},
          [{map_field_assoc,
            0,
            {atom, 0, params},
            {map, 0, codegen_path_param_elements(['Foo'])}}]}},
    ?assertEqual(Expected, codegen_path_params(['Foo'])).

filter_path_params_test() ->
    ?assertEqual([foo, bar],
                 filter_path_params([<<"foo">>, foo, <<"bar">>, bar, 123, "foobar"])),
    ?assertEqual([foo, bar, baz],
                 filter_path_params([<<"foo">>,
                                     foo,
                                     <<"bar">>,
                                     {<<"bar">>, bar},
                                     {all, baz},
                                     all])).

enumerate_middleware_test() ->
    InputData = [{foo, bar}, {bar, foo}],
    OutputData = enumerate_middleware(InputData, 0),
    ?assertEqual([{bar, foo, 1}, {foo, bar, 0}], OutputData).

codegen_handle_req_test() ->
    Expected = {call, 0, {remote, 0, {atom, 0, foo}, {atom, 0, bar}}, [{var, 0, 'Req0'}]},
    ?assertEqual(Expected, codegen_handle_req(foo, bar, 'Req0')).

codegen_binary_test() ->
    Expected = {bin, 0, [{bin_element, 0, {string, 0, "foobar"}, default, default}]},
    ?assertEqual(Expected, codegen_binary(<<"foobar">>)).

codegen_binary_var_test() ->
    Expected =
        {bin,
         0,
         [{bin_element, 0, {string, 0, "foobar"}, default, default},
          {bin_element, 0, {var, 0, 'Var'}, default, [binary]}]},

    ?assertEqual(Expected, codegen_binary_var(<<"foobar">>, 'Var')).

codegen_path_element_test() ->
    ?assertEqual({var, 0, '_'}, codegen_path_element(all)),
    ?assertEqual({var, 0, foo}, codegen_path_element(foo)),
    ?assertEqual(codegen_binary(<<"foobar">>), codegen_path_element(<<"foobar">>)),
    ?assertEqual(codegen_binary_var(<<"foobar">>, 'Var'),
                 codegen_path_element({<<"foobar">>, 'Var'})).

codegen_path_test() ->
    ?assertEqual({var, 0, '_'}, codegen_path([])),
    ?assertEqual({nil, 0}, codegen_path([<<>>])),
    ?assertEqual({nil, 0}, codegen_path([], {nil, 0})),
    ?assertEqual({cons, 0, {var, 0, foo}, {nil, 0}}, codegen_path([foo], {nil, 0})),
    ?assertEqual({cons, 0, {var, 0, foo}, {nil, 0}}, codegen_path([foo])),
    ?assertEqual({cons, 0, {var, 0, foo}, {var, 0, bar}}, codegen_path([foo, {all, bar}])),
    ?assertEqual({cons, 0, {var, 0, foo}, {var, 0, '_'}}, codegen_path([foo, all])).

codegen_method_clause_helper_test() ->
    ?assertEqual([{map_field_exact, 0, {atom, 0, method}, {atom, 0, 'GET'}},
                  {map_field_exact, 0, {atom, 0, path}, {nil, 0}}],
                 codegen_method_clause_helper({nil, 0}, <<"GET">>)).

codegen_method_clause_test() ->
    ?assertEqual({clause,
                  0,
                  [{match,
                    0,
                    {var, 0, 'Req0'},
                    {map,
                     0,
                     [{map_field_exact, 0, {atom, 0, method}, {atom, 0, 'GET'}},
                      {map_field_exact, 0, {atom, 0, path}, {nil, 0}}]}}],
                  [],
                  {nil, 0}},
                 codegen_method_clause({nil, 0}, <<"GET">>, {nil, 0})).

translate_method_test() ->
    ?assertEqual('GET', translate_method(<<"GET">>)),
    ?assertEqual('POST', translate_method(<<"POST">>)),
    ?assertEqual('PUT', translate_method(<<"PUT">>)),
    ?assertEqual('PATCH', translate_method(<<"PATCH">>)),
    ?assertEqual('DELETE', translate_method(<<"DELETE">>)),
    ?assertEqual('_Method', translate_method(<<"_">>)).

codegen_method_value_test() ->
    ?assertEqual({var, 0, '_Method'}, codegen_method_value('_Method')),
    ?assertEqual({atom, 0, thing}, codegen_method_value(thing)),
    ?assertEqual({atom, 0, stuff}, codegen_method_value(stuff)).

parse_path_test() ->
    ?assertEqual([<<"foo">>, <<"bar">>], parse_path(<<"/foo/bar">>)),

    ?assertEqual([<<"foo">>, 'Bar'], parse_path(<<"/foo/:bar">>)),
    ?assertEqual([<<>>], parse_path(<<"/">>)),

    ?assertEqual([all], parse_path(<<"/*">>)),
    ?assertEqual([<<"api">>, {<<"v">>, 'Version'}, <<"pages">>, 'Id'],
                 parse_path(<<"/api/v:version/pages/:id">>)),
    ?assertEqual([<<"pages">>, {all, 'Page'}], parse_path(<<"/pages/*page">>)),
    ?assertEqual([<<"pages">>, {<<"he">>, 'Page'}, {all, 'Rest'}],
                 parse_path(<<"/pages/he:page/*rest">>)).

translate_path_param_test() ->
    ?assertEqual(<<"foo">>, translate_path_param(<<"foo">>)),
    ?assertEqual('Foo', translate_path_param(<<":foo">>)),
    ?assertEqual({<<"v">>, 'Version'}, translate_path_param(<<"v:version">>)),
    ?assertEqual({all, 'Splat'}, translate_path_param(<<"*splat">>)),
    ?assertEqual(all, translate_path_param(<<"*">>)).

resp_atom_test() ->
    ?assertEqual('Resp1', resp_atom(1)),
    ?assertEqual('Resp2', resp_atom(2)).

req_atom_test() ->
    ?assertEqual('Req1', req_atom(1)),
    ?assertEqual('Req2', req_atom(2)).

-endif.