mod app;
mod database;
mod manager;
mod models;
mod router;

use std::{env, net::SocketAddr};

use database::types::{DayOfWeek, WorkTime};

#[derive(Debug, Clone)]
struct AssignmentRules {
    days: [DayOfWeek; 7],
    shifts: [WorkTime; 3],
    max_shifts_per_employee_per_day: u8,
    max_days_per_employee_per_week: u8,
    min_employees_per_shift: u8,
    conflict_strategy: &'static str,
}

impl AssignmentRules {
    fn is_valid(&self) -> bool {
        self.days.len() == 7
            && self.shifts.len() == 3
            && self.max_shifts_per_employee_per_day == 1
            && self.max_days_per_employee_per_week == 5
            && self.min_employees_per_shift == 2
            && !self.conflict_strategy.is_empty()
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    let database_url = env::var("DATABASE_URL")?;
    let pool = database::connection::connect(&database_url).await?;
    database::connection::init_database(&pool).await?;
    debug_assert!(assignment_rules().is_valid());

    let router = router::build_router(pool);

    let address = env::var("APP_ADDRESS")
        .unwrap_or_else(|_| "127.0.0.1:5005".to_string())
        .parse::<SocketAddr>()?;

    let listener = tokio::net::TcpListener::bind(address).await?;
    axum::serve(listener, router).await?;

    Ok(())
}

fn assignment_rules() -> AssignmentRules {
    AssignmentRules {
        days: models::shift::define_day_values(),
        shifts: models::shift::define_shift_values(),
        max_shifts_per_employee_per_day: 1,
        max_days_per_employee_per_week: 5,
        min_employees_per_shift: 2,
        conflict_strategy: "try same-day alternative shifts, then next-day preferences",
    }
}