use axum::{
    body::HttpBody,
    extract::ConnectInfo,
    http::{Request, StatusCode},
    middleware::{self, Next},
    response::Response,
    Extension, RequestExt, Router,
};
use std::{net::SocketAddr, process::exit};
use tower_cookies::CookieManagerLayer;
use tracing::{error, info, metadata::LevelFilter};
use tracing_subscriber::{
    filter::filter_fn, prelude::__tracing_subscriber_SubscriberExt, util::SubscriberInitExt, Layer,
};
use types::http::ResponseCode;

use crate::{
    api::{auth, pages, posts, users},
    types::extract::RouterURI,
};

mod api;
mod console;
mod database;
mod types;

async fn serve<B>(req: Request<B>, next: Next<B>) -> Response
where
    B: Send + Sync + 'static + HttpBody,
{
    let uri = req.uri();
    let file = ResponseCode::Success.file(&uri.to_string()).await;
    if file.status() != StatusCode::OK {
        return next.run(req).await;
    }
    file
}

async fn log<B>(mut req: Request<B>, next: Next<B>) -> Response
where
    B: Send + Sync + 'static + HttpBody,
{
    let Ok(ConnectInfo(info)) = req.extract_parts::<ConnectInfo<SocketAddr>>().await else {
        return next.run(req).await
    };

    console::log(
        info.ip(),
        req.method().clone(),
        req.uri().clone(),
        None,
        None,
    )
    .await;

    next.run(req).await
}

async fn not_found() -> Response {
    ResponseCode::NotFound.file("/404.html").await
}

#[tokio::main]
async fn main() {
    let fmt_layer = tracing_subscriber::fmt::layer();
    tracing_subscriber::registry()
        .with(
            fmt_layer
                .with_filter(LevelFilter::TRACE)
                .with_filter(filter_fn(|metadata| {
                    metadata.target().starts_with("xssbook")
                })),
        )
        .init();

    if database::init().is_err() {
        error!("Failed to connect to the sqlite database");
        exit(1)
    };

    let app = Router::new()
        .fallback(not_found)
        .nest("/", pages::router())
        .layer(middleware::from_fn(log))
        .layer(middleware::from_fn(serve))
        .nest(
            "/api/auth",
            auth::router().layer(Extension(RouterURI("/api/auth"))),
        )
        .nest(
            "/api/users",
            users::router().layer(Extension(RouterURI("/api/users"))),
        )
        .nest(
            "/api/posts",
            posts::router().layer(Extension(RouterURI("/api/posts"))),
        )
        .layer(CookieManagerLayer::new());

    let Ok(addr) = "[::]:8080".parse::<std::net::SocketAddr>() else {
        error!("Failed to parse port binding");
        exit(1)
    };

    info!("listening on {}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service_with_connect_info::<SocketAddr>())
        .await
        .unwrap_or(());
}