%% 
%% %CopyrightBegin%
%% 
%% Copyright Ericsson AB 2003-2015. 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%
%% 

%%----------------------------------------------------------------------
%% Purpose: Simple (snmp) manager used when performing appup tests.
%%----------------------------------------------------------------------
-module(snmp_appup_mgr).

-behaviour(snmpm_user).

-include_lib("snmp/include/STANDARD-MIB.hrl").
-include_lib("snmp/include/snmp_types.hrl").

-export([start/0, start/1, start/2]).
-export([handle_error/3, 
	 handle_agent/4,
	 handle_pdu/5,
	 handle_trap/4,
	 handle_inform/4,
	 handle_report/4]).
-export([main/2]).

-record(agent, {host, port, conf}).
-record(state, {timer, reqs, ids, agent}).

-define(USER_ID,      ?MODULE).
-define(REQ_TIMEOUT,  10000).
-define(POLL_TIMEOUT, 5000).
-define(DEFAULT_PORT, 4000).
%% -define(DEFAULT_PORT, 161).

-define(v1_2(V1,V2),
	case get(vsn) of
	    v1 -> V1;
	    _  -> V2
	end).


start() ->
    {ok, AgentHost} = inet:gethostname(),
    AgentPort = ?DEFAULT_PORT,
    start(AgentHost, AgentPort).

start(AgentPort) when is_integer(AgentPort) ->
    {ok, AgentHost} = inet:gethostname(),
    start(AgentHost, AgentPort);
start(AgentHost) when is_list(AgentHost) ->
    AgentPort = 161,
    start(AgentHost, AgentPort).

start(AgentHost, AgentPort) 
  when is_list(AgentHost) and is_integer(AgentPort) ->
    ensure_started(snmp),
    Pid = erlang:spawn_link(?MODULE, main, [AgentHost, AgentPort]),
    receive
	{'EXIT', Pid, normal} ->
	    ok;
	{'EXIT', Pid, Reason} ->
	    {error, {unexpected_exit, Reason}}
    end.

ensure_started(App) ->
    case application:start(App) of
	ok ->
	    ok;
	{error, {already_started, _}} ->
	    ok;
	{error, Reason} ->
	    exit(Reason)
    end.

poll_timer() ->
    poll_timer(first).

poll_timer(How) ->
    erlang:send_after(?POLL_TIMEOUT, self(), {poll_timeout, How}).

next_poll_type(first) ->
    all;
next_poll_type(all) ->
    first.

main(AgentHost, AgentPort) ->
    ok = snmpm:register_user_monitor(?USER_ID, ?MODULE, self()),
    AgentConf = [{community, "all-rights"},
		 {engine_id, "agentEngine"},
		 {sec_level, noAuthNoPriv},
		 {version,   v1}],
    ok = snmpm:register_agent(?USER_ID, AgentHost, AgentPort, AgentConf),
    Reqs = [{"sysDescr",    get, ?sysDescr_instance},
	    {"sysObjectID", get, ?sysObjectID_instance},
	    {"sysUpTime",   get, ?sysUpTime_instance}],
    Agent = #agent{host = AgentHost, port = AgentPort, conf = AgentConf},
    State = #state{timer = poll_timer(), reqs = Reqs, agent = Agent},
    loop(State).

