%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1997-2012. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%
%%
-module(asn1_db).

-export([dbstart/1,dbnew/1,dbsave/2,dbload/1,dbput/3,dbget/2,dbget_all/1]).
-export([dbget_all_mod/1,dbclear/0,dberase_module/1,dbstop/0]).

-record(state, {parent, monitor, includes, table}).

%% Interface
dbstart(Includes) ->
    Parent = self(),
    case get(?MODULE) of
        undefined ->
            put(?MODULE, spawn_link(fun() -> init(Parent, Includes) end)),
            true;
        _Pid ->
            req({new_includes, Includes})
    end.

dbnew(Module)              -> req({new, Module}).
dbsave(OutFile, Module)    -> req({save, OutFile, Module}).
dbload(Module)             -> req({load, Module}).
dbput(Module, K, V)        -> req({set, Module, K, V}).
dbget(Module, K)           -> req({get, Module, K}).
dbget_all(K)               -> req({get_all, K}).
dbget_all_mod(Mod)         -> req({all_mod, Mod}).
dbclear()                  -> req(clear).
dberase_module({module,M}) -> req({delete_mod, M}).
dbstop()                   -> Resp = req(stop), erase(?MODULE), Resp.

%% Internal functions
req(Request) ->
    DbPid = get(?MODULE),
    Ref = erlang:monitor(process,DbPid),
    get(?MODULE) ! {{Ref, self()}, Request},
    receive 
	{{Ref,?MODULE}, Reply} ->
	    erlang:demonitor(Ref,[flush]),
	    Reply; 
	{'DOWN',Ref,_,_,Info} -> 
	    exit({db_error,Info}) 
    end.

reply({Ref,From}, Response) ->
    From ! {{Ref,?MODULE}, Response}.

init(Parent, Includes) ->
    MRef = erlang:monitor(process, Parent),
    loop(#state{parent = Parent, monitor = MRef, includes = Includes,
                table = ets:new(?MODULE, [])}).

loop(#state{parent = Parent, monitor = MRef, table = Table,
            includes = Includes} = State) ->
    receive
        {From, {set, Mod, K2, V}} ->
            [{_, Modtab}] = ets:lookup(Table, Mod),
            ets:insert(Modtab, {K2, V}),
            reply(From, ok),
            loop(State);
        {From, {get, Mod, K2}} ->
            Result = case ets:lookup(Table, Mod) of
                         []            -> opentab(Table, Mod, Includes);
                         [{_, Modtab}] -> {ok, Modtab}
                     end,
            case Result of
                {ok, Newtab} -> reply(From, lookup(Newtab, K2));
                _Error       -> reply(From, undefined)
            end,
            loop(State);
        {From, {all_mod, Mod}} ->
            [{_, Modtab}] = ets:lookup(Table, Mod),
            reply(From, ets:tab2list(Modtab)),
            loop(State);
        {From, {delete_mod, Mod}} ->
            [{_, Modtab}] = ets:lookup(Table, Mod),
            ets:delete(Modtab),
            ets:delete(Table, Mod),
            reply(From, ok),
            loop(State);
        {From, {save, OutFile, Mod}} ->
            [{_,Mtab}] = ets:lookup(Table, Mod),
            reply(From, ets:tab2file(Mtab, OutFile)),
            loop(State);
        {From, {load, Mod}} ->
            Result = case ets:lookup(Table, Mod) of
                         []            -> opentab(Table, Mod, Includes);
                         [{_, Modtab}] -> {ok, Modtab}
                     end,
            reply(From, Result),
            loop(State);
        {From, {new, Mod}} ->
            case ets:lookup(Table, Mod) of
                [{_, Modtab}] -> ets:delete(Modtab);
                _             -> true
            end,
            ModTableId = ets:new(list_to_atom(lists:concat(["asn1_",Mod])), []),
            ets:insert(Table, {Mod, ModTableId}),
            reply(From, ok),
            loop(State);
        {From, clear} ->
            [ets:delete(Mt) || {_, Mt} <- ets:tab2list(Table)],
            ets:delete(Table),
            reply(From, cleared),
            loop(State#state{table = ets:new(asn1, [set])});
        {From, {new_includes, NewIncludes}} ->
            reply(From, true),
            loop(State#state{includes = NewIncludes});
        {From, stop} ->
            reply(From, stopped); %% Nothing to store
        {'DOWN', MRef, process, Parent, Reason} ->
            exit(Reason)
    end.

opentab(Tab, Mod, []) ->
    opentab(Tab, Mod, ["."]);
opentab(Tab, Mod, Includes) ->
    Base = lists:concat([Mod, ".asn1db"]),
    opentab2(Tab, Base, Mod, Includes, ok).

opentab2(_Tab, _Base, _Mod, [], Error) ->
    Error;
opentab2(Tab, Base, Mod, [Ih|It], _Error) ->
    File = filename:join(Ih, Base),
    case ets:file2tab(File) of
        {ok, Modtab} ->
            ets:insert(Tab, {Mod, Modtab}),
            {ok, Modtab};
        NewErr ->
            opentab2(Tab, Base, Mod, It, NewErr)
    end.

lookup(Tab, K) ->
    case ets:lookup(Tab, K) of
        []      -> undefined;
        [{K,V}] -> V
    end.