%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
%%
%% 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.
%%
%% %CopyrightEnd%
%%

-module(snmpa_mib_storage_ets).

-behaviour(snmpa_mib_storage).

%%%-----------------------------------------------------------------
%%% This module implements the snmpa_mib_storage behaviour. 
%%% It uses ets for storage. 
%%%-----------------------------------------------------------------

-export([
	 open/5, 
	 close/1, 
	 read/2, 
	 write/2, 
	 delete/1, 
	 delete/2, 
	 match_object/2, 
	 match_delete/2, 
	 tab2list/1, 
	 info/1, info/2, 
	 sync/1, 
	 backup/2
	]).


-define(VMODULE,"MS-ETS").
-include("snmp_verbosity.hrl").

-record(tab, {id, rec_name, file, checksum = false}).


%% ---------------------------------------------------------------
%% open
%% 
%% Open or create an ets table. 
%% Possibly also read data from a (specified) file (mirror) and 
%% populate the table from that (the dir option). 
%% 
%% Opts    - A list of implementation dependent options
%%           ets_open_options() = [ets_open_option()]
%%           ets_open_option()  = {dir,      filename()} | 
%%                                {action,   keep | clear} | 
%%                                {checksum, boolean()}
%% 
%% The RecName and Fields arguments are not used in this 
%% implementation. 
%% 
%% ---------------------------------------------------------------

