from solverforge_legacy.solver.domain import (
    planning_entity,
    planning_solution,
)

from solverforge_legacy.solver.domain import (
    PlanningId,
    PlanningVariable,
    PlanningListVariable,
    PlanningEntityCollectionProperty,
    ProblemFactCollectionProperty,
    ValueRangeProvider,
    PlanningScore,
    PlanningPin,
    PlanningPinToIndex,
)

from typing import Annotated
from dataclasses import dataclass, field

@planning_entity
@dataclass
class Lesson:
    id: Annotated[str, PlanningId]
    timeslot: Annotated[Timeslot | None, PlanningVariable] = field(default=None)

from solverforge_legacy.solver.domain import (
    InverseRelationShadowVariable,
    PreviousElementShadowVariable,
    NextElementShadowVariable,
    CascadingUpdateShadowVariable,
)

from solverforge_legacy.solver.score import (
    SimpleScore,
    HardSoftScore,
    HardMediumSoftScore,
    HardSoftDecimalScore,
)

score = HardSoftScore.of(-2, -15)
score.hard_score      # -2
score.soft_score      # -15
score.is_feasible     # False (hard_score < 0)

# Constants
HardSoftScore.ZERO
HardSoftScore.ONE_HARD
HardSoftScore.ONE_SOFT

from solverforge_legacy.solver.score import (
    constraint_provider,
    ConstraintFactory,
    Constraint,
    Joiners,
    ConstraintCollectors,
)

from solverforge_legacy.solver.score import Joiners

from solverforge_legacy.solver.score import ConstraintCollectors

from solverforge_legacy.solver.config import (
    SolverConfig,
    ScoreDirectorFactoryConfig,
    TerminationConfig,
    Duration,
)

config = SolverConfig(
    solution_class=Timetable,
    entity_class_list=[Lesson],
    score_director_factory_config=ScoreDirectorFactoryConfig(
        constraint_provider_function=define_constraints
    ),
    termination_config=TerminationConfig(
        spent_limit=Duration(seconds=30)
    ),
)

from solverforge_legacy.solver import (
    SolverFactory,
    SolverManager,
    SolutionManager,
    SolverStatus,
)

solver_factory = SolverFactory.create(config)
solver = solver_factory.build_solver()
solution = solver.solve(problem)

solver_manager = SolverManager.create(solver_factory)

# Async solving
solver_manager.solve_and_listen(
    problem_id,
    problem_finder=lambda _: problem,
    best_solution_consumer=on_best_solution,
)

# Control
solver_manager.terminate_early(problem_id)
status = solver_manager.get_solver_status(problem_id)
solver_manager.close()

solution_manager = SolutionManager.create(solver_factory)
analysis = solution_manager.analyze(solution)
score = solution_manager.update(solution)

from solverforge_legacy.solver.config import Duration

Duration(seconds=30)
Duration(minutes=5)
Duration(hours=1)

from solverforge_legacy.solver import BestSolutionChangedEvent

def on_best_solution(event: BestSolutionChangedEvent):
    print(f"Score: {event.new_best_score}")
    print(f"Time: {event.time_spent}")

from solverforge_legacy.solver import ProblemChange

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

    def do_change(self, solution: Timetable, problem_change_director):
        problem_change_director.add_entity(
            self.lesson,
            lambda l: solution.lessons.append(l)
        )

# Domain modeling
from solverforge_legacy.solver.domain import (
    planning_entity,
    planning_solution,
    PlanningId,
    PlanningVariable,
    PlanningListVariable,
    PlanningEntityCollectionProperty,
    ProblemFactCollectionProperty,
    ValueRangeProvider,
    PlanningScore,
    PlanningPin,
    InverseRelationShadowVariable,
    PreviousElementShadowVariable,
    NextElementShadowVariable,
    CascadingUpdateShadowVariable,
)

# Scores and constraints
from solverforge_legacy.solver.score import (
    constraint_provider,
    ConstraintFactory,
    Constraint,
    Joiners,
    ConstraintCollectors,
    HardSoftScore,
    HardMediumSoftScore,
    SimpleScore,
)

# Solver
from solverforge_legacy.solver import (
    SolverFactory,
    SolverManager,
    SolutionManager,
    SolverStatus,
    BestSolutionChangedEvent,
    ProblemChange,
)

# Configuration
from solverforge_legacy.solver.config import (
    SolverConfig,
    ScoreDirectorFactoryConfig,
    TerminationConfig,
    Duration,
)

pip install solverforge-legacy

@planning_entity
class Lesson:
    pinned: Annotated[bool, PlanningPin] = False

# Good - each pair counted once
constraint_factory.for_each_unique_pair(
    Lesson,
    Joiners.equal(lambda l: l.timeslot),
    Joiners.equal(lambda l: l.room),
)

# Less efficient - (A,B) and (B,A) both matched
constraint_factory.for_each(Lesson).join(Lesson, ...)

analysis = solution_manager.analyze(solution)
for c in analysis.constraint_analyses():
    print(f"{c.constraint_name}: {c.score}")

for match in constraint_analysis.matches():
    print(f"  {match.justification}")

# External termination (from another thread)
solver.terminate_early()

solver_manager.terminate_early(problem_id)

solver_manager.solve_and_listen(
    problem_id,
    problem_finder=lambda _: problem,
    best_solution_consumer=lambda solution: print(f"Score: {solution.score}"),
)

# Fast - indexing
Joiners.equal(lambda lesson: lesson.timeslot)

# Slower - Python filter
.filter(lambda l1, l2: l1.timeslot == l2.timeslot)

@asynccontextmanager
async def lifespan(app: FastAPI):
    global solver_manager
    solver_manager = SolverManager.create(solver_factory)
    yield
    solver_manager.close()

# With dataclasses
import json
from dataclasses import asdict

json.dumps(asdict(solution))

# With Pydantic
solution.model_dump_json()

# Save
with open("solution.json", "w") as f:
    json.dump(solution_to_dict(solution), f)

# Load
with open("solution.json") as f:
    problem = dict_to_solution(json.load(f))

# Check Java
java -version

# Set JAVA_HOME (example for Linux)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

export JAVA_TOOL_OPTIONS="-Xmx4g"