use std::sync::Arc;

use axum::{
    http::{StatusCode, Uri},
    response::IntoResponse,
};
use axum_extra::routing::RouterExt;

use crate::state::AppState;

mod healthcheck;
mod login;
mod register;
mod user;

#[tracing::instrument]
pub fn init_router(state: Arc<AppState>) -> axum::Router {
    axum::Router::new()
        // .route("/api/user", get(get_user))
        .typed_get(healthcheck::HealthCheck::get)
        .typed_get(user::UserUuid::get)
        .typed_post(register::Register::post)
        .typed_post(login::Login::post)
        .fallback(fallback)
        .with_state(state)
}

pub async fn fallback(uri: Uri) -> impl IntoResponse {
    (StatusCode::NOT_FOUND, format!("Route not found: {uri}"))
}

#[cfg(test)]
mod tests {
    use super::*;

    use axum::{
        body::Body,
        http::{Request, StatusCode},
    };
    use sqlx::PgPool;
    use tower::ServiceExt;

    use crate::Error;

    const JWT_SECRET: &str = "test-jwt-secret-token";
    const JWT_MAX_AGE: time::Duration = time::Duration::HOUR;

    #[sqlx::test]
    async fn test_route_not_found(pool: PgPool) -> Result<(), Error> {
        let state = Arc::new(AppState {
            pool,
            jwt_secret: JWT_SECRET.to_string(),
            jwt_max_age: JWT_MAX_AGE,
        });
        let router = init_router(state.clone());

        let response = router
            .oneshot(
                Request::builder()
                    .uri("/does-not-exist")
                    .body(Body::empty())
                    .unwrap(),
            )
            .await
            .unwrap();

        assert_eq!(StatusCode::NOT_FOUND, response.status());

        Ok(())
    }
}