use std::net::SocketAddr;

use axum::{
    extract::{FromRef, State},
    response::IntoResponse,
    routing::get,
    Router,
};
use nefarious_login::{
    auth::AuthService,
    axum::{AuthController, UserFromSession},
};

#[derive(Clone)]
struct AppState {
    auth: AuthService,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt().init();

    // Change to zitadel test instance
    let auth_service = AuthService::new_noop();

    let state = AppState {
        auth: auth_service.clone(),
    };

    let app = Router::new()
        .route("/unauthed", get(unauthed))
        .route("/authed", get(authed))
        .with_state(state)
        .nest("/auth", AuthController::new_router(auth_service).await?);

    let addr = SocketAddr::from(([127, 0, 0, 1], 3001));
    println!("listening on: {addr}");
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();

    Ok(())
}

impl FromRef<AppState> for AuthService {
    fn from_ref(input: &AppState) -> Self {
        input.auth.clone()
    }
}

async fn unauthed() -> String {
    "Hello Unauthorized User".into()
}

#[axum::debug_handler()]
async fn authed(
    user: UserFromSession,
    State(_auth_service): State<AuthService>,
) -> impl IntoResponse {
    format!("Hello authorized user: {:?}", user.user.id)
}