use std::net::SocketAddr;

use axum::{middleware, routing::get, Router};
use rand_core::{OsRng, RngCore};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use witch_watch::{
    db,
    generic_handlers::{handle_slash, handle_slash_redir},
    login::{get_login, get_logout, post_login, post_logout},
    signup::{get_create_user, handle_signup_success, post_create_user},
    users,
};

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "witch_watch=debug,axum::routing=info".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let pool = db::get_pool().await;

    let secret = {
        let mut bytes = [0u8; 64];
        let mut rng = OsRng;
        rng.fill_bytes(&mut bytes);
        bytes
    };

    let session_layer = db::session_layer(pool.clone(), &secret).await;
    let auth_layer = db::auth_layer(pool.clone(), &secret).await;

    let app = Router::new()
        .route("/", get(handle_slash).post(handle_slash))
        .route("/signup", get(get_create_user).post(post_create_user))
        .route(
            "/signup_success/:id",
            get(handle_signup_success).post(handle_signup_success),
        )
        .route("/login", get(get_login).post(post_login))
        .route("/logout", get(get_logout).post(post_logout))
        .fallback(handle_slash_redir)
        .route_layer(middleware::from_fn_with_state(
            pool.clone(),
            users::handle_update_last_seen,
        ))
        .layer(auth_layer)
        .layer(session_layer)
        .with_state(pool);

    let addr = ([127, 0, 0, 1], 3000);
    tracing::debug!("binding to 0.0.0.0:3000");
    axum::Server::bind(&SocketAddr::from(addr))
        .serve(app.into_make_service())
        .await
        .unwrap();
}