%%% Copyright (c) 2014-2015, NORDUnet A/S.
%%% See LICENSE for licensing information.

%%% @doc Frontend node API

-module(frontend).
%% API (URL)
-export([request/3]).

request(post, "ct/frontend/sendentry", Input) ->
    case (catch mochijson2:decode(Input)) of
        {error, E} ->
            html("sendentry: bad input:", E);
        {struct, PropList} ->
            LogEntry = base64:decode(proplists:get_value(<<"entry">>, PropList)),
            TreeLeafHash = base64:decode(proplists:get_value(<<"treeleafhash">>, PropList)),

            ok = db:add(TreeLeafHash, LogEntry),
            success({[{result, <<"ok">>}]})
    end;

request(post, "ct/frontend/sendlog", Input) ->
    case (catch mochijson2:decode(Input)) of
        {error, E} ->
            html("sendentry: bad input:", E);
        {struct, PropList} ->
            Start = proplists:get_value(<<"start">>, PropList),
            Hashes = lists:map(fun (S) -> base64:decode(S) end, proplists:get_value(<<"hashes">>, PropList)),

            Indices = lists:seq(Start, Start + length(Hashes) - 1),
            lists:foreach(fun ({Hash, Index}) ->
                                  ok = db:add_index_nosync(Hash, Index)
                          end, lists:zip(Hashes, Indices)),
            lists:foreach(fun ({Hash, Index}) ->
                                  ok = db:indexforhash_sync(Hash, Index)
                          end, lists:zip(Hashes, Indices)),
            ok = db:index_sync(),
            success({[{result, <<"ok">>}]})
    end;

request(post, "ct/frontend/sendsth", Input) ->
    case (catch mochijson2:decode(Input)) of
        {error, E} ->
            html("sendentry: bad input:", E);
        {struct, PropList} ->
            OldSize = db:size(),
            Treesize = proplists:get_value(<<"tree_size">>, PropList),
            Timestamp = proplists:get_value(<<"timestamp">>, PropList),
            RootHash = base64:decode(proplists:get_value(<<"sha256_root_hash">>, PropList)),
            Signature = base64:decode(proplists:get_value(<<"tree_head_signature">>, PropList)),
            Indexsize = db:indexsize(),

            if
                Treesize < OldSize ->
                    html("Size is older than current size", OldSize);
                Treesize == 0, OldSize == 0 ->
                    lager:debug("both old and new size is 0, saving sth"),
                    OwnRootHash = ht:root(-1),
                    case {plop:verify_sth(Treesize, Timestamp, RootHash, Signature), OwnRootHash} of
                        {true, RootHash} ->
                            ok = plop:save_sth({struct, PropList}),
                            success({[{result, <<"ok">>}]});
                        {false, RootHash} ->
                            html("Verification failed", hex:bin_to_hexstr(RootHash));
                        _ ->
                            html("Root hash not the same", hex:bin_to_hexstr(OwnRootHash))
                    end;
                Treesize > Indexsize ->
                    html("Has too few entries", Indexsize);
                true ->
                    NewEntries = get_new_entries(OldSize, Treesize),
                    lager:debug("old size: ~p new size: ~p entries: ~p",
                                [OldSize, Treesize, NewEntries]),

                    Errors = check_entries(NewEntries, OldSize, Treesize - 1),

                    case Errors of
                        [] ->
                            ht:load_tree(Treesize - 1),
                            OwnRootHash = ht:root(Treesize - 1),
                            case {plop:verify_sth(Treesize, Timestamp, RootHash, Signature), OwnRootHash} of
                                {true, RootHash} ->
                                    ok = plop:save_sth({struct, PropList}),
                                    success({[{result, <<"ok">>}]});
                                {false, RootHash} ->
                                    html("Verification failed", hex:bin_to_hexstr(RootHash));
                                _ ->
                                    html("Root hash not the same", hex:bin_to_hexstr(OwnRootHash))
                            end;
                        _ ->
                            html("Database not complete", Errors)
                    end
            end
    end;

request(get, "ct/frontend/currentposition", _Query) ->
    Size = db:size(),
    success({[{result, <<"ok">>},
              {position, Size}]});

request(get, "ct/frontend/missingentries", _Query) ->
    Size = db:size(),
    Missing = fetchmissingentries(Size),
    lager:debug("missingentries: ~p", [Missing]),
    success({[{result, <<"ok">>},
              {entries, lists:map(fun (Entry) -> base64:encode(Entry) end,
                                  Missing)}]}).

get_new_entries(OldSize, Treesize) when OldSize < Treesize ->
    db:leafhash_for_indices(OldSize, Treesize - 1);
get_new_entries(OldSize, Treesize) when OldSize == Treesize ->
    [].

check_entries(Entries, Start, End) ->
    lists:foldl(fun ({Hash, Index}, Acc) ->
                        case check_entry(Hash, Index) of
                            ok ->
                                Acc;
                            Error ->
                                [Error | Acc]
                        end
                end, [], lists:zip(Entries, lists:seq(Start, End))).

check_entry(LeafHash, Index) ->
    case db:get_by_leaf_hash(LeafHash) of
        notfound ->
            {notfound, Index};
        {Index, LeafHash, Entry} ->
            {ok, {Module, Function}} = application:get_env(plop, entryhash_from_entry),
            EntryHash = Module:Function(Entry),
            ok = db:add_entryhash(LeafHash, EntryHash),
            ok
    end.

fetchmissingentries(Index) ->
    lists:reverse(fetchmissingentries(Index, [])).

fetchmissingentries(Index, Acc) ->
    lager:debug("index ~p", [Index]),
    case db:leafhash_for_index(Index) of
        noentry ->
            Acc;
        Hash ->
            case db:entry_for_leafhash(Hash) of
                noentry ->
                    lager:debug("didn't find hash ~p", [Hash]),
                    fetchmissingentries(Index + 1, [Hash | Acc]);
                _ ->
                    fetchmissingentries(Index + 1, Acc)
            end
    end.


%% Private functions.
html(Text, Input) ->
    {400, [{"Content-Type", "text/html"}],
     io_lib:format(
       "<html><body><p>~n" ++
           "~s~n" ++
           "~p~n" ++
           "</body></html>~n", [Text, Input])}.

success(Data) ->
    {200, [{"Content-Type", "text/json"}], mochijson2:encode(Data)}.