GenEvent สำหรับการจัดการเหตุการณ์

-module(event_manager_starter).
-export([start/0]).

start() ->
    % Start a local event manager named 'my_app_events'
    {ok, Pid} = gen_event:start_link({local, my_app_events}),
    io:format("Event manager started with PID: ~p~n", [Pid]),
    ok.

-module(my_event_handler).
-behaviour(gen_event).

-export([init/1, handle_event/2, terminate/2]).

init(Args) ->
    io:format("Handler initialized with args: ~p~n", [Args]),
    {ok, []}. % Returns initial state

handle_event(Event, State) ->
    io:format("Handler received event: ~p~n", [Event]),
    % Here you'd process the event
    {ok, State}. % Return new state

terminate(_Args, _State) ->
    io:format("Handler terminating.~n", []),
    ok.

-module(handler_adder).
-export([add_to_manager/1]).

add_to_manager(ManagerName) ->
    % The handler module name (my_event_handler)
    % and any initial arguments for its init/1 function ([] in this case)
    gen_event:add_handler(ManagerName, my_event_handler, []),
    io:format("Handler 'my_event_handler' added to '~p'.~n", [ManagerName]),
    ok.

-module(event_publisher).
-export([send_alert/2]).

send_alert(ManagerName, Message) ->
    Event = {alert, Message, os:timestamp()},
    io:format("Publisher sending event: ~p to manager '~p'.~n", [Event, ManagerName]),
    gen_event:notify(ManagerName, Event).

-module(gen_event_demo).
-export([start/0]).

% --- Inline Handler Module for Demo ---
% In a real app, this would be a separate .erl file.
my_demo_handler() ->
    % Compile and load a temporary handler module
    code:delete(demo_handler_impl),
    code:purge(demo_handler_impl),
    {ok, _} = compile:forms([
        '-module(demo_handler_impl).',
        '-behaviour(gen_event).',
        '-export([init/1, handle_event/2, terminate/2]).',
        'init(Args) -> {ok, Args}.',
        'handle_event(Event, State) ->',
        '    io:format("*** Handler received: ~p~n", [Event]),',
        '    {ok, State}.',
        'terminate(_Args, _State) -> ok.'
    ], []),
    demo_handler_impl.

% --- Main Application Logic ---
start() ->
    ManagerName = my_system_events,
    HandlerModule = my_demo_handler(),

    io:format("--- Starting GenEvent Demo ---~n"),

    % 1. Start the event manager
    {ok, _ManagerPid} = gen_event:start_link({local, ManagerName}),
    io:format("Manager '~p' started.~n", [ManagerName]),

    % 2. Add the handler to the manager
    gen_event:add_handler(ManagerName, HandlerModule, []), 
    io:format("Handler '~p' added.~n", [HandlerModule]),

    % 3. Publish some events
    io:format("Sending first event...~n"),
    gen_event:notify(ManagerName, {user_logged_in, "Alice"}),
    timer:sleep(100), % Give time for event processing

    io:format("Sending second event...~n"),
    gen_event:notify(ManagerName, {sensor_reading, 25.5}),
    timer:sleep(100),

    io:format("Sending third event...~n"),
    gen_event:notify(ManagerName, {error_alert, "Disk_full"}),
    timer:sleep(100),

    % 4. Stop the manager (optional, for clean exit)
    gen_event:stop(ManagerName),
    io:format("--- GenEvent Demo Finished ---~n"),
    ok.