%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2011. 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(diameter_lib).

-export([report/2, info_report/2,
         error_report/2,
         warning_report/2,
         now_diff/1,
         time/1,
         eval/1,
         ip4address/1,
         ip6address/1,
         ipaddr/1,
         spawn_opts/2,
         wait/1,
         fold_tuple/3]).

-include("diameter_internal.hrl").

%% ---------------------------------------------------------------------------
%% # info_report(Reason, MFA)
%%
%% Input: Reason = Arbitrary term indicating the reason for the report.
%%        MFA    = {Module, Function, Args} to report.
%%
%% Output:  true
%% ---------------------------------------------------------------------------

report(Reason, MFA) ->
    info_report(Reason, MFA).

info_report(Reason, MFA) ->
    report(fun error_logger:info_report/1, Reason, MFA),
    true.

%%% ---------------------------------------------------------------------------
%%% # error_report(Reason, MFA)
%%% # warning_report(Reason, MFA)
%%%
%%% Output:  false
%%% ---------------------------------------------------------------------------

error_report(Reason, MFA) ->
    report(fun error_logger:error_report/1, Reason, MFA).

warning_report(Reason, MFA) ->
    report(fun error_logger:warning_report/1, Reason, MFA).

report(Fun, Reason, MFA) ->
    Fun([{why, Reason}, {who, self()}, {what, MFA}]),
    false.

%%% ---------------------------------------------------------------------------
%%% # now_diff(Time)
%%%
%%% Description: Return timer:now_diff(now(), Time) as an {H, M, S, MicroS}
%%%              tuple instead of as integer microseconds.
%%% ---------------------------------------------------------------------------

now_diff({_,_,_} = Time) ->
    time(timer:now_diff(erlang:now(), Time)).

%%% ---------------------------------------------------------------------------
%%% # time(Time)
%%%
%%% Input:  Time = {MegaSec, Sec, MicroSec}
%%%              | MicroSec
%%%
%%% Output: {H, M, S, MicroS}
%%% ---------------------------------------------------------------------------

time({_,_,_} = Time) ->  %% time of day
    %% 24 hours = 24*60*60*1000000 = 86400000000 microsec
    time(timer:now_diff(Time, {0,0,0}) rem 86400000000);

time(Micro) ->  %% elapsed time
    Seconds = Micro div 1000000,
    H = Seconds div 3600,
    M = (Seconds rem 3600) div 60,
    S = Seconds rem 60,
    {H, M, S, Micro rem 1000000}.

%%% ---------------------------------------------------------------------------
%%% # eval(Func)
%%% ---------------------------------------------------------------------------

eval({M,F,A}) ->
    apply(M,F,A);

eval([{M,F,A} | X]) ->
    apply(M, F, X ++ A);

eval([[F|A] | X]) ->
    eval([F | X ++ A]);

eval([F|A]) ->
    apply(F,A);

eval({F}) ->
    eval(F);

eval(F) ->
    F().

%%% ---------------------------------------------------------------------------
%%% # ip4address(Addr)
%%%
%%% Input:  string()   (eg. "10.0.0.1")
%%%         | list of integer()
%%%         | tuple of integer()
%%%
%%% Output: {_,_,_,_} of integer
%%%
%%% Exceptions: error: {invalid_address, Addr, erlang:get_stacktrace()}
%%% ---------------------------------------------------------------------------

ip4address([_,_,_,_] = Addr) -> %% Length 4 string can't be an address.
    ipaddr(list_to_tuple(Addr));

%% Be brutal.
ip4address(Addr) ->
    try
        {_,_,_,_} = ipaddr(Addr)
    catch
        error: _ ->
            erlang:error({invalid_address, Addr, ?STACK})
    end.

%%% ---------------------------------------------------------------------------
%%% # ip6address(Addr)
%%%
%%% Input:  string()   (eg. "1080::8:800:200C:417A")
%%%         | list of integer()
%%%         | tuple of integer()
%%%
%%% Output: {_,_,_,_,_,_,_,_} of integer
%%%
%%% Exceptions: error: {invalid_address, Addr, erlang:get_stacktrace()}
%%% ---------------------------------------------------------------------------

ip6address([_,_,_,_,_,_,_,_] = Addr) -> %% Length 8 string can't be an address.
    ipaddr(list_to_tuple(Addr));

%% Be brutal.
ip6address(Addr) ->
    try
        {_,_,_,_,_,_,_,_} = ipaddr(Addr)
    catch
        error: _ ->
            erlang:error({invalid_address, Addr, ?STACK})
    end.

%%% ---------------------------------------------------------------------------
%%% # ipaddr(Addr)
%%%
%%% Input:  string() | tuple of integer()
%%%
%%% Output: {_,_,_,_} | {_,_,_,_,_,_,_,_}
%%%
%%% Exceptions: error: {invalid_address, erlang:get_stacktrace()}
%%% ---------------------------------------------------------------------------

-spec ipaddr(string() | tuple())
   -> inet:ip_address().

%% Don't convert lists of integers since a length 8 list like
%% [$1,$0,$.,$0,$.,$0,$.,$1] is ambiguous: is it "10.0.0.1" or
%% "49:48:46:48:46:48:46:49"?
%%
%% RFC 2373 defines the format parsed for v6 addresses.

%% Be brutal.
ipaddr(Addr) ->
    try
        ip(Addr)
    catch
        error: _ ->
            erlang:error({invalid_address, ?STACK})
    end.

%% Already a tuple: ensure non-negative integers of the right size.
ip(T)
  when size(T) == 4;
       size(T) == 8 ->
    Bs = 2*size(T),
    [] = lists:filter(fun(N) when 0 =< N -> 0 < N bsr Bs end,
                      tuple_to_list(T)),
    T;

%% Or not: convert from '.'/':'-separated decimal/hex.
ip(Addr) ->
    {ok, A} = inet_parse:address(Addr),  %% documented in inet(3)
    A.

%%% ---------------------------------------------------------------------------
%%% # spawn_opts(Type, Opts)
%%% ---------------------------------------------------------------------------

%% TODO: config variables.

spawn_opts(server, Opts) ->
    opts(75000, Opts);
spawn_opts(worker, Opts) ->
    opts(5000, Opts).

opts(HeapSize, Opts) ->
    [{min_heap_size, HeapSize} | lists:keydelete(min_heap_size, 1, Opts)].

%%% ---------------------------------------------------------------------------
%%% # wait(MRefs)
%%% ---------------------------------------------------------------------------

wait(L) ->
    w([erlang:monitor(process, P) || P <- L]).

w([]) ->
    ok;
w(L) ->
    receive
        {'DOWN', MRef, process, _, _} ->
            w(lists:delete(MRef, L))
    end.

%%% ---------------------------------------------------------------------------
%%% # fold_tuple(N, T0, T)
%%% ---------------------------------------------------------------------------

%% Replace fields in T0 by those of T starting at index N, unless the
%% new value is 'undefined'.
%%
%% eg. fold_tuple(2, Hdr, #diameter_header{end_to_end_id = 42})

fold_tuple(_, T, undefined) ->
    T;

fold_tuple(N, T0, T1) ->
    {_, T} = lists:foldl(fun(V, {I,_} = IT) -> {I+1, ft(V, IT)} end,
                         {N, T0},
                         lists:nthtail(N-1, tuple_to_list(T1))),
    T.

ft(undefined, {_, T}) ->
    T;
ft(Value, {Idx, T}) ->
    setelement(Idx, T, Value).