%% This function creates the ets table 
open(Name, RecName, _Fields, Type, Opts) ->
    ?vtrace("open table ~p", [Name]),
    case lists:keysearch(dir, 1, Opts) of
	{value, {dir, Dir}} ->
	    Action   = snmp_misc:get_option(action,   Opts, keep),
	    Checksum = snmp_misc:get_option(checksum, Opts, false),
	    ?vtrace("open ~p database ~p - check if file exist", [Type, Name]),
	    File = filename:join(Dir, atom_to_list(Name) ++ ".db"),
	    case file:read_file_info(File) of
		{ok, _} ->
		    ?vdebug("open ~p database ~p - file exist - try reading", 
			    [Type, Name]),
		    case ets:file2tab(File, [{verify, Checksum}]) of
			{ok, ID} ->
			    ?vtrace("open ~p database ~p - "
				    "data read from file", [Type, Name]),
			    {ok, #tab{id       = ID, 
				      rec_name = RecName, 
				      file     = File, 
				      checksum = Checksum}};
			{error, Reason} when (Action =:= keep) ->
			    ?vinfo("open ~p database ~p - "
				   "failed reading from file (keep): "
				   "~n   ~p", 
				   [Type, Name, Reason]),
			    {error, {file2tab, Reason}};
			{error, Reason} ->
			    ?vlog("open ~p database ~p - "
				  "failed reading from file (clear): "
				  "~n   ~p", [Type, Name, Reason]),
			    user_err("Warning: could not read file - "
				     "create new (empty): "
				     "~n   File:   ~p"
				     "~n   Reason: ~p", [File, Reason]), 
			    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
			    write_ets_file(ID, File, Checksum), 
			    {ok, #tab{id       = ID, 
				      rec_name = RecName, 
				      file     = File, 
				      checksum = Checksum}}
		    end;
		{error, enoent} ->
		    %% No such file - create it
		    ?vdebug("open ~p database ~p - "
			    "file does *not* exist - create", 
			    [Type, Name]),
		    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
		    write_ets_file(ID, File, Checksum), 
		    {ok, #tab{id       = ID, 
			      rec_name = RecName, 
			      file     = File, 
			      checksum = Checksum}};
		{error, Reason} when (Action =:= keep) ->
		    ?vinfo("open ~p database ~p - "
			   "failed reading file info (keep): "
			   "~n   ~p", 
			   [Type, Name, Reason]),
		    {error, {read_file_info, Reason}};
		{error, Reason} ->
		    ?vlog("open ~p database ~p - "
			  "failed reading file info (clear): "
			  "~n   ~p", 
			  [Type, Name, Reason]),
		    user_err("Warning: could not read file info - "
			     "create new file: "
			     "~n   File:   ~p"
			     "~n   Reason: ~p", [File, Reason]), 
		    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
		    write_ets_file(ID, File, Checksum), 
		    {ok, #tab{id       = ID, 
			      rec_name = RecName, 
			      file     = File, 
			      checksum = Checksum}}
	    end;
	false ->
	    ?vdebug("open ~p database ~p - ok", [Type, Name]),
	    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
	    {ok, #tab{id = ID, rec_name = RecName}}
    end.


%% ---------------------------------------------------------------
%% close
%% 
%% Close the mib-storage table. 
%% We will delete the table and if there is a file component, 
%% will also be written to file. 
%% ---------------------------------------------------------------
close(#tab{id = ID, file = undefined}) ->
    ?vtrace("close (delete) table ~p", [ID]),
    ets:delete(ID);
close(#tab{id = ID, file = File, checksum = Checksum}) ->
    ?vtrace("close (delete) table ~p", [ID]),
    write_ets_file(ID, File, Checksum),
    ets:delete(ID).


%% ---------------------------------------------------------------
%% read
%% 
%% Retrieve a record from the mib-storage table.
%% ---------------------------------------------------------------

read(#tab{id = ID}, Key) ->
    ?vtrace("read from table ~p: ~p", [ID, Key]),
    case ets:lookup(ID, Key) of
	[Rec|_] -> {value, Rec};
	_ -> false
    end.
    

%% ---------------------------------------------------------------
%% write
%% 
%% Write a record to the mib-storage table.
%% ---------------------------------------------------------------

%% This is a very crude guard test is used instead of: is_record(Rec, RecName)
write(#tab{id = ID, rec_name = RecName}, Rec) 
  when (is_tuple(Rec) andalso (element(1, Rec) =:= RecName)) ->
    ?vtrace("write to table ~p", [ID]),
    ets:insert(ID, Rec).


%% ---------------------------------------------------------------
%% delete
%% 
%% Delete the mib-storage table. 
%% ---------------------------------------------------------------
delete(#tab{id = ID, file = undefined}) ->
    ?vtrace("delete table ~p", [ID]),
    ets:delete(ID);
delete(#tab{id = ID, file = File}) ->
    ?vtrace("delete table ~p", [ID]),
    file:delete(File),
    ets:delete(ID).


%% ---------------------------------------------------------------
%% delete
%% 
%% Delete a record from the mib-storage table.
%% ---------------------------------------------------------------
delete(#tab{id = ID}, Key) ->
    ?vtrace("delete from table ~p: ~p", [ID, Key]),
    ets:delete(ID, Key).


%% ---------------------------------------------------------------
%% match_object
%% 
%% Search the mib-storage table for records witch matches 
%% the pattern.
%% ---------------------------------------------------------------

match_object(#tab{id = ID}, Pattern) ->
    ?vtrace("match_object in ~p of ~p", [ID, Pattern]),
    ets:match_object(ID, Pattern).
    

%% ---------------------------------------------------------------
%% match_delete
%% 
%% Search the mib-storage table for records witch matches 
%% the pattern and deletes them from the table.
%% ---------------------------------------------------------------
 
match_delete(#tab{id = ID}, Pattern) -> 
    ?vtrace("match_delete in ~p with pattern ~p", [ID, Pattern]),
    Recs = ets:match_object(ID, Pattern),
    ets:match_delete(ID, Pattern),
    Recs.


%% ---------------------------------------------------------------
%% tab2list
%% 
%% Return all records in the mib-storage table in the form 
%% of a list.
%% ---------------------------------------------------------------

tab2list(#tab{id = ID}) ->
    ?vtrace("tab2list -> list of ~p", [ID]),
    ets:tab2list(ID).



%% ---------------------------------------------------------------
%% info/1,2
%% 
%% Retrieve implementation dependent mib-storage table 
%% information.
%% ---------------------------------------------------------------
info(#tab{id = ID}) ->
    ?vtrace("info on ~p", [ID]),
    case ets:info(ID) of
	undefined ->
	    [];
	L ->
	    L
    end.


info(TabId, all = _Item) ->
    info(TabId);
info(#tab{id = ID}, Item) ->
    ?vtrace("info on ~p", [ID]),
    ets:info(ID, Item).


%% ---------------------------------------------------------------
%% sync
%% 
%% Dump mib-storage table to disc (if there is a file compionent)
%% ---------------------------------------------------------------

sync(#tab{file = undefined}) ->
    ok;
sync(#tab{id = ID, file = File, checksum = Checksum}) ->
    ?vtrace("sync ~p", [ID]),
    write_ets_file(ID, File, Checksum).


%% ---------------------------------------------------------------
%% backup
%% 
%% Make a backup copy of the mib-storage table. Only valid id
%% there is a file component. 
%% ---------------------------------------------------------------

backup(#tab{file = undefined}, _BackupDir) ->
    ok;
backup(#tab{id = ID, file = File, checksum = Checksum}, BackupDir) ->
    ?vtrace("backup ~p to ~p", [ID, BackupDir]),
    Filename = filename:basename(File),
    case filename:join(BackupDir, Filename) of
	File ->
	    %% Oups: backup-dir and db-dir the same
	    {error, db_dir};
	BackupFile ->
	    write_ets_file(ID, BackupFile, Checksum)
    end.

	      
%%----------------------------------------------------------------------

write_ets_file(ID, File, Checksum) when (Checksum =:= true) ->
    do_write_ets_file(ID, File, [{extended_info, [md5sum]}]);
write_ets_file(ID, File, Checksum) when (Checksum =:= false) ->
    do_write_ets_file(ID, File, []).

do_write_ets_file(ID, File, Options) ->
    TmpFile = File ++ ".tmp",
    case ets:tab2file(ID, TmpFile, Options) of
	ok ->
	    case file:rename(TmpFile, File) of
		ok ->
		    ok;
		Else ->
		    user_err("Warning: could not move file ~p"
			     " (~p)", [File, Else])
	    end;
	{error, Reason} ->
	    user_err("Warning: could not save file ~p (~p)",
		     [File, Reason])
    end.


%%----------------------------------------------------------------------

user_err(F, A) ->
    snmpa_error:user_err(F, A).
