-module(p11p_config).
-behaviour(gen_server).

%% API
-export([start_link/0]).
%%-export([config/0]).
-export([nameof/1]).
-export([tokens/0]).
-export([modules_for_token/1, module_path/1, token_mode/1]).

%% Genserver callbacks.
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
         terminate/2, code_change/3]).

%% Records and types.
-record(p11module, {
	  name :: string(),
          path :: string()
	  }).
-type p11module() :: #p11module{}.

-type token_mode() :: {failover | balance, [term()]}.

-record(token, {
	  name :: string(),
	  mode :: token_mode(),
	  modules = #{} :: #{string() => p11module()}
	 }).
-type token() :: #token{}.

%% Genserver state.
-record(state, {
	  tokens :: #{string() => token()}
	 }).

%%%%%%%%%%%%%%%%%%%%
%% API.
start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

%% config() ->
%%     gen_server:call(?MODULE, config).

-spec tokens() -> [token()].
tokens() ->
    gen_server:call(?MODULE, tokens).

-spec token_mode(string()) -> token_mode().
token_mode(TokName) ->
    gen_server:call(?MODULE, {token_mode, TokName}).

-spec modules_for_token(string()) -> [p11module()].
modules_for_token(TokName) ->
    gen_server:call(?MODULE, {modules_for_token, TokName}).

-spec module_path(p11module()) -> string().
module_path(Module) ->
    Module#p11module.path.

nameof(#token{name = Name}) ->
    Name;
nameof(#p11module{name = Name}) ->
    Name;
nameof(List) ->
    [nameof(E) || E <- List].

%%%%%%%%%%%%%%%%%%%%
%% Genserver callbacks.
init(_Args) ->
    State = init_state(),
    {ok, State}.

%% handle_call(config, _From, State) ->
%%     {reply, State, State};
handle_call(tokens, _From, #state{tokens = Tokens} = State) ->
    {reply, maps:values(Tokens), State};
handle_call({modules_for_token, TokName}, _, #state{tokens = Tokens} = S) ->
    #{TokName := Token} = Tokens,
    {reply, maps:values(Token#token.modules), S};
handle_call({token_mode, TokName}, _, #state{tokens = Tokens} = State) ->
    #{TokName := Token} = Tokens,
    {reply, Token#token.mode, State};
handle_call(Request, _From, State) ->
    lager:warning("Unhandled call: ~p", [Request]),
    {reply, unhandled, State}.

handle_cast(Message, State) ->
    lager:warning("Unhandled cast: ~p", [Message]),
    {noreply, State}.

handle_info(Info, State) ->
    lager:warning("Unhandled info: ~p", [Info]),
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVersion, State, _Extra) ->
    {ok, State}.

%%%%%%%%%%%%%%%%%%%%
%% Private.

init_state() ->
    #state { 
       tokens = conf_tokens(application:get_env(p11p, groups, []))
      }.

conf_tokens(L) ->
    conf_tokens(L, #{}).
conf_tokens([], Acc) ->
    Acc;
conf_tokens([H = {Name, _}|T], Acc) ->
    conf_tokens(T, Acc#{Name => new_token(H)}).

-spec new_token({string(), [tuple()]}) -> token().
new_token({Name, Settings}) ->
    #token{
       name = Name,
       mode = proplists:get_value(mode, Settings, {failover, [timeout]}),
       modules = conf_modules(proplists:get_value(modules, Settings))
      }.

conf_modules(L) ->
    conf_modules(L, #{}).
conf_modules([], Acc) ->
    Acc;
conf_modules([{Name, Path}|T], Acc) ->
    conf_modules(T, Acc#{Name => new_module(Name, Path)}).

new_module(Name, Path) ->
    #p11module{
       name = Name,
       path = Path
      }.

%%%%%%%%%%%%%%
%% Unit tests.

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

tokens_init_test_() ->
    {setup,
     fun() ->
	     conf_tokens(
	       [
		{"vtoken0", 
		 [{modules, [{"bogusmod0_0", "/path/to/bogusmod0_0"},
			     {"bogusmod0_1", "/path/to/bogusmod0_1"}
			    ]}]},
		{"vtoken1",
		 [{modules, [{"bogusmod1_0", "/path/to/bogusmod1_0"}]}]}
	       ]) end,
     fun(_) -> ok end,
     fun(Conf) ->
             [?_assertEqual(
                 #{"vtoken0" =>
		       {token,"vtoken0",
			{failover,[timeout]},
			#{"bogusmod0_0" => 
			      {p11module,"bogusmod0_0", "/path/to/bogusmod0_0"},
			  "bogusmod0_1" => 
			      {p11module,"bogusmod0_1", "/path/to/bogusmod0_1"}}},
		   "vtoken1" =>
		       {token,"vtoken1",
			{failover,[timeout]},
			#{"bogusmod1_0" =>
			      {p11module,"bogusmod1_0", "/path/to/bogusmod1_0"}}}
		  },
		 Conf)] end}.
%% modules_for_token_test_() ->
%%     {setup,
%%      fun() ->