use anyhow::{Context, Result};
use axum::Router;
use axum::serve::ListenerExt;
use sqlx::sqlite::SqlitePool;
use std::net::SocketAddr;
use tower_http::services::ServeDir;
use tracing::trace;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod place;
mod routes;

#[tokio::main]
async fn main() -> Result<()> {
    dotenvy::dotenv().unwrap_or_default();
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "huellas=debug".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let db_url = dotenvy::var("DATABASE_URL").context("DATABASE_URL not defined")?;
    let pool = SqlitePool::connect(&db_url)
        .await
        .context("Couldn't connect to database")?;

    sqlx::migrate!()
        .run(&pool)
        .await
        .context("Couldn't run migrations")?;

    let app = Router::new()
        .nest("/places", routes::places_routes(pool))
        .nest_service("/", ServeDir::new("static"));

    let port = dotenvy::var("PORT").unwrap_or_default();
    let port = str::parse(&port).unwrap_or(3000);
    let address = SocketAddr::from(([0, 0, 0, 0], port));
    tracing::debug!("listening on {}", address);
    let listener = tokio::net::TcpListener::bind(address)
        .await?
        .tap_io(|tcp_stream| {
            if let Err(err) = tcp_stream.set_nodelay(true) {
                trace!("failed to set TCP_NODELAY on incoming connection: {err:#}");
            }
        });
    axum::serve(listener, app.into_make_service())
        .with_graceful_shutdown(shutdown_signal())
        .await?;

    Ok(())
}

async fn shutdown_signal() {
    tokio::signal::ctrl_c()
        .await
        .expect("failed to listen for ctrl-c");
    tracing::debug!("Received shutdown signal");
}