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

use anyhow::Result;
use axum::{Router, middleware, response::Response};
use tower_cookies::CookieManagerLayer;
use tower_http::services::ServeDir;
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

use crate::{
    model::FileController,
    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=info", env!("CARGO_CRATE_NAME")).into()
            }),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let file_controller = FileController::new().await?;

    let routes_file =
        routes_file(file_controller.clone()).route_layer(middleware::from_fn(mw_require_auth));

    let app = Router::new()
        .nest("/api", routes_file)
        .merge(routes_health())
        .merge(routes_login())
        .layer(middleware::map_response(main_response_mapper))
        .layer(middleware::from_fn_with_state(
            file_controller,
            mw_ctx_resolver,
        ))
        .layer(CookieManagerLayer::new())
        .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
}