loop(State) ->
    receive
	{poll_timeout, How} ->
	    NewState = handle_poll_timeout(State, How),
	    loop(NewState#state{timer = poll_timer(next_poll_type(How))});
	
	{req_timeout, ReqId} ->
	    NewState = handle_req_timeout(State, ReqId),
	    loop(NewState);

	{snmp_callback, Info} ->
	    NewState = handle_snmp(State, Info),
	    loop(NewState)
    end.


handle_poll_timeout(#state{agent = Agent, reqs = [Req|Reqs], ids = IDs} = S, 
	       first) ->
    ReqId = handle_req(Agent, [Req]),
    S#state{reqs = Reqs ++ [Req], ids = [ReqId|IDs]};
handle_poll_timeout(#state{agent = Agent, reqs = Reqs, ids = IDs} = S, all) ->
    ReqId = handle_req(Agent, Reqs),
    S#state{ids = [ReqId|IDs]}.

handle_req(#agent{host = Host, port = Port}, Reqs) ->
    Oids  = [Oid  || {_Desc, Op, Oid} <- Reqs, Op == get],
    Descs = [Desc || {Desc, Op, _Oid} <- Reqs, Op == get],
    {ok, ReqId} = snmpm:ag(?USER_ID, Host, Port, Oids),
    p("issued get-request (~w) for: ~s", [ReqId, oid_descs(Descs)]),
    ReqTimer = erlang:send_after(?REQ_TIMEOUT, self(), {req_timeout, ReqId}),
    {ReqId, erlang:monotonic_time(micro_seconds), ReqTimer}.

oid_descs([]) ->
    [];
oid_descs([Desc]) ->
    lists:flatten(io_lib:format("~s", [Desc]));
oid_descs([Desc|Descs]) ->
    lists:flatten(io_lib:format("~s, ", [Desc])) ++ oid_descs(Descs).

handle_req_timeout(#state{ids = IDs0} = State, ReqId) ->
    case lists:keysearch(ReqId, 1, IDs0) of
	{value, {ReqId, _T, _Ref}} ->
	    e("Request timeout for request ~w", [ReqId]),
	    IDs = lists:keydelete(ReqId, 1, IDs0),
	    State#state{ids = IDs};
	false ->
	    w("Did not find request corresponding to id ~w", [ReqId]),
	    State
    end.
    
handle_snmp(#state{ids = IDs0} = S, {error, ReqId, Reason}) ->
    case lists:keysearch(ReqId, 1, IDs0) of
	{value, {ReqId, T, Ref}} ->
	    Diff = erlang:monotonic_time(micro_seconds) - T,
	    p("SNMP error regarding outstanding request after ~w microsec:"
	      "~n   ReqId:  ~w"
	      "~n   Reason: ~w", [Diff, ReqId, Reason]),
	    IDs = lists:keydelete(ReqId, 1, IDs0),
	    erlang:cancel_timer(Ref),
	    S#state{ids = IDs};
	false ->
	    w("SNMP error regarding unknown request:"
	      "~n   ReqId:  ~w"
	      "~n   Reason: ~w", [ReqId, Reason]),
	    S
    end;

handle_snmp(State, {agent, Addr, Port, SnmpInfo}) ->
    p("Received agent info:"
      "~n   Addr:     ~w"
      "~n   Port:     ~w"
      "~n   SnmpInfo: ~w", [Addr, Port, SnmpInfo]),
    State;

handle_snmp(#state{ids = IDs0} = S, {pdu, Addr, Port, ReqId, SnmpResponse}) ->
    case lists:keysearch(ReqId, 1, IDs0) of
	{value, {ReqId, T, Ref}} ->
	    Diff = erlang:monotonic_time(micro_seconds) - T,
	    p("SNMP pdu regarding outstanding request after ~w microsec:"
	      "~n   ReqId:        ~w"
	      "~n   Addr:         ~w"
	      "~n   Port:         ~w"
	      "~n   SnmpResponse: ~w", 
	      [Diff, ReqId, Addr, Port, SnmpResponse]),
	    IDs = lists:keydelete(ReqId, 1, IDs0),
	    erlang:cancel_timer(Ref),
	    S#state{ids = IDs};
	false ->
	    w("SNMP pdu regarding unknown request:"
	      "~n   ReqId:        ~w"
	      "~n   Addr:         ~w"
	      "~n   Port:         ~w"
	      "~n   SnmpResponse: ~w", [ReqId, Addr, Port, SnmpResponse]),
	    S
    end;

handle_snmp(State, {trap, Addr, Port, SnmpTrapInfo}) ->
    p("Received trap:"
      "~n   Addr:         ~w"
      "~n   Port:         ~w"
      "~n   SnmpTrapInfo: ~w", [Addr, Port, SnmpTrapInfo]),
    State;

handle_snmp(State, {inform, Addr, Port, SnmpInform}) ->
    p("Received inform:"
      "~n   Addr:       ~w"
      "~n   Port:       ~w"
      "~n   SnmpInform: ~w", [Addr, Port, SnmpInform]),
    State;

handle_snmp(State, {report, Addr, Port, SnmpReport}) ->
    p("Received report:"
      "~n   Addr:       ~w"
      "~n   Port:       ~w"
      "~n   SnmpReport: ~w", [Addr, Port, SnmpReport]),
    State;

handle_snmp(State, Unknown) ->
    p("Received unknown snmp info:"
      "~n   Unknown: ~w", [Unknown]),
    State.


%% -----------------------------------------------------------------------
%% 
%% Manager user callback API
%% 
%% -----------------------------------------------------------------------


handle_error(ReqId, Reason, Pid) ->
    Pid ! {snmp_callback, {error, ReqId, Reason}},
    ignore.

handle_agent(Addr, Port, SnmpInfo, Pid) ->
    Pid ! {snmp_callback, {agent, Addr, Port, SnmpInfo}},
    ignore.

handle_pdu(Addr, Port, ReqId, SnmpResponse, Pid) ->
    Pid ! {snmp_callback, {pdu, Addr, Port, ReqId, SnmpResponse}},
    ignore.

handle_trap(Addr, Port, SnmpTrapInfo, Pid) ->
    Pid ! {snmp_callback, {trap, Addr, Port, SnmpTrapInfo}},
    ignore.

handle_inform(Addr, Port, SnmpInform, Pid) ->
    Pid ! {snmp_callback, {inform, Addr, Port, SnmpInform}},
    ignore.

handle_report(Addr, Port, SnmpReport, Pid) ->
    Pid ! {snmp_callback, {report, Addr, Port, SnmpReport}},
    ignore.


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

e(F, A) ->
    p("*** ERROR ***", F, A).

w(F, A) ->
    p("*** WARNING ***", F, A).

p(F, A) ->
    p("*** INFO ***", F, A).

p(P, F, A) ->
    io:format("~s~nMGR: " ++ F ++ "~n~n", [P|A]).