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

%% Implements an interface to a file pair (basename and
%% basename.chksum) that stores an ordered list of fixed-size entries.
%% Entries can be added at the end and are retrieved by index. Entries
%% can also be added at already existing indices, but then the
%% contents must be the same.
%%
%% Writes(add, addlast) need to be serialized.

%% TODO: Checksums

-module(index).
-export([get/2, getrange/3, add/3, add_nosync/3, addlast_nosync/2, indexsize/1, sync/1]).

-define(ENTRYSIZE, 32).
-define(ENTRYSIZEINFILE, (?ENTRYSIZE*2+1)).

-spec add(string(), integer() | last, binary()) -> ok.
add(Basepath, Index, Entry) ->
    add(Basepath, Index, Entry, sync).

-spec add_nosync(string(), integer() | last, binary()) -> ok.
add_nosync(Basepath, Index, Entry) ->
    add(Basepath, Index, Entry, nosync).

add(Basepath, Index, Entry, Syncflag) when is_binary(Entry), size(Entry) == ?ENTRYSIZE ->
    case file:open(Basepath, [read, write, binary]) of
        {ok, File} ->
            {ok, Position} = file:position(File, eof),
            Mode = case Index of
                       last when Position rem ?ENTRYSIZEINFILE == 0 ->
                           write;
                       Index when is_integer(Index),
                                  Index * ?ENTRYSIZEINFILE == Position ->
                           write;
                       Index when is_integer(Index),
                                  Index * ?ENTRYSIZEINFILE < Position ->
                           read;
                       _ ->
                           util:exit_with_error(invalid, writefile,
                                                "Index not valid")
                   end,
            EntryText = hex:bin_to_hexstr(Entry) ++ "\n",
            case Mode of
                write ->
                    ok = file:write(File, EntryText);
                read ->
                    {ok, _Position} =
                        file:position(File, {bof, Index * ?ENTRYSIZEINFILE}),
                    {ok, OldEntryText} = file:read(File, ?ENTRYSIZEINFILE),
                    %% check that the written content is the same as
                    %% the old content
                    case binary_to_list(OldEntryText) of
                        EntryText ->
                            ok;
                        _ ->
                            util:exit_with_error(invalid, writefile,
                                                 "Written content not the" ++
                                                     " same as old content")
                    end
            end,
            ok = file:close(File),
            case Syncflag of
                sync ->
                    sync(Basepath);
                nosync ->
                    ok
            end;
        {error, Error} ->
            util:exit_with_error(Error, writefile,
                                 "Error opening file for writing")
    end.


-spec sync(string()) -> ok.
sync(Basepath) ->
    util:fsync([Basepath, filename:dirname(Basepath)]).

-spec addlast_nosync(string(), binary()) -> ok.
addlast_nosync(Basepath, Entry) ->
    add_nosync(Basepath, last, Entry).

decodedata(Binary) ->
    lists:reverse(decodedata(Binary, [])).

decodedata(<<>>, Acc) ->
    Acc;
decodedata(<<Entry:?ENTRYSIZE/binary-unit:16, "\n", Rest/binary>>, Acc) ->
    decodedata(Rest, [mochihex:to_bin(binary_to_list(Entry)) | Acc]);
decodedata(<<_:?ENTRYSIZE/binary-unit:16, _>>, _Acc) ->
    util:exit_with_error(badformat, readindex,
                         "Index line not ending with linefeed").

-spec indexsize(string()) -> integer().
indexsize(Basepath) ->
    case file:open(Basepath, [read, binary]) of
        {ok, File} ->
            {ok, Filesize} = file:position(File, eof),
            file:close(File),
            lager:debug("file ~p size ~p", [Basepath, Filesize]),
            Filesize div ?ENTRYSIZEINFILE;
        {error, Error} ->
            util:exit_with_error(Error, readfile,
                                 "Error opening file for reading")
    end.

-spec get(string(), integer()) -> binary() | noentry.
get(Basepath, Index) ->
    case getrange(Basepath, Index, Index) of
        noentry ->
            noentry;
        [Entry] ->
            Entry
    end.

-spec getrange(string(), integer(), integer()) -> [binary()] | noentry.
getrange(Basepath, Start, End) when Start =< End ->
    lager:debug("path ~p start ~p end ~p", [Basepath, Start, End]),
    case file:open(Basepath, [read, binary]) of
        {ok, File} ->
            {ok, Filesize} = file:position(File, eof),
            if
                End * ?ENTRYSIZEINFILE + ?ENTRYSIZEINFILE =< Filesize ->
                    {ok, _Position} = file:position(File,
                                                    Start * ?ENTRYSIZEINFILE),
                    {ok, EntryText} =
                        file:read(File, ?ENTRYSIZEINFILE * (End - Start + 1)),
                    Entry = decodedata(EntryText),
                    lager:debug("entries ~p", [length(Entry)]),
                    file:close(File),
                    Entry;
                true ->
                    file:close(File),
                    noentry
            end;
        {error, Error} ->
            util:exit_with_error(Error, readfile,
                                 "Error opening file for reading")
    end.