mod ctx;
mod error;
mod model;
mod web;

use anyhow::Result;
use axum::{
    Router,
    extract::DefaultBodyLimit,
    http::{HeaderValue, Method, header},
    middleware,
    response::Response,
};
use tower_cookies::CookieManagerLayer;
use tower_http::{cors::CorsLayer, services::ServeDir, trace::TraceLayer};
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

use crate::{
    model::FileRepository,
    web::{
        mw_auth::{mw_ctx_resolver, mw_require_auth},
        routes_file::routes_file,
        routes_health::routes_health,
        routes_login::routes_login,
    },
};

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
                format!("{}=info,tower_http=debug", env!("CARGO_CRATE_NAME")).into()
            }),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let file_repository = FileRepository::new().await?;

    let routes_file = routes_file(file_repository.clone())
        .route_layer(middleware::from_fn(mw_require_auth))
        .layer(DefaultBodyLimit::disable());

    let app = Router::new()
        .nest("/api", routes_file)
        .merge(routes_health())
        .merge(routes_login())
        .layer(TraceLayer::new_for_http())
        .layer(middleware::map_response(main_response_mapper))
        .layer(middleware::from_fn_with_state(
            file_repository,
            mw_ctx_resolver,
        ))
        .layer(CookieManagerLayer::new())
        .layer(
            CorsLayer::new()
                .allow_origin("http://localhost:5173".parse::<HeaderValue>().unwrap())
                .allow_methods([Method::GET, Method::POST, Method::DELETE])
                .allow_credentials(true)
                .allow_headers([header::CONTENT_TYPE]),
        )
        .fallback_service(ServeDir::new("./"));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
    info!("listening on {}", listener.local_addr().unwrap());

    axum::serve(listener, app).await?;

    Ok(())
}

async fn main_response_mapper(res: Response) -> Response {
    info!("response mapper: {}", res.status());
    res
}