use std::{net::SocketAddr, time::Duration};

use axum::{routing::get, Router};
use axum_login::{
    axum_sessions::{PersistencePolicy, SessionLayer},
    AuthLayer, SqliteStore,
};
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},
    session_store::SqliteSessionStore,
    signup::{get_create_user, handle_signup_success, post_create_user},
    User,
};

#[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 = {
        let store = SqliteSessionStore::from_client(pool.clone());
        store.migrate().await.expect("Could not migrate session DB");
        SessionLayer::new(store, &secret)
            .with_secure(true)
            .with_persistence_policy(PersistencePolicy::ExistingOnly)
            .with_session_ttl(Some(Duration::from_secs(3600 * 24 * 366)))
    };

    let auth_layer = {
        const QUERY: &str = "select * from witches where id = $1";
        let store = SqliteStore::<User>::new(pool.clone()).with_query(QUERY);
        AuthLayer::new(store, &secret)
    };

    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)
        .layer(auth_layer)
        .layer(session_layer)
        .with_state(pool);

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