from solverforge_legacy.solver import ProblemChange

class AddLessonChange(ProblemChange[Timetable]):
    def __init__(self, lesson: Lesson):
        self.lesson = lesson

    def do_change(self, working_solution: Timetable, score_director):
        # Add to solution
        working_solution.lessons.append(self.lesson)
        # Notify score director
        score_director.after_entity_added(self.lesson)

# With Solver
new_lesson = Lesson("new-1", "Art", "S. Dali", "Group A")
solver.add_problem_change(AddLessonChange(new_lesson))

# With SolverManager
solver_manager.add_problem_change(job_id, AddLessonChange(new_lesson))

class AddVisitChange(ProblemChange[RoutePlan]):
    def __init__(self, visit: Visit):
        self.visit = visit

    def do_change(self, solution: RoutePlan, score_director):
        solution.visits.append(self.visit)
        score_director.after_entity_added(self.visit)

class RemoveVisitChange(ProblemChange[RoutePlan]):
    def __init__(self, visit_id: str):
        self.visit_id = visit_id

    def do_change(self, solution: RoutePlan, score_director):
        visit = next(v for v in solution.visits if v.id == self.visit_id)

        # Remove from vehicle if assigned
        if visit.vehicle:
            score_director.before_list_variable_changed(
                visit.vehicle, "visits", visit.vehicle.visits
            )
            visit.vehicle.visits.remove(visit)
            score_director.after_list_variable_changed(
                visit.vehicle, "visits", visit.vehicle.visits
            )

        # Remove from solution
        score_director.before_entity_removed(visit)
        solution.visits.remove(visit)
        score_director.after_entity_removed(visit)

class UpdateVisitDemandChange(ProblemChange[RoutePlan]):
    def __init__(self, visit_id: str, new_demand: int):
        self.visit_id = visit_id
        self.new_demand = new_demand

    def do_change(self, solution: RoutePlan, score_director):
        visit = next(v for v in solution.visits if v.id == self.visit_id)

        score_director.before_problem_property_changed(visit)
        visit.demand = self.new_demand
        score_director.after_problem_property_changed(visit)

class AddVehicleChange(ProblemChange[RoutePlan]):
    def __init__(self, vehicle: Vehicle):
        self.vehicle = vehicle

    def do_change(self, solution: RoutePlan, score_director):
        solution.vehicles.append(self.vehicle)
        score_director.after_problem_fact_added(self.vehicle)

score_director.before_entity_removed(entity)
# Actually remove
solution.entities.remove(entity)
score_director.after_entity_removed(entity)

from fastapi import FastAPI
from solverforge_legacy.solver import SolverManager, ProblemChange

app = FastAPI()
solver_manager: SolverManager


@app.post("/visits")
async def add_visit(visit: VisitRequest, job_id: str):
    """Add a visit to an active solving job."""
    new_visit = Visit(
        id=str(uuid.uuid4()),
        location=visit.location,
        demand=visit.demand,
    )

    solver_manager.add_problem_change(
        job_id,
        AddVisitChange(new_visit)
    )

    return {"id": new_visit.id, "status": "added"}


@app.delete("/visits/{visit_id}")
async def remove_visit(visit_id: str, job_id: str):
    """Remove a visit from an active solving job."""
    solver_manager.add_problem_change(
        job_id,
        RemoveVisitChange(visit_id)
    )

    return {"status": "removed"}

solver.add_problem_change(change1)  # Applied first
solver.add_problem_change(change2)  # Applied second
solver.add_problem_change(change3)  # Applied third

class DebugChange(ProblemChange[Solution]):
    def __init__(self, inner: ProblemChange):
        self.inner = inner

    def do_change(self, solution, score_director):
        print(f"Before: {len(solution.entities)} entities")
        self.inner.do_change(solution, score_director)
        print(f"After: {len(solution.entities)} entities")

from datetime import datetime, timedelta

def plan_window(start_date: date, window_days: int, problem: Schedule) -> Schedule:
    """Plan a time window."""
    end_date = start_date + timedelta(days=window_days)

    # Filter entities to window
    window_shifts = [
        s for s in problem.shifts
        if start_date <= s.date < end_date
    ]

    window_problem = Schedule(
        employees=problem.employees,
        shifts=window_shifts,
    )

    solver = create_solver()
    return solver.solve(window_problem)


def continuous_plan(problem: Schedule, window_days: int = 14):
    """Run continuous planning with rolling windows."""
    current_date = date.today()
    end_date = max(s.date for s in problem.shifts)

    while current_date < end_date:
        solution = plan_window(current_date, window_days, problem)
        save_solution(solution)

        # Move window forward
        current_date += timedelta(days=7)  # Overlap

def prepare_window(problem: Schedule, publish_deadline: datetime):
    """Pin published shifts, leave draft unpinned."""
    for shift in problem.shifts:
        if shift.start_time < publish_deadline:
            shift.pinned = True
        else:
            shift.pinned = False

    return problem

def on_new_order(order: Order, active_job_id: str):
    """Trigger replanning when new order arrives."""
    solver_manager.terminate_early(active_job_id)

    updated_problem = load_current_state()
    updated_problem.orders.append(order)

    new_job_id = start_solving(updated_problem)
    return new_job_id

def warm_start_plan(previous: Schedule, new_shifts: list[Shift]) -> Schedule:
    """Start from previous solution, add new shifts."""
    # Keep previous assignments (pinned or as starting point)
    for shift in previous.shifts:
        if shift.employee is not None:
            shift.pinned = True  # Or just leave assigned

    # Add new unassigned shifts
    for shift in new_shifts:
        shift.employee = None
        shift.pinned = False
        previous.shifts.append(shift)

    return solve(previous)

def merge_with_reality(planned: Schedule, actual: Schedule) -> Schedule:
    """Merge planned schedule with actual execution."""
    for planned_shift in planned.shifts:
        actual_shift = find_actual(actual, planned_shift.id)

        if actual_shift and actual_shift.is_started:
            # Can't change started shifts
            planned_shift.employee = actual_shift.employee
            planned_shift.pinned = True

    return planned

class WeeklyScheduler:
    def __init__(self):
        self.solver_manager = create_solver_manager()

    def plan_next_week(self):
        """Run weekly planning cycle."""
        # Load current state
        current = load_current_schedule()

        # Determine window
        today = date.today()
        window_start = today + timedelta(days=(7 - today.weekday()))  # Next Monday
        window_end = window_start + timedelta(days=14)

        # Pin this week (being executed)
        for shift in current.shifts:
            if shift.date < window_start:
                shift.pinned = True
            elif shift.date < window_end:
                shift.pinned = False  # Can replan
            else:
                continue  # Outside window

        # Solve
        solution = self.solve(current)

        # Publish next week
        publish_week(solution, window_start, window_start + timedelta(days=7))

        return solution

from datetime import datetime
import schedule
import time

def daily_optimization():
    """Run optimization every day at 2 AM."""
    # Load today's problem
    problem = load_todays_problem()

    # Solve
    solver = create_solver()
    solution = solver.solve(problem)

    # Save results
    save_solution(solution)
    notify_stakeholders(solution)

# Schedule daily run
schedule.every().day.at("02:00").do(daily_optimization)

while True:
    schedule.run_pending()
    time.sleep(60)

def optimize_all_regions():
    """Optimize each region independently."""
    regions = load_regions()
    results = {}

    for region in regions:
        problem = load_region_problem(region)
        solution = solve(problem)
        results[region] = solution
        save_solution(region, solution)

    return results

from concurrent.futures import ThreadPoolExecutor

def optimize_regions_parallel():
    """Optimize regions in parallel."""
    regions = load_regions()

    with ThreadPoolExecutor(max_workers=4) as executor:
        futures = {
            executor.submit(solve_region, region): region
            for region in regions
        }

        results = {}
        for future in futures:
            region = futures[future]
            results[region] = future.result()

    return results

# Every hour
schedule.every().hour.do(replan)

# Every day at specific time
schedule.every().day.at("06:00").do(replan)

# Every Monday
schedule.every().monday.at("00:00").do(weekly_plan)

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler()

# Run at 2 AM every day
scheduler.add_job(daily_optimization, 'cron', hour=2)

# Run every 30 minutes
scheduler.add_job(frequent_replan, 'cron', minute='*/30')

scheduler.start()

def robust_optimization():
    """Optimization with retry and fallback."""
    max_retries = 3

    for attempt in range(max_retries):
        try:
            problem = load_problem()
            solution = solve(problem)
            save_solution(solution)
            return solution

        except Exception as e:
            logger.error(f"Attempt {attempt + 1} failed: {e}")
            if attempt < max_retries - 1:
                time.sleep(60)  # Wait before retry
            else:
                # Use previous solution as fallback
                return load_previous_solution()

def track_solution_quality(solution: Schedule):
    """Log solution metrics for analysis."""
    metrics = {
        "timestamp": datetime.now().isoformat(),
        "score": str(solution.score),
        "feasible": solution.score.is_feasible,
        "entity_count": len(solution.shifts),
        "assigned_count": sum(1 for s in solution.shifts if s.employee),
    }

    log_metrics(metrics)

    # Alert if quality degrades
    if not solution.score.is_feasible:
        send_alert("Infeasible solution generated!")

def fresh_optimization():
    problem = load_problem()
    # All entities unassigned
    for entity in problem.entities:
        entity.planning_variable = None
    return solve(problem)

def incremental_optimization():
    previous = load_previous_solution()

    # Keep good assignments, clear bad ones
    for entity in previous.entities:
        if should_keep(entity):
            entity.pinned = True
        else:
            entity.planning_variable = None
            entity.pinned = False

    return solve(previous)

class OptimizationMonitor:
    def __init__(self):
        self.runs = []

    def record_run(self, solution, duration):
        self.runs.append({
            "time": datetime.now(),
            "score": solution.score,
            "duration": duration,
            "feasible": solution.score.is_feasible,
        })

    def get_statistics(self):
        if not self.runs:
            return None

        feasible_rate = sum(r["feasible"] for r in self.runs) / len(self.runs)
        avg_duration = sum(r["duration"] for r in self.runs) / len(self.runs)

        return {
            "total_runs": len(self.runs),
            "feasibility_rate": feasible_rate,
            "avg_duration_seconds": avg_duration,
        }