use std::env;
use std::sync::Arc;
use std::time::Duration;
use sqlx::postgres::PgPoolOptions;
use tokio::time;

mod tasks;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt::init();
    tracing::info!("Starting NXTGAUGE Cron Expiry Engine...");

    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&db_url)
        .await?;

    let mailer = Arc::new(email::Mailer::new());

    // Spawn 15-minute lead request expiry task
    let p_lead_sys = pool.clone();
    let m_lead_sys = Arc::clone(&mailer);
    tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_secs(15 * 60));
        loop {
            interval.tick().await;
            tracing::info!("Running Lead Request Expiry Task...");
            if let Err(e) = tasks::leads::expire_stale_lead_requests(&p_lead_sys, &m_lead_sys).await {
                tracing::error!("Lead Expiry Task Failed: {}", e);
            }
        }
    });

    // Spawn Hourly Lead expiry task
    let p_req_sys = pool.clone();
    let m_req_sys = Arc::clone(&mailer);
    tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_secs(60 * 60));
        loop {
            interval.tick().await;
            tracing::info!("Running Lead Expiry Task...");
            if let Err(e) = tasks::requirements::expire_stale_leads(&p_req_sys, &m_req_sys).await {
                tracing::error!("Lead Expiry Task Failed: {}", e);
            }
        }
    });

    // Spawn Hourly Job Expiry task
    let p_job_sys = pool.clone();
    let m_job_sys = Arc::clone(&mailer);
    tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_secs(60 * 60));
        loop {
            interval.tick().await;
            tracing::info!("Running Job Expiry Task...");
            if let Err(e) = tasks::jobs::expire_stale_jobs(&p_job_sys, &m_job_sys).await {
                tracing::error!("Job Expiry Task Failed: {}", e);
            }
        }
    });

    // Spawn Daily Reminder task
    let p_rem_sys = pool.clone();
    let m_rem_sys = Arc::clone(&mailer);
    tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_secs(24 * 60 * 60));
        loop {
            interval.tick().await;
            tracing::info!("Running Daily Reminders Task...");
            if let Err(e) = tasks::reminders::send_expiry_reminders(&p_rem_sys, &m_rem_sys).await {
                tracing::error!("Reminders Task Failed: {}", e);
            }
        }
    });

    // Keep main thread alive
    tokio::signal::ctrl_c().await?;
    tracing::info!("Shutting down cron engine.");

    Ok(())
}