{deps, [
    {arizona, {git, "https://github.com/arizona-framework/arizona", {branch, "main"}}}
]}.

-module(home_view).
-behaviour(arizona_view).
-compile({parse_transform, arizona_parse_transform}).
-export([mount/2, render/1, handle_event/3]).

mount(_Arg, _Request) ->
    arizona_view:new(
        ?MODULE,
        #{
            id => ~"home",
            greeting => ~"Hello, Arizona!",
            count => 0
        },
        none  % No layout
    ).

render(Bindings) ->
    arizona_template:from_html(~"""
    <div id="{arizona_template:get_binding(id, Bindings)}">
        <h1>{arizona_template:get_binding(greeting, Bindings)}</h1>
        <p>Clicked: {arizona_template:get_binding(count, Bindings)} times</p>
        <button onclick="arizona.pushEvent('increment')">Click me</button>
    </div>
    """).

handle_event(~"increment", _Params, View) ->
    State = arizona_view:get_state(View),
    Count = arizona_stateful:get_binding(count, State),
    NewState = arizona_stateful:put_binding(count, Count + 1, State),
    {[], arizona_view:update_state(NewState, View)}.

[
    {arizona, [
        {server, #{
            enabled => true,
            scheme => http,  % or https
            transport_opts => [{port, 1912}],  % Cowboy/Ranch transport options
            proto_opts => #{env => #{custom_option => value}},  % Optional Cowboy protocol options
            routes => [
                {view, ~"/", home_view, #{}, []},  % Empty middleware list
                {websocket, ~"/live", #{}, []},    % WebSocket options + middleware list
                {controller, ~"/api/presence", my_api_controller, #{}, []},  % Plain Cowboy handler
                {asset, ~"/assets", {priv_dir, arizona, ~"static/assets"}, []}  % Required for live features
            ]
        }},
        {reloader, #{
            enabled => true,  % Enable file watcher coordination
            rules => [
                #{
                    handler => {my_erlang_handler, #{profile => dev}},  % {Module, Options}
                    watcher => #{
                        directories => ["src"],
                        patterns => [".*\\.erl$"],
                        debounce_ms => 100
                    }
                }
            ]
        }}
    ]}
].

{ok, _Started} = application:ensure_all_started(arizona).

% Configure the application environment
application:set_env([{arizona, [
    {server, #{
        enabled => true,
        scheme => http,
        transport_opts => [{port, 1912}],
        routes => [
            {view, ~"/", home_view, #{}, []},
            {websocket, ~"/live", #{}, []},
            {asset, ~"/assets", {priv_dir, arizona, ~"static/assets"}, []}
        ]
    }},
    {reloader, #{enabled => false}}  % Typically disabled when using programmatic config
]}]),

% Start the application
{ok, _Started} = application:ensure_all_started(arizona).

% You must implement your own handler modules:

% Example:
-module(my_erlang_handler).
-behaviour(arizona_reloader).
-export([reload/2]).

reload(Files, Options) ->
    Profile = maps:get(profile, Options, default),
    io:format("Compiling ~p with profile ~p~n", [Files, Profile]),
    % Your custom build logic here
    ok.

% Inline HTML template
arizona_template:from_html(~"""
<div>
    <h1>{arizona_template:get_binding(title, Bindings)}</h1>
    <p>User: {arizona_template:get_binding(username, Bindings)}</p>
</div>
""")

% File-based template with compile-time optimization
arizona_template:from_html({file, "templates/user.html"})
arizona_template:from_html({priv_file, myapp, "templates/user.html"})

arizona_template:from_html(~"""
<div>
    {arizona_template:render_stateful(counter_component, #{
        id => ~"my_counter",
        count => 0
    })}
</div>
""")

arizona_template:from_html(~"""
<div>
    {arizona_template:render_stateless(my_module, render_header, #{
        title => ~"Welcome",
        user => ~"John"
    })}
</div>
""")

arizona_template:from_html(~"""
<ul>
    {arizona_template:render_list(fun(Item) ->
        arizona_template:from_html(~"""
        <li>{arizona_template:get_binding(name, Item)}</li>
        """)
    end, arizona_template:get_binding(items, Bindings))}
</ul>
""")

arizona_template:from_html(~"""
<div>
    {arizona_template:render_map(fun({Key, Value}) ->
        arizona_template:from_html(~"""
        <p>{Key}: {Value}</p>
        """)
    end, #{~"name" => ~"Arizona", ~"type" => ~"Framework"})}
</div>
""")

arizona_template:from_html(~"""
<div class="modal">
    <h1>{arizona_template:render_slot(arizona_template:get_binding(header, Bindings))}</h1>
    <div class="content">
        {arizona_template:render_slot(arizona_template:get_binding(inner_block, Bindings))}
    </div>
</div>
""")

arizona_template:from_html(~"""
<div>
    {% This is a comment and is not rendered }
    <h1>{arizona_template:get_binding(title, Bindings)}</h1>
    <style>
        .css-rule \{ color: blue; }  /* \{ renders as literal { */
    </style>
</div>
""")

% Pure markdown to HTML
{ok, Html} = arizona_markdown:to_html(~"# Hello **World**")
% Returns: ~"<h1>Hello <strong>World</strong></h1>\n"

% Inline markdown template
arizona_template:from_markdown(~"""
# {arizona_template:get_binding(title, Bindings)}
Welcome **{arizona_template:get_binding(user, Bindings)}**!

{% Template comment - not rendered %}

{arizona_template:render_stateful(my_widget_component, #{
    id => ~"widget",
    data => arizona_template:get_binding(widget_data, Bindings)
})}
""")

% File-based markdown template with compile-time optimization
arizona_template:from_markdown({file, "content/blog-post.md"})
arizona_template:from_markdown({priv_file, myapp, "content/blog-post.md"})

% With markdown options
{ok, Html} = arizona_markdown:to_html(~"# Hello", [source_pos, smart])

render(Bindings) ->
    arizona_template:from_markdown(~"""
    # {arizona_template:get_binding(title, Bindings)}

    {arizona_template:get_binding(content, Bindings)}

    {arizona_template:render_stateful(comment_section, #{
        id => ~"comments",
        post_id => arizona_template:get_binding(id, Bindings)
    })}
    """).

-module(timer_component).
-behaviour(arizona_stateful).
-export([mount/1, render/1, handle_event/3, unmount/1]).

mount(Bindings) ->
    % Start a timer when component mounts
    {ok, TimerRef} = timer:send_interval(1000, tick),
    arizona_pubsub:join(~"time_updates", self()),
    NewBindings = Bindings#{timer_ref => TimerRef, seconds => 0},
    arizona_stateful:new(?MODULE, NewBindings).

handle_event(~"tick", _Params, State) ->
    Seconds = arizona_stateful:get_binding(seconds, State),
    NewState = arizona_stateful:put_binding(seconds, Seconds + 1, State),
    {[], NewState}.

% Automatic cleanup when component is unmounted
unmount(State) ->
    % Cancel timer to prevent memory leaks
    case arizona_stateful:get_binding(timer_ref, State) of
        undefined -> ok;
        TimerRef -> timer:cancel(TimerRef)
    end,
    % Unsubscribe from PubSub
    arizona_pubsub:leave(~"time_updates", self()),
    ok.

-module(my_layout).
-compile({parse_transform, arizona_parse_transform}).
-export([render/1]).

render(Bindings) ->
    arizona_template:from_html(~"""
    <!DOCTYPE html>
    <html>
    <head>
        <title>My Arizona App</title>
        <script type="module" async>
            import { Arizona, ArizonaConsoleLogger, LOG_LEVELS } from '@arizona-framework/client';

            // Create client with optional logger
            const logger = new ArizonaConsoleLogger({ logLevel: LOG_LEVELS.info });

            globalThis.arizona = new Arizona({ logger });
            arizona.connect('/live');
        </script>
    </head>
    <body>
        {arizona_template:render_slot(arizona_template:get_binding(main_content, Bindings))}
    </body>
    </html>
    """).

% No action - just update state
{[], NewState}

% Dispatch custom events - subscribe using arizona.on('event_name', callback)
{[{dispatch, ~"dataLoaded", #{status => success, data => Value}}], NewState}
{[{dispatch, ~"notification:show", #{message => ~"Success!"}}], NewState}
{[{dispatch, ~"counter_123:update", #{count => 5}}], NewState}

% Redirect to new URL
{[{redirect, ~"/new-page", #{target => ~"_self"}}], NewState}     % Same tab
{[{redirect, ~"/external", #{target => ~"_blank"}}], NewState}    % New tab

% Redirect with window features
{[{redirect, ~"/popup", #{
    target => ~"popup_window",
    window_features => ~"width=600,height=400,resizable=yes"
}}], NewState}

% Reload the current page
{[reload], NewState}

% Multiple actions - executed in sequence
{[
    {dispatch, ~"taskCompleted", #{message => ~"Saved successfully!"}},
    {redirect, ~"/dashboard", #{target => ~"_self"}}
], NewState}

routes => [
    % View routes with authentication middleware
    {view, ~"/admin", admin_view, #{}, [
        {auth_middleware, #{jwt_secret => ~"secret123", redirect_on_fail => true}},
        {role_middleware, #{required_role => admin}}
    ]},

    % Controller routes with CORS and auth
    {controller, ~"/api/users", users_controller, #{}, [
        {cors_middleware, #{origins => [~"https://app.com"]}},
        {auth_middleware, #{jwt_secret => ~"secret123"}}
    ]},

    % WebSocket routes with authentication
    {websocket, ~"/live", #{idle_timeout => 60000}, [
        {auth_middleware, #{jwt_secret => ~"secret123"}}
    ]},

    % Asset routes with authentication (for protected files)
    {asset, ~"/private", {priv_dir, myapp, ~"private"}, [
        {auth_middleware, #{jwt_secret => ~"secret123"}}
    ]},

    % Public routes with no middlewares
    {view, ~"/public", public_view, #{}, []}
]

-module(auth_middleware).
-behaviour(arizona_middleware).
-export([execute/2]).

execute(Req, #{jwt_secret := Secret} = Opts) ->
    case cowboy_req:header(~"authorization", Req) of
        <<"Bearer ", Token/binary>> ->
            case validate_jwt(Token, Secret) of
                {ok, Claims} ->
                    % Add user info for downstream middlewares/handlers
                    Req1 = cowboy_req:set_meta(user_claims, Claims, Req),
                    {continue, Req1};
                {error, _} ->
                    Req1 = cowboy_req:reply(401, #{}, ~"Invalid token", Req),
                    {halt, Req1}
            end;
        undefined ->
            case maps:get(redirect_on_fail, Opts, false) of
                true ->
                    % Redirect to login for views
                    Req1 = cowboy_req:reply(302, #{~"location" => ~"/login"}, ~"", Req),
                    {halt, Req1};
                false ->
                    % JSON error for APIs
                    Req1 = cowboy_req:reply(401, #{}, ~"Unauthorized", Req),
                    {halt, Req1}
            end
    end.

validate_jwt(_Token, _Secret) ->
    % Your JWT validation logic
    {ok, #{user_id => ~"123", role => ~"admin"}}.

-module(my_auth_plugin).
-behaviour(arizona_plugin).
-export([transform_config/2]).

transform_config(Config, PluginConfig) ->
    JwtSecret = maps:get(jwt_secret, PluginConfig),

    % Transform routes to add auth middleware to protected paths
    ServerConfig = maps:get(server, Config),
    Routes = maps:get(routes, ServerConfig, []),
    NewRoutes = lists:map(fun(Route) ->
        case Route of
            {view, Path, ViewModule, MountArg, Middlewares} when
                binary:match(Path, <<"admin">>) =/= nomatch ->
                % Add auth middleware to admin routes
                AuthMiddleware = {auth_middleware, #{jwt_secret => JwtSecret}},
                {view, Path, ViewModule, MountArg, [AuthMiddleware | Middlewares]};
            Other ->
                Other
        end
    end, Routes),

    UpdatedServerConfig = ServerConfig#{routes => NewRoutes},
    Config#{server => UpdatedServerConfig}.

[
    {arizona, [
        {server, #{
            enabled => true,
            transport_opts => [{port, 1912}],
            routes => [
                {view, ~"/", home_view, #{}, []},
                {view, ~"/admin", admin_view, #{}, []},  % Plugin will add auth middleware
                {controller, ~"/api/users", users_controller, #{}, []}
            ]
        }},

        % Configure plugins with their options
        {plugins, [
            {my_auth_plugin, #{jwt_secret => "secret123"}},
            {my_cors_plugin, #{origins => ["*"]}},
            {my_logging_plugin, true}  % Plugin config can be any term
        ]}
    ]}
].

% rebar.config
{deps, [
    {arizona, "~> 1.0"},
    {arizona_auth_plugin, "~> 1.0"}  % Add plugin dependency
]}.

% sys.config - just reference by name
{plugins, [
    {arizona_auth_plugin, #{jwt_secret => "secret123"}}
]}

% In templates - send events to current view
<button onclick="arizona.pushEvent('my_event')">Click</button>

% Send events to specific components
<button onclick="arizona.pushEventTo('component_id', 'increment', \{amount: 5})">+5</button>

% In view/component modules - handle events
handle_event(~"my_event", Params, State) ->
    % Update state and return {Actions, NewState} where Actions is a list
    {[], arizona_stateful:put_binding(updated, true, State)}.

% Example with actions - dispatch custom event to client
handle_event(~"save_data", Params, State) ->
    % Process data and dispatch event to client
    {[{dispatch, ~"dataSaved", #{status => success, id => 123}}], UpdatedState}.

% Example with redirect action
handle_event(~"login_success", _Params, State) ->
    % Redirect user to dashboard after login
    {[{redirect, ~"/dashboard", #{target => ~"_self"}}], State}.

% Example with reload action
handle_event(~"reset_app", _Params, State) ->
    % Reload the entire page
    {[reload], State}.

% Example with multiple actions
handle_event(~"complete_task", _Params, State) ->
    % Dispatch event and then redirect
    Actions = [
        {dispatch, ~"taskCompleted", #{message => ~"Task completed!"}},
        {redirect, ~"/tasks", #{target => ~"_self"}}
    ],
    {Actions, State}.

% Subscribe to topics during mount
mount(_Arg, _Request) ->
    case arizona_live:is_connected(self()) of
        true -> arizona_pubsub:join(~"time_update", self());
        false -> ok
    end,
    arizona_view:new(?MODULE, #{current_time => ~"Loading..."}).

% Publish messages from external processes
arizona_pubsub:broadcast(~"time_update", #{~"time" => TimeString}),

% Handle PubSub messages in views (treated as events)
handle_event(~"time_update", Data, View) ->
    NewTime = maps:get(~"time", Data),
    State = arizona_view:get_state(View),
    UpdatedState = arizona_stateful:put_binding(current_time, NewTime, State),
    {[], arizona_view:update_state(UpdatedState, View)}.

% Views can handle arbitrary Erlang messages
handle_info({timer, update}, View) ->
    % Handle timer or other process messages
    {[], UpdatedView}.

-module(my_custom_handler).
-behaviour(arizona_reloader).
-export([reload/2]).

reload(Files, Options) ->
    % Your custom logic: compile, build, reload, etc.
    io:format("Files changed: ~p with options: ~p~n", [Files, Options]),
    % You implement what happens here
    ok.

% In your reload handler, specify file type for smart client handling
reload(_Files, _Options) ->
    % Compile logic here
    FileType = css,
    arizona_pubsub:broadcast(~"arizona:reload", FileType).

arizona_static:generate(#{
    route_paths => #{
        ~"/" => #{},
        ~"/about" => #{parallel => true},
        ~"/posts/123" => #{parallel => false}
    },
    output_dir => ~"_site"
}).

[
    {arizona, [
        {server, #{
            enabled => true,
            scheme => https,  % Use HTTPS in production
            transport_opts => #{
                socket_opts => [{port, 443}],
                % Add SSL certificates and options
                ssl_opts => [
                    {certfile, "/path/to/cert.pem"},
                    {keyfile, "/path/to/key.pem"}
                ]
            },
            proto_opts => #{
                env => #{
                    max_keepalive => 100,
                    timeout => 60000
                }
            },
            routes => YourRoutes
        }},
        {reloader, #{enabled => false}}  % Disable file watchers in production
    ]}
].

{ok, _Started} = application:ensure_all_started(arizona).

{asset, ~"/assets", {priv_dir, arizona, ~"static/assets"}, []}