use solverforge::prelude::*;

// Problem fact: Employee with skills
#[derive(Clone)]
struct Employee {
    name: String,
    skills: Vec<String>,
}

// Planning entity: Shift with employee assignment
#[derive(PlanningEntity, Clone)]
struct Shift {
    #[planning_id]
    id: String,

    #[planning_variable(value_range_provider = "employees")]
    employee: Option<Employee>,

    required_skill: String,
}

// Planning solution: Schedule
#[derive(PlanningSolution, Clone)]
struct Schedule {
    #[problem_fact_collection]
    #[value_range_provider(id = "employees")]
    employees: Vec<Employee>,

    #[planning_entity_collection]
    shifts: Vec<Shift>,

    #[planning_score]
    score: Option<HardSoftScore>,
}

use solverforge::{Constraint, ConstraintFactory, HardSoftScore};

fn define_constraints(factory: ConstraintFactory) -> Vec<Constraint> {
    vec![
        // Hard: Employee must have the required skill
        factory.for_each::<Shift>()
            .filter(|shift| {
                shift.employee.as_ref().map_or(false, |emp| {
                    !emp.skills.contains(&shift.required_skill)
                })
            })
            .penalize(HardSoftScore::ONE_HARD)
            .as_constraint("Required skill"),

        // Soft: Prefer balanced workload
        factory.for_each::<Shift>()
            .group_by(|shift| shift.employee.clone(), count())
            .penalize(HardSoftScore::ONE_SOFT, |_emp, count| count * count)
            .as_constraint("Balanced workload"),
    ]
}

use solverforge::{SolverFactory, SolverConfig, TerminationConfig};

let config = SolverConfig::new()
    .with_solution_class::<Schedule>()
    .with_entity_classes::<Shift>()
    .with_termination(
        TerminationConfig::new().with_seconds_spent_limit(30)
    );

let solver = SolverFactory::create(config, define_constraints).build();
let solution = solver.solve(problem)?;

println!("Score: {:?}", solution.score);

factory.for_each::<Entity>()           // Start stream
    .filter(|e| predicate)             // Filter entities
    .join::<Other>()                   // Join with another type
    .if_exists::<Other>()              // Filter if matching exists
    .if_not_exists::<Other>()          // Filter if no match
    .group_by(key_fn, collector)       // Group and aggregate
    .penalize(score)                   // Apply penalty
    .penalize(score, weigher)          // Weighted penalty
    .reward(score)                     // Apply reward
    .as_constraint("name")             // Name the constraint

Joiners::equal(|a| a.field, |b| b.field)
Joiners::less_than(|a| a.value, |b| b.value)
Joiners::greater_than(|a| a.value, |b| b.value)
Joiners::overlapping(|a| a.start, |a| a.end, |b| b.start, |b| b.end)

count()
count_distinct(|e| e.field)
sum(|e| e.value)
average(|e| e.value)
min(|e| e.value)
max(|e| e.value)
to_list()
to_set()
load_balance()
compose(collector1, collector2)
conditionally(filter, collector)

#[derive(PlanningEntity)]
struct Visit {
    #[planning_id]
    id: i64,

    #[planning_variable(value_range_provider = "vehicles")]
    vehicle: Option<Vehicle>,

    #[inverse_relation_shadow_variable(source = "vehicle")]
    previous_visit: Option<Visit>,

    #[shadow_variable(source = "previous_visit", listener = "ArrivalTimeListener")]
    arrival_time: Option<DateTime>,
}