.

Dockerfile

@@ -0,0 +1,39 @@
+# Build stage
+FROM eclipse-temurin:21-jdk-alpine AS build
+
+# Install Maven
+RUN apk add --no-cache maven
+
+# Set working directory
+WORKDIR /app
+
+# Copy source files
+COPY pom.xml .
+COPY src ./src
+
+# Build the application
+RUN mvn package -DskipTests -Dquarkus.package.jar.type=uber-jar
+
+# Runtime stage
+FROM eclipse-temurin:21-jre-alpine
+
+# Create non-root user for HuggingFace Spaces
+RUN addgroup -g 1000 appgroup && \
+    adduser -u 1000 -G appgroup -h /app -D appuser
+
+WORKDIR /app
+
+# Copy the built jar from build stage
+COPY --from=build /app/target/*-runner.jar /app/app.jar
+
+# Change ownership to non-root user
+RUN chown -R appuser:appgroup /app
+
+# Switch to non-root user
+USER appuser
+
+# HuggingFace Spaces requires port 7860
+EXPOSE 7860
+
+# Run the application on port 7860
+CMD ["java", "-Dquarkus.http.host=0.0.0.0", "-Dquarkus.http.port=7860", "-jar", "app.jar"]

README.adoc

@@ -0,0 +1,173 @@
+= Flight Crew Scheduling (Java, Quarkus, Maven)
+
+Assign crew to flights to produce a better schedule for flight assignments.
+
+image::./flight-crew-scheduling-screenshot.png[]
+
+* <<run,Run the application>>
+* <<enterprise,Run the application with Timefold Solver Enterprise Edition>>
+* <<package,Run the packaged application>>
+* <<container,Run the application in a container>>
+* <<native,Run it native>>
+
+== Prerequisites
+
+. Install Java and Maven, for example with https://sdkman.io[Sdkman]:
++
+----
+$ sdk install java
+$ sdk install maven
+----
+
+[[run]]
+== Run the application
+
+. Git clone the timefold-quickstarts repo and navigate to this directory:
++
+[source, shell]
+----
+$ git clone https://github.com/TimefoldAI/timefold-quickstarts.git
+...
+$ cd timefold-quickstarts/java/flight-crew-scheduling
+----
+
+. Start the application with Maven:
++
+[source, shell]
+----
+$ mvn quarkus:dev
+----
+
+
+. Visit http://localhost:8080 in your browser.
+
+. Click on the *Solve* button.
+
+Then try _live coding_:
+
+. Make some changes in the source code.
+. Refresh your browser (F5).
+
+Notice that those changes are immediately in effect.
+
+[[enterprise]]
+== Run the application with Timefold Solver Enterprise Edition
+
+For high-scalability use cases, switch to https://docs.timefold.ai/timefold-solver/latest/enterprise-edition/enterprise-edition[Timefold Solver Enterprise Edition],
+our commercial offering.
+https://timefold.ai/contact[Contact Timefold] to obtain the credentials required to access our private Enterprise Maven repository.
+
+. Create `.m2/settings.xml` in your home directory with the following content:
++
+--
+[source,xml,options="nowrap"]
+----
+<settings>
+  ...
+  <servers>
+    <server>
+      <!-- Replace "my_username" and "my_password" with credentials obtained from a Timefold representative. -->
+      <id>timefold-solver-enterprise</id>
+      <username>my_username</username>
+      <password>my_password</password>
+    </server>
+  </servers>
+  ...
+</settings>
+----
+
+See https://maven.apache.org/settings.html[Settings Reference] for more information on Maven settings.
+--
+
+. Start the application with Maven:
++
+[source,shell]
+----
+$ mvn clean quarkus:dev -Denterprise
+----
+
+. Visit http://localhost:8080 in your browser.
+
+. Click on the *Solve* button.
+
+Then try _live coding_:
+
+. Make some changes in the source code.
+. Refresh your browser (F5).
+
+Notice that those changes are immediately in effect.
+
+[[package]]
+== Run the packaged application
+
+When you're done iterating in `quarkus:dev` mode,
+package the application to run as a conventional jar file.
+
+. Build it with Maven:
++
+[source, shell]
+----
+$ mvn package
+----
+. Run the Maven output:
++
+[source, shell]
+----
+$ java -jar ./target/quarkus-app/quarkus-run.jar
+----
++
+[NOTE]
+====
+To run it on port 8081 instead, add `-Dquarkus.http.port=8081`.
+====
+
+. Visit http://localhost:8080 in your browser.
+
+. Click on the *Solve* button.
+
+[[container]]
+== Run the application in a container
+
+. Build a container image:
++
+[source, shell]
+----
+$ mvn package -Dcontainer
+----
+The container image name
+. Run a container:
++
+[source, shell]
+----
+$ docker run -p 8080:8080 --rm $USER/flight-crew-scheduling:1.0-SNAPSHOT
+----
+
+[[native]]
+== Run it native
+
+To increase startup performance for serverless deployments,
+build the application as a native executable:
+
+. https://quarkus.io/guides/building-native-image#configuring-graalvm[Install GraalVM and gu install the native-image tool]
+
+. Compile it natively. This takes a few minutes:
++
+[source, shell]
+----
+$ mvn package -Dnative
+----
+
+. Run the native executable:
++
+[source, shell]
+----
+$ ./target/*-runner
+----
+
+. Visit http://localhost:8080 in your browser.
+
+. Click on the *Solve* button.
+
+== More information
+
+Visit https://timefold.ai[timefold.ai].

README.md

@@ -0,0 +1,20 @@
+---
+title: Flight Crew Scheduling (Java)
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: apache-2.0
+app_port: 7860
+---
+
+# Flight Crew Scheduling
+
+An optimization application for scheduling flight crews using Timefold Solver.
+
+This application assigns employees to flights while respecting constraints such as:
+- Required skills for each flight
+- Employee availability and home airports
+- Legal rest requirements between flights
+
+Built with Quarkus and Timefold Solver.

pom.xml

@@ -0,0 +1,253 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.acme</groupId>
+    <artifactId>flight-crew-scheduling</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.release>17</maven.compiler.release>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+        <version.io.quarkus>3.30.0</version.io.quarkus>
+        <version.ai.timefold.solver>1.29.0</version.ai.timefold.solver>
+
+        <version.compiler.plugin>3.14.0</version.compiler.plugin>
+        <version.resources.plugin>3.3.1</version.resources.plugin>
+        <version.surefire.plugin>3.5.3</version.surefire.plugin>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-bom</artifactId>
+                <version>${version.io.quarkus}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <dependency>
+                <groupId>ai.timefold.solver</groupId>
+                <artifactId>timefold-solver-bom</artifactId>
+                <version>${version.ai.timefold.solver}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-jackson</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-openapi</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ai.timefold.solver</groupId>
+            <artifactId>timefold-solver-quarkus</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ai.timefold.solver</groupId>
+            <artifactId>timefold-solver-quarkus-jackson</artifactId>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>ai.timefold.solver</groupId>
+            <artifactId>timefold-solver-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.27.3</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- UI -->
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-webjars-locator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ai.timefold.solver</groupId>
+            <artifactId>timefold-solver-webui</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.webjars</groupId>
+            <artifactId>bootstrap</artifactId>
+            <version>5.2.3</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.webjars</groupId>
+            <artifactId>jquery</artifactId>
+            <version>3.6.4</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.webjars</groupId>
+            <artifactId>font-awesome</artifactId>
+            <version>5.15.1</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.webjars.npm</groupId>
+            <artifactId>js-joda</artifactId>
+            <version>1.11.0</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.webjars.npm</groupId>
+            <artifactId>js-joda__locale_en-us</artifactId>
+            <version>3.1.0</version>
+            <scope>runtime</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <version>${version.resources.plugin}</version>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${version.compiler.plugin}</version>
+            </plugin>
+            <plugin>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-maven-plugin</artifactId>
+                <version>${version.io.quarkus}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>build</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${version.surefire.plugin}</version>
+            </plugin>
+        </plugins>
+    </build>
+
+    <profiles>
+        <profile>
+            <id>native</id>
+            <activation>
+                <property>
+                    <name>native</name>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-failsafe-plugin</artifactId>
+                        <version>${version.surefire.plugin}</version>
+                        <executions>
+                            <execution>
+                                <goals>
+                                    <goal>integration-test</goal>
+                                    <goal>verify</goal>
+                                </goals>
+                                <configuration>
+                                    <systemPropertyVariables>
+                                        <native.image.path>
+                                            ${project.build.directory}/${project.build.finalName}-runner
+                                        </native.image.path>
+                                    </systemPropertyVariables>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+            <properties>
+                <quarkus.native.enabled>true</quarkus.native.enabled>
+                <!-- To allow application.properties to avoid using the in-memory database for native builds. -->
+                <quarkus.profile>native</quarkus.profile>
+            </properties>
+        </profile>
+        <profile>
+            <id>container</id>
+            <activation>
+                <property>
+                    <name>container</name>
+                </property>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>io.quarkus</groupId>
+                    <artifactId>quarkus-container-image-jib</artifactId>
+                </dependency>
+            </dependencies>
+            <properties>
+                <quarkus.container-image.build>true</quarkus.container-image.build>
+            </properties>
+        </profile>
+        <profile>
+            <id>enterprise</id>
+            <activation>
+                <property>
+                    <name>enterprise</name>
+                </property>
+            </activation>
+            <repositories>
+                <repository>
+                    <id>timefold-solver-enterprise</id>
+                    <name>Timefold Solver Enterprise Edition</name>
+                    <url>https://timefold.jfrog.io/artifactory/releases/</url>
+                </repository>
+            </repositories>
+            <dependencyManagement>
+                <dependencies>
+                    <dependency>
+                        <groupId>ai.timefold.solver.enterprise</groupId>
+                        <artifactId>timefold-solver-enterprise-bom</artifactId>
+                        <version>${version.ai.timefold.solver}</version>
+                        <type>pom</type>
+                        <scope>import</scope>
+                    </dependency>
+                </dependencies>
+            </dependencyManagement>
+            <dependencies>
+                <dependency>
+                    <groupId>ai.timefold.solver.enterprise</groupId>
+                    <artifactId>timefold-solver-enterprise-quarkus</artifactId>
+                </dependency>
+            </dependencies>
+            <properties>
+                <quarkus.profile>enterprise</quarkus.profile>
+            </properties>
+        </profile>
+    </profiles>
+
+</project>

src/main/java/org/acme/flighcrewscheduling/domain/Airport.java

@@ -0,0 +1,115 @@
+package org.acme.flighcrewscheduling.domain;
+
+import java.util.Map;
+import java.util.Objects;
+
+import ai.timefold.solver.core.api.domain.lookup.PlanningId;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+
+@JsonIdentityInfo(scope = Airport.class, generator = ObjectIdGenerators.PropertyGenerator.class, property = "code")
+public class Airport implements Comparable<Airport> {
+
+    @PlanningId
+    private String code; // IATA 3-letter code
+    private String name;
+    private double latitude;
+    private double longitude;
+
+    private Map<String, Long> taxiTimeInMinutes; // Map from airport code to taxi time in minutes
+
+    public Airport() {
+    }
+
+    public Airport(String code) {
+        this.code = code;
+    }
+
+    public Airport(String code, String name, double latitude, double longitude) {
+        this.code = code;
+        this.name = name;
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    // ************************************************************************
+    // Simple getters and setters
+    // ************************************************************************
+
+    public String getCode() {
+        return code;
+    }
+
+    public void setCode(String code) {
+        this.code = code;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getLatitude() {
+        return latitude;
+    }
+
+    public void setLatitude(double latitude) {
+        this.latitude = latitude;
+    }
+
+    public double getLongitude() {
+        return longitude;
+    }
+
+    public void setLongitude(double longitude) {
+        this.longitude = longitude;
+    }
+
+    public Map<String, Long> getTaxiTimeInMinutes() {
+        return taxiTimeInMinutes;
+    }
+
+    public void setTaxiTimeInMinutes(Map<String, Long> taxiTimeInMinutes) {
+        this.taxiTimeInMinutes = taxiTimeInMinutes;
+    }
+
+    /**
+     * Get taxi time in minutes to another airport.
+     * Returns null if no taxi time data is available for the route.
+     */
+    @com.fasterxml.jackson.annotation.JsonIgnore
+    public Long getTaxiTimeInMinutesTo(Airport destination) {
+        if (taxiTimeInMinutes == null || destination == null) {
+            return null;
+        }
+        return taxiTimeInMinutes.get(destination.getCode());
+    }
+
+    @Override
+    public int compareTo(Airport o) {
+        return code.compareTo(o.code);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof Airport airport))
+            return false;
+        return Objects.equals(getCode(), airport.getCode());
+    }
+
+    @Override
+    public int hashCode() {
+        return getCode().hashCode();
+    }
+}

src/main/java/org/acme/flighcrewscheduling/domain/Employee.java

@@ -0,0 +1,120 @@
+package org.acme.flighcrewscheduling.domain;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import ai.timefold.solver.core.api.domain.lookup.PlanningId;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+
+@JsonIdentityInfo(scope = Employee.class, generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
+public class Employee {
+
+    @PlanningId
+    private String id;
+    private String name;
+    private Airport homeAirport;
+
+    private List<String> skills;
+    private List<LocalDate> unavailableDays;
+
+    public Employee() {
+        this.unavailableDays = new ArrayList<>();
+    }
+
+    public Employee(String id) {
+        this.id = id;
+        this.unavailableDays = new ArrayList<>();
+    }
+
+    public Employee(String id, String name) {
+        this.id = id;
+        this.name = name;
+        this.unavailableDays = new ArrayList<>();
+    }
+
+    public Employee(String id, String name, Airport homeAirport, List<String> skills) {
+        this.id = id;
+        this.name = name;
+        this.homeAirport = homeAirport;
+        this.skills = skills;
+    }
+
+    @JsonIgnore
+    public boolean hasSkill(String skill) {
+        return skills.contains(skill);
+    }
+
+    @JsonIgnore
+    public boolean isAvailable(LocalDate fromDateInclusive, LocalDate toDateInclusive) {
+        if (unavailableDays == null) {
+            return true;
+        }
+        return fromDateInclusive
+                .datesUntil(toDateInclusive.plusDays(1))
+                .noneMatch(unavailableDays::contains);
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    // ************************************************************************
+    // Simple getters and setters
+    // ************************************************************************
+
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Airport getHomeAirport() {
+        return homeAirport;
+    }
+
+    public void setHomeAirport(Airport homeAirport) {
+        this.homeAirport = homeAirport;
+    }
+
+    public List<String> getSkills() {
+        return skills;
+    }
+
+    public void setSkills(List<String> skills) {
+        this.skills = skills;
+    }
+
+    public List<LocalDate> getUnavailableDays() {
+        return unavailableDays;
+    }
+
+    public void setUnavailableDays(List<LocalDate> unavailableDays) {
+        this.unavailableDays = unavailableDays;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof Employee employee))
+            return false;
+        return Objects.equals(getId(), employee.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getId().hashCode();
+    }
+}

src/main/java/org/acme/flighcrewscheduling/domain/Flight.java

@@ -0,0 +1,164 @@
+package org.acme.flighcrewscheduling.domain;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Comparator;
+import java.util.Objects;
+
+import ai.timefold.solver.core.api.domain.lookup.PlanningId;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+
+@JsonIdentityInfo(scope = Flight.class, generator = ObjectIdGenerators.PropertyGenerator.class, property = "flightNumber")
+public class Flight implements Comparable<Flight> {
+
+    private static final Comparator<Flight> COMPARATOR = Comparator.comparing(Flight::getDepartureUTCDateTime)
+            .thenComparing(Flight::getDepartureAirport)
+            .thenComparing(Flight::getArrivalUTCDateTime)
+            .thenComparing(Flight::getArrivalAirport)
+            .thenComparing(Flight::getFlightNumber);
+
+    @PlanningId
+    private String flightNumber;
+    private Airport departureAirport;
+    private LocalDateTime departureUTCDateTime;
+    private Airport arrivalAirport;
+    private LocalDateTime arrivalUTCDateTime;
+
+    public Flight() {
+    }
+
+    public Flight(String flightNumber) {
+        this.flightNumber = flightNumber;
+    }
+
+    public Flight(String flightNumber, Airport departureAirport, Airport arrivalAirport) {
+        this.flightNumber = flightNumber;
+        this.departureAirport = departureAirport;
+        this.arrivalAirport = arrivalAirport;
+    }
+
+    public Flight(String flightNumber, Airport departureAirport, LocalDateTime departureUTCDateTime, Airport arrivalAirport, LocalDateTime arrivalUTCDateTime) {
+        this.flightNumber = flightNumber;
+        this.departureAirport = departureAirport;
+        this.departureUTCDateTime = departureUTCDateTime;
+        this.arrivalAirport = arrivalAirport;
+        this.arrivalUTCDateTime = arrivalUTCDateTime;
+    }
+
+    @JsonIgnore
+    public LocalDate getDepartureUTCDate() {
+        return departureUTCDateTime.toLocalDate();
+    }
+
+    /**
+     * Calculate Flight Duty Period (FDP) duration in hours.
+     * FDP = reporting time (45 min before departure) + flight time + post-flight duties (20 min)
+     * This is a simplified MVP calculation using fixed constants.
+     */
+    @JsonIgnore
+    public double getFlightDutyPeriodHours() {
+        long flightMinutes = java.time.Duration.between(
+            departureUTCDateTime,
+            arrivalUTCDateTime
+        ).toMinutes();
+        long fdpMinutes = flightMinutes + 65;
+        return fdpMinutes / 60.0;
+    }
+
+    @JsonIgnore
+    public LocalDateTime getDutyEndDateTime() {
+        return arrivalUTCDateTime.plusMinutes(20); // 20 min post-flight
+    }
+
+    @JsonIgnore
+    public LocalDateTime getDutyStartDateTime() {
+        return departureUTCDateTime.minusMinutes(45); // 45 min reporting
+    }
+
+    /**
+     * Determine if this is a long haul flight.
+     * A flight is considered long haul if the actual flight duration is 8 hours or more.
+     *
+     * @return true if flight duration >= 8 hours, false otherwise
+     */
+    @JsonIgnore
+    public boolean isLongHaul() {
+        long flightMinutes = java.time.Duration.between(
+            departureUTCDateTime,
+            arrivalUTCDateTime
+        ).toMinutes();
+        double flightHours = flightMinutes / 60.0;
+        return flightHours >= 10.0;
+    }
+
+    @Override
+    public String toString() {
+        return flightNumber + "@" + departureUTCDateTime.toLocalDate();
+    }
+
+    // ************************************************************************
+    // Simple getters and setters
+    // ************************************************************************
+
+    public String getFlightNumber() {
+        return flightNumber;
+    }
+
+    public void setFlightNumber(String flightNumber) {
+        this.flightNumber = flightNumber;
+    }
+
+    public Airport getDepartureAirport() {
+        return departureAirport;
+    }
+
+    public void setDepartureAirport(Airport departureAirport) {
+        this.departureAirport = departureAirport;
+    }
+
+    public LocalDateTime getDepartureUTCDateTime() {
+        return departureUTCDateTime;
+    }
+
+    public void setDepartureUTCDateTime(LocalDateTime departureUTCDateTime) {
+        this.departureUTCDateTime = departureUTCDateTime;
+    }
+
+    public Airport getArrivalAirport() {
+        return arrivalAirport;
+    }
+
+    public void setArrivalAirport(Airport arrivalAirport) {
+        this.arrivalAirport = arrivalAirport;
+    }
+
+    public LocalDateTime getArrivalUTCDateTime() {
+        return arrivalUTCDateTime;
+    }
+
+    public void setArrivalUTCDateTime(LocalDateTime arrivalUTCDateTime) {
+        this.arrivalUTCDateTime = arrivalUTCDateTime;
+    }
+
+    @Override
+    public int compareTo(Flight o) {
+        return COMPARATOR.compare(this, o);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof Flight flight))
+            return false;
+        return Objects.equals(getFlightNumber(), flight.getFlightNumber());
+    }
+
+    @Override
+    public int hashCode() {
+        return getFlightNumber().hashCode();
+    }
+}

src/main/java/org/acme/flighcrewscheduling/domain/FlightAssignment.java

@@ -0,0 +1,196 @@
+package org.acme.flighcrewscheduling.domain;
+
+import java.time.LocalDateTime;
+import java.util.Objects;
+
+import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
+import ai.timefold.solver.core.api.domain.lookup.PlanningId;
+import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+@PlanningEntity
+public class FlightAssignment {
+
+    @PlanningId
+    private String id;
+    private Flight flight;
+    private int indexInFlight;
+    private String requiredSkill;
+
+    @PlanningVariable
+    private Employee employee;
+
+    public FlightAssignment() {
+    }
+
+    public FlightAssignment(String id, Flight flight) {
+        this.id = id;
+        this.flight = flight;
+    }
+
+    public FlightAssignment(String id, Flight flight, int indexInFlight, String requiredSkill) {
+        this.id = id;
+        this.flight = flight;
+        this.indexInFlight = indexInFlight;
+        this.requiredSkill = requiredSkill;
+    }
+
+    @JsonIgnore
+    public boolean hasRequiredSkills() {
+        return getEmployee().hasSkill(requiredSkill);
+    }
+
+    @JsonIgnore
+    public boolean isUnavailableEmployee() {
+        return !getEmployee().isAvailable(getFlight().getDepartureUTCDate(), getFlight().getArrivalUTCDateTime().toLocalDate());
+    }
+
+    @JsonIgnore
+    public LocalDateTime getDepartureUTCDateTime() {
+        return flight.getDepartureUTCDateTime();
+    }
+
+    @JsonIgnore
+    public Airport getArrivalAirport() {
+        return flight.getArrivalAirport();
+    }
+
+    @JsonIgnore
+    public Airport getDepartureAirport() {
+        return flight.getDepartureAirport();
+    }
+
+    @JsonIgnore
+    public LocalDateTime getDutyEndDateTime() {
+        return flight.getDutyEndDateTime();
+    }
+
+    @JsonIgnore
+    public LocalDateTime getDutyStartDateTime() {
+        return flight.getDutyStartDateTime();
+    }
+
+    @JsonIgnore
+    public LocalDateTime getArrivalUTCDateTime() {
+        return flight.getArrivalUTCDateTime();
+    }
+
+    @JsonIgnore
+    public boolean isAtHomeBase(Airport airport) {
+        return employee != null && employee.getHomeAirport().equals(airport);
+    }
+
+    @JsonIgnore
+    public boolean isLongHaulFlight() {
+        return flight.isLongHaul();
+    }
+
+    /**
+     * Checks if this assignment followed by the next assignment forms a long haul operation.
+     * Two consecutive flights are considered as one long haul if:
+     * 1. They are back-to-back (arrival airport of first = departure airport of second)
+     * 2. The total flight duration is >= 10 hours
+     * 3. The time between flights is minimal (taxi time)
+     *
+     * @param nextAssignment the next flight assignment for the same employee
+     * @return true if the combined flights form a long haul operation
+     */
+    @JsonIgnore
+    public boolean formsLongHaulWithNext(FlightAssignment nextAssignment) {
+        if (nextAssignment == null) {
+            return false;
+        }
+
+        // Check if flights are back-to-back (arrival airport matches next departure)
+        if (!this.getArrivalAirport().equals(nextAssignment.getDepartureAirport())) {
+            return false;
+        }
+
+        // Calculate time between flights (from arrival to next departure)
+        long minutesBetween = java.time.Duration.between(
+            this.getArrivalUTCDateTime(),
+            nextAssignment.getDepartureUTCDateTime()
+        ).toMinutes();
+
+        // If there's more than 2 hours between flights, they're not consecutive
+        if (minutesBetween > 120) {
+            return false;
+        }
+
+        // Calculate total flight time of both flights
+        long firstFlightMinutes = java.time.Duration.between(
+            this.flight.getDepartureUTCDateTime(),
+            this.flight.getArrivalUTCDateTime()
+        ).toMinutes();
+
+        long secondFlightMinutes = java.time.Duration.between(
+            nextAssignment.getFlight().getDepartureUTCDateTime(),
+            nextAssignment.getFlight().getArrivalUTCDateTime()
+        ).toMinutes();
+
+        double totalFlightHours = (firstFlightMinutes + secondFlightMinutes) / 60.0;
+
+        // Consider as long haul if total >= 10 hours
+        return totalFlightHours >= 10.0;
+    }
+
+    @Override
+    public String toString() {
+        return flight + "-" + indexInFlight;
+    }
+
+    // ************************************************************************
+    // Simple getters and setters
+    // ************************************************************************
+
+    public String getId() {
+        return id;
+    }
+
+    public Flight getFlight() {
+        return flight;
+    }
+
+    public void setFlight(Flight flight) {
+        this.flight = flight;
+    }
+
+    public int getIndexInFlight() {
+        return indexInFlight;
+    }
+
+    public void setIndexInFlight(int indexInFlight) {
+        this.indexInFlight = indexInFlight;
+    }
+
+    public String getRequiredSkill() {
+        return requiredSkill;
+    }
+
+    public void setRequiredSkill(String requiredSkill) {
+        this.requiredSkill = requiredSkill;
+    }
+
+    public Employee getEmployee() {
+        return employee;
+    }
+
+    public void setEmployee(Employee employee) {
+        this.employee = employee;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof FlightAssignment that))
+            return false;
+        return Objects.equals(getId(), that.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getId().hashCode();
+    }
+}

src/main/java/org/acme/flighcrewscheduling/domain/FlightCrewSchedule.java

@@ -0,0 +1,94 @@
+package org.acme.flighcrewscheduling.domain;
+
+import java.util.List;
+
+import ai.timefold.solver.core.api.domain.solution.PlanningEntityCollectionProperty;
+import ai.timefold.solver.core.api.domain.solution.PlanningScore;
+import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
+import ai.timefold.solver.core.api.domain.solution.ProblemFactCollectionProperty;
+import ai.timefold.solver.core.api.domain.valuerange.ValueRangeProvider;
+import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
+import ai.timefold.solver.core.api.solver.SolverStatus;
+
+@PlanningSolution
+public class FlightCrewSchedule {
+
+    @ProblemFactCollectionProperty
+    private List<Airport> airports;
+
+    @ProblemFactCollectionProperty
+    @ValueRangeProvider
+    private List<Employee> employees;
+
+    @ProblemFactCollectionProperty
+    private List<Flight> flights;
+
+    @PlanningEntityCollectionProperty
+    private List<FlightAssignment> flightAssignments;
+
+    @PlanningScore
+    private HardSoftLongScore score = null;
+
+    // Ignored by Timefold, used by the UI to display solve or stop solving button
+    private SolverStatus solverStatus;
+
+    public FlightCrewSchedule() {
+    }
+
+    public FlightCrewSchedule(HardSoftLongScore score, SolverStatus solverStatus) {
+        this.score = score;
+        this.solverStatus = solverStatus;
+    }
+
+    // ************************************************************************
+    // Simple getters and setters
+    // ************************************************************************
+
+    public List<Airport> getAirports() {
+        return airports;
+    }
+
+    public void setAirports(List<Airport> airports) {
+        this.airports = airports;
+    }
+
+    public List<Employee> getEmployees() {
+        return employees;
+    }
+
+    public void setEmployees(List<Employee> employees) {
+        this.employees = employees;
+    }
+
+    public List<Flight> getFlights() {
+        return flights;
+    }
+
+    public void setFlights(List<Flight> flights) {
+        this.flights = flights;
+    }
+
+    public List<FlightAssignment> getFlightAssignments() {
+        return flightAssignments;
+    }
+
+    public void setFlightAssignments(List<FlightAssignment> flightAssignments) {
+        this.flightAssignments = flightAssignments;
+    }
+
+    public HardSoftLongScore getScore() {
+        return score;
+    }
+
+    public void setScore(HardSoftLongScore score) {
+        this.score = score;
+    }
+
+    public SolverStatus getSolverStatus() {
+        return solverStatus;
+    }
+
+    public void setSolverStatus(SolverStatus solverStatus) {
+        this.solverStatus = solverStatus;
+    }
+}

src/main/java/org/acme/flighcrewscheduling/rest/DemoDataGenerator.java

@@ -0,0 +1,353 @@
+package org.acme.flighcrewscheduling.rest;
+
+import static java.util.Collections.unmodifiableList;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+import org.acme.flighcrewscheduling.domain.Airport;
+import org.acme.flighcrewscheduling.domain.Employee;
+import org.acme.flighcrewscheduling.domain.Flight;
+import org.acme.flighcrewscheduling.domain.FlightAssignment;
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+
+@ApplicationScoped
+public class DemoDataGenerator {
+
+    private static final String[] FIRST_NAMES = { "Amy", "Beth", "Carl", "Dan", "Elsa", "Flo", "Gus", "Hugo", "Ivy", "Jay",
+            "Jeri", "Hope", "Avis", "Lino", "Lyle", "Nick", "Dino", "Otha", "Gwen", "Jose", "Dena", "Jana", "Dave",
+            "Russ", "Josh", "Dana", "Katy" };
+    private static final String[] LAST_NAMES =
+            { "Cole", "Fox", "Green", "Jones", "King", "Li", "Poe", "Rye", "Smith", "Watt", "Howe", "Lowe", "Wise", "Clay",
+                    "Carr", "Hood", "Long", "Horn", "Haas", "Meza" };
+    private static final String ATTENDANT_SKILL = "Flight attendant";
+    private static final String PILOT_SKILL = "Pilot";
+    private final Random random = new Random(0);
+
+    public FlightCrewSchedule generateDemoData() {
+        FlightCrewSchedule schedule = new FlightCrewSchedule();
+        // Airports
+        List<Airport> airports = List.of(
+                new Airport("LHR", "LHR", 51.4775, -0.461389),
+                new Airport("JFK", "JFK", 40.639722, -73.778889),
+                new Airport("CNF", "CNF", -19.624444, -43.971944),
+                new Airport("BRU", "BRU", 50.901389, 4.484444),
+                new Airport("ATL", "ATL", 33.636667, -84.428056),
+                new Airport("BNE", "BNE", -27.383333, 153.118333));
+
+        // Populate taxi times between airports using actual geographic distances
+        // Calculate ground distance and convert to driving time (assuming ~60 km/h average)
+        for (Airport from : airports) {
+            Map<String, Long> airportTaxiTimes = new HashMap<>();
+            for (Airport to : airports) {
+                if (from.equals(to)) {
+                    // Same airport: 30 minutes local travel
+                    airportTaxiTimes.put(to.getCode(), 30L);
+                } else {
+                    // Calculate great circle distance in km
+                    double distanceKm = calculateHaversineDistance(
+                            from.getLatitude(), from.getLongitude(),
+                            to.getLatitude(), to.getLongitude());
+                    // Convert to driving time: assume 60 km/h average speed
+                    // (accounts for city traffic, highways, etc.)
+                    long travelTimeMinutes = Math.round(distanceKm);
+                    airportTaxiTimes.put(to.getCode(), travelTimeMinutes);
+                }
+            }
+            from.setTaxiTimeInMinutes(airportTaxiTimes);
+        }
+
+        Map<String, Integer> distances = new HashMap<>();
+        distances.put("LHR-JFK", 8);
+        distances.put("LHR-CNF", 12);
+        distances.put("LHR-BRU", 13);
+        distances.put("LHR-ATL", 9);
+        distances.put("LHR-BNE", 21);
+        distances.put("JFK-LHR", 8);
+        distances.put("JFK-BRU", 14);
+        distances.put("JFK-CNF", 10);
+        distances.put("JFK-ATL", 6);
+        distances.put("JFK-BNE", 20);
+        distances.put("CNF-LHR", 12);
+        distances.put("CNF-JFK", 10);
+        distances.put("CNF-BRU", 19);
+        distances.put("CNF-ATL", 10);
+        distances.put("CNF-BNE", 19);
+        distances.put("BRU-LHR", 13);
+        distances.put("BRU-JFK", 14);
+        distances.put("BRU-CNF", 19);
+        distances.put("BRU-ATL", 9);
+        distances.put("BRU-BNE", 21);
+        distances.put("ATL-LHR", 9);
+        distances.put("ATL-JFK", 6);
+        distances.put("ATL-CNF", 10);
+        distances.put("ATL-BRU", 9);
+        distances.put("ATL-BNE", 18);
+        distances.put("BNE-LHR", 21);
+        distances.put("BNE-JFK", 20);
+        distances.put("BNE-CNF", 19);
+        distances.put("BNE-BRU", 21);
+        distances.put("BNE-ATL", 18);
+
+        // Flights
+        LocalDate firstDate = LocalDate.now();
+        int countDays = 5;
+        List<LocalDate> dates = new ArrayList<>(countDays);
+        dates.add(firstDate);
+        for (int i = 1; i < countDays; i++) {
+            dates.add(firstDate.plusDays(i));
+        }
+        List<Airport> homeAirports = new ArrayList<>(2);
+        homeAirports.add(pickRandomAirport(airports, ""));
+        homeAirports.add(pickRandomAirport(airports, homeAirports.get(0).getCode()));
+        List<LocalTime> times = IntStream.range(0, 23)
+                .mapToObj(i -> LocalTime.of(i, 0))
+                .toList();
+        int countFlights = 14;
+        List<Flight> flights =
+                generateFlights(countFlights, LocalDateTime.now().plusMinutes(1), airports, homeAirports, dates, times,
+                        distances);
+
+        // Flight assignments
+        List<FlightAssignment> flightAssignments = generateFlightAssignments(flights);
+
+        // Employees
+        List<Employee> employees = generateEmployees(flights, dates);
+
+        // Update problem facts
+        schedule.setAirports(airports);
+        schedule.setEmployees(employees);
+        schedule.setFlights(flights);
+        schedule.setFlightAssignments(flightAssignments);
+
+        return schedule;
+    }
+
+    private List<Employee> generateEmployees(List<Flight> flights, List<LocalDate> dates) {
+        Supplier<String> nameSupplier = () -> {
+            Function<String[], String> randomStringSelector = strings -> strings[random.nextInt(strings.length)];
+            String firstName = randomStringSelector.apply(FIRST_NAMES);
+            String lastName = randomStringSelector.apply(LAST_NAMES);
+            return firstName + " " + lastName;
+        };
+
+        List<Airport> flightAirports = flights.stream()
+                .map(Flight::getDepartureAirport)
+                .distinct()
+                .toList();
+
+        // two pilots and three attendants per airport
+        List<Employee> employees = new ArrayList<>(flightAirports.size() * 5);
+
+        AtomicInteger count = new AtomicInteger();
+        // Two teams per airport
+        flightAirports.forEach(airport -> IntStream.range(0, 2).forEach(i -> {
+            employees.add(new Employee(String.valueOf(count.incrementAndGet()), nameSupplier.get(), airport, List.of(PILOT_SKILL)));
+            employees.add(new Employee(String.valueOf(count.incrementAndGet()), nameSupplier.get(), airport, List.of(PILOT_SKILL)));
+            employees.add(
+                    new Employee(String.valueOf(count.incrementAndGet()), nameSupplier.get(), airport, List.of(ATTENDANT_SKILL)));
+            employees.add(
+                    new Employee(String.valueOf(count.incrementAndGet()), nameSupplier.get(), airport, List.of(ATTENDANT_SKILL)));
+            if (airport.getCode().equals("CNF")) {
+                employees.add(
+                        new Employee(String.valueOf(count.incrementAndGet()), nameSupplier.get(), airport, List.of(ATTENDANT_SKILL)));
+            }
+        }));
+
+        // Unavailable dates - 28% one date; 4% two dates
+        applyRandomValue((int) (0.28 * employees.size()), employees, e -> e.getUnavailableDays() == null,
+                e -> e.setUnavailableDays(List.of(dates.get(random.nextInt(dates.size())))));
+        applyRandomValue((int) (0.04 * employees.size()), employees, e -> e.getUnavailableDays() == null,
+                e -> {
+                    List<LocalDate> unavailableDates = new ArrayList<>(2);
+                    while (unavailableDates.size() < 2) {
+                        LocalDate nextDate = dates.get(random.nextInt(dates.size()));
+                        if (!unavailableDates.contains(nextDate)) {
+                            unavailableDates.add(nextDate);
+                        }
+                    }
+                    e.setUnavailableDays(unmodifiableList(unavailableDates));
+                });
+
+        return employees;
+    }
+
+    private List<Flight> generateFlights(int size, LocalDateTime startDatetime, List<Airport> airports,
+            List<Airport> homeAirports, List<LocalDate> dates, List<LocalTime> timeGroups, Map<String, Integer> distances) {
+        if (size % 2 != 0) {
+            throw new IllegalArgumentException("The size of flights must be even");
+        }
+
+        // Departure and arrival airports
+        List<Flight> flights = new ArrayList<>(size);
+        List<Airport> remainingAirports = airports.stream()
+                .filter(airport -> !homeAirports.contains(airport))
+                .toList();
+        int countFlights = 0;
+        while (countFlights < size) {
+            int routeSize = pickRandomRouteSize(countFlights, size);
+            Airport homeAirport = homeAirports.get(random.nextInt(homeAirports.size()));
+            Flight homeFlight = new Flight(String.valueOf(countFlights++), homeAirport,
+                    remainingAirports.get(random.nextInt(remainingAirports.size())));
+            flights.add(homeFlight);
+            Flight nextFlight = homeFlight;
+            for (int i = 0; i < routeSize - 2; i++) {
+                nextFlight = new Flight(String.valueOf(countFlights++), nextFlight.getArrivalAirport(),
+                        pickRandomAirport(remainingAirports, nextFlight.getArrivalAirport().getCode()));
+                flights.add(nextFlight);
+            }
+            flights.add(new Flight(String.valueOf(countFlights++), nextFlight.getArrivalAirport(),
+                    homeFlight.getDepartureAirport()));
+        }
+
+        // Flight number
+        IntStream.range(0, flights.size()).forEach(i -> flights.get(i)
+                .setFlightNumber("Flight %d".formatted(i + 1)));
+
+        // Flight duration
+        int countDates = size / dates.size();
+        BiConsumer<Flight, LocalDate> flightConsumer = (flight, date) -> {
+            int countHours = distances
+                    .get("%s-%s".formatted(flight.getDepartureAirport().getCode(), flight.getArrivalAirport().getCode()));
+            LocalTime startTime = timeGroups.get(random.nextInt(timeGroups.size()));
+            LocalDateTime departureDateTime = LocalDateTime.of(date, startTime);
+            if (departureDateTime.isBefore(startDatetime)) {
+                departureDateTime = startDatetime.plusHours(random.nextInt(4));
+            }
+            LocalDateTime arrivalDateTime = departureDateTime.plusHours(countHours);
+            flight.setDepartureUTCDateTime(departureDateTime);
+            flight.setArrivalUTCDateTime(arrivalDateTime);
+        };
+        dates.forEach(startDate -> applyRandomValue(countDates, flights, startDate,
+                flight -> flight.getDepartureUTCDateTime() == null, flightConsumer));
+        // Ensure there are no empty dates
+        flights.stream()
+                .filter(flight -> flight.getDepartureUTCDateTime() == null)
+                .forEach(flight -> flightConsumer.accept(flight, dates.get(random.nextInt(dates.size()))));
+        return unmodifiableList(flights);
+    }
+
+    private Airport pickRandomAirport(List<Airport> airports, String excludeCode) {
+        Airport airport = null;
+        while (airport == null || airport.getCode().equals(excludeCode)) {
+            airport = airports.stream()
+                    .skip(random.nextInt(airports.size()))
+                    .findFirst()
+                    .get();
+        }
+        return airport;
+    }
+
+    private int pickRandomRouteSize(int countFlights, int maxCountFlights) {
+        List<Integer> allowedSizes = List.of(2, 4, 6);
+        int limit = maxCountFlights - countFlights;
+        int routeSize = 0;
+        while (routeSize == 0 || routeSize > limit) {
+            routeSize = allowedSizes.stream()
+                    .skip(random.nextInt(3))
+                    .findFirst()
+                    .get();
+        }
+        return routeSize;
+    }
+
+    private List<FlightAssignment> generateFlightAssignments(List<Flight> flights) {
+        // 2 pilots and 2 or 3 attendants
+        List<FlightAssignment> flightAssignments = new ArrayList<>(flights.size() * 5);
+        AtomicInteger count = new AtomicInteger();
+        flights.forEach(flight -> {
+            AtomicInteger indexSkill = new AtomicInteger();
+            flightAssignments
+                    .add(new FlightAssignment(String.valueOf(count.incrementAndGet()), flight, indexSkill.incrementAndGet(), PILOT_SKILL));
+            flightAssignments
+                    .add(new FlightAssignment(String.valueOf(count.incrementAndGet()), flight, indexSkill.incrementAndGet(), PILOT_SKILL));
+            flightAssignments
+                    .add(new FlightAssignment(String.valueOf(count.incrementAndGet()), flight, indexSkill.incrementAndGet(),
+                            ATTENDANT_SKILL));
+            flightAssignments
+                    .add(new FlightAssignment(String.valueOf(count.incrementAndGet()), flight, indexSkill.incrementAndGet(),
+                            ATTENDANT_SKILL));
+            if (flight.getDepartureAirport().getCode().equals("CNF") || flight.getArrivalAirport().getCode().equals("CNF")) {
+                flightAssignments
+                        .add(new FlightAssignment(String.valueOf(count.incrementAndGet()), flight, indexSkill.incrementAndGet(),
+                                ATTENDANT_SKILL));
+            }
+        });
+        return unmodifiableList(flightAssignments);
+    }
+
+    private <T> void applyRandomValue(int count, List<T> values, Predicate<T> filter, Consumer<T> consumer) {
+        int size = (int) values.stream().filter(filter).count();
+        for (int i = 0; i < count; i++) {
+            values.stream()
+                    .filter(filter)
+                    .skip(size > 0 ? random.nextInt(size) : 0).findFirst()
+                    .ifPresent(consumer::accept);
+            size--;
+            if (size < 0) {
+                break;
+            }
+        }
+    }
+
+    private <T, L> void applyRandomValue(int count, List<T> values, L secondParam, Predicate<T> filter,
+            BiConsumer<T, L> consumer) {
+        int size = (int) values.stream().filter(filter).count();
+        for (int i = 0; i < count; i++) {
+            values.stream()
+                    .filter(filter)
+                    .skip(size > 0 ? random.nextInt(size) : 0).findFirst()
+                    .ifPresent(v -> consumer.accept(v, secondParam));
+            size--;
+            if (size < 0) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Calculate the great circle distance between two points on Earth using the Haversine formula.
+     *
+     * @param lat1 Latitude of first point in degrees
+     * @param lon1 Longitude of first point in degrees
+     * @param lat2 Latitude of second point in degrees
+     * @param lon2 Longitude of second point in degrees
+     * @return Distance in kilometers
+     */
+    private double calculateHaversineDistance(double lat1, double lon1, double lat2, double lon2) {
+        final double EARTH_RADIUS_KM = 6371.0;
+
+        // Convert degrees to radians
+        double lat1Rad = Math.toRadians(lat1);
+        double lon1Rad = Math.toRadians(lon1);
+        double lat2Rad = Math.toRadians(lat2);
+        double lon2Rad = Math.toRadians(lon2);
+
+        // Haversine formula
+        double dLat = lat2Rad - lat1Rad;
+        double dLon = lon2Rad - lon1Rad;
+
+        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+                + Math.cos(lat1Rad) * Math.cos(lat2Rad)
+                * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        return EARTH_RADIUS_KM * c;
+    }
+}

src/main/java/org/acme/flighcrewscheduling/rest/FlightCrewSchedulingDemoResource.java

@@ -0,0 +1,38 @@
+package org.acme.flighcrewscheduling.rest;
+
+import jakarta.inject.Inject;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.media.Content;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
+import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+
+@Tag(name = "Demo data", description = "Timefold-provided demo flight crew scheduling data.")
+@Path("demo-data")
+public class FlightCrewSchedulingDemoResource {
+
+    private final DemoDataGenerator dataGenerator;
+
+    @Inject
+    public FlightCrewSchedulingDemoResource(DemoDataGenerator dataGenerator) {
+        this.dataGenerator = dataGenerator;
+    }
+
+    @APIResponses(value = {
+            @APIResponse(responseCode = "200", description = "Unsolved demo schedule.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = FlightCrewSchedule.class))) })
+    @Operation(summary = "Find an unsolved demo schedule by ID.")
+    @GET
+    public Response generate() {
+        return Response.ok(dataGenerator.generateDemoData()).build();
+    }
+
+}

src/main/java/org/acme/flighcrewscheduling/rest/FlightCrewSchedulingResource.java

@@ -0,0 +1,230 @@
+package org.acme.flighcrewscheduling.rest;
+
+import java.time.LocalDateTime;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import jakarta.inject.Inject;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+
+import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
+import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
+import ai.timefold.solver.core.api.solver.ScoreAnalysisFetchPolicy;
+import ai.timefold.solver.core.api.solver.SolutionManager;
+import ai.timefold.solver.core.api.solver.SolverManager;
+import ai.timefold.solver.core.api.solver.SolverStatus;
+
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.acme.flighcrewscheduling.rest.exception.ErrorInfo;
+import org.acme.flighcrewscheduling.rest.exception.ScheduleSolverException;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
+import org.eclipse.microprofile.openapi.annotations.media.Content;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
+import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Tag(name = "Flight Crew Scheduling",
+        description = "Flight Crew Scheduling service assigning crew for flights.")
+@Path("schedules")
+public class FlightCrewSchedulingResource {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(FlightCrewSchedulingResource.class);
+    private static final int MAX_JOBS_CACHE_SIZE = 2;
+
+    private final SolverManager<FlightCrewSchedule, String> solverManager;
+    private final SolutionManager<FlightCrewSchedule, HardSoftScore> solutionManager;
+    private final ConcurrentMap<String, Job> jobIdToJob = new ConcurrentHashMap<>();
+
+    // Workaround to make Quarkus CDI happy. Do not use.
+    public FlightCrewSchedulingResource() {
+        this.solverManager = null;
+        this.solutionManager = null;
+    }
+
+    @Inject
+    public FlightCrewSchedulingResource(SolverManager<FlightCrewSchedule, String> solverManager,
+            SolutionManager<FlightCrewSchedule, HardSoftScore> solutionManager) {
+        this.solverManager = solverManager;
+        this.solutionManager = solutionManager;
+    }
+
+    @Operation(summary = "List the job IDs of all submitted schedules.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "200", description = "List of all job IDs.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(type = SchemaType.ARRAY, implementation = String.class))) })
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public Collection<String> list() {
+        return jobIdToJob.keySet();
+    }
+
+    @Operation(summary = "Submit a schedule to start solving as soon as CPU resources are available.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "202",
+                    description = "The job ID. Use that ID to get the solution with the other methods.",
+                    content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(implementation = String.class))) })
+    @POST
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces(MediaType.TEXT_PLAIN)
+    public String solve(FlightCrewSchedule problem) {
+        String jobId = UUID.randomUUID().toString();
+        jobIdToJob.put(jobId, Job.ofSchedule(problem));
+        solverManager.solveBuilder()
+                .withProblemId(jobId)
+                .withProblemFinder(id -> jobIdToJob.get(jobId).schedule)
+                .withBestSolutionConsumer(solution -> jobIdToJob.put(jobId, Job.ofSchedule(solution)))
+                .withExceptionHandler((id, exception) -> {
+                    jobIdToJob.put(id, Job.ofException(exception));
+                    LOGGER.error("Failed solving jobId ({}).", id, exception);
+                })
+                .run();
+        cleanJobs();
+        return jobId;
+    }
+
+    @Operation(summary = "Submit a schedule to analyze its score.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "202",
+                    description = "Resulting score analysis, optionally without constraint matches.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ScoreAnalysis.class))) })
+    @PUT
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("analyze")
+    public ScoreAnalysis<HardSoftScore> analyze(FlightCrewSchedule problem,
+            @QueryParam("fetchPolicy") ScoreAnalysisFetchPolicy fetchPolicy) {
+        return fetchPolicy == null ? solutionManager.analyze(problem) : solutionManager.analyze(problem, fetchPolicy);
+    }
+
+    @Operation(
+            summary = "Get the solution and score for a given job ID. This is the best solution so far, as it might still be running or not even started.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "200", description = "The best solution of the schedule so far.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = FlightCrewSchedule.class))),
+            @APIResponse(responseCode = "404", description = "No schedule found.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class))),
+            @APIResponse(responseCode = "500", description = "Exception during solving a schedule.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class)))
+    })
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("{jobId}")
+    public FlightCrewSchedule getSchedule(
+            @Parameter(description = "The job ID returned by the POST method.") @PathParam("jobId") String jobId) {
+        FlightCrewSchedule schedule = getScheduleAndCheckForExceptions(jobId);
+        SolverStatus solverStatus = solverManager.getSolverStatus(jobId);
+        schedule.setSolverStatus(solverStatus);
+        return schedule;
+    }
+
+    @Operation(
+            summary = "Get the schedule status and score for a given job ID.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "200", description = "The schedule status and the best score so far.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = FlightCrewSchedule.class))),
+            @APIResponse(responseCode = "404", description = "No schedule found.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class))),
+            @APIResponse(responseCode = "500", description = "Exception during solving a schedule.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class)))
+    })
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("{jobId}/status")
+    public FlightCrewSchedule getStatus(
+            @Parameter(description = "The job ID returned by the POST method.") @PathParam("jobId") String jobId) {
+        FlightCrewSchedule schedule = getScheduleAndCheckForExceptions(jobId);
+        SolverStatus solverStatus = solverManager.getSolverStatus(jobId);
+        return new FlightCrewSchedule(schedule.getScore(), solverStatus);
+    }
+
+    @Operation(
+            summary = "Terminate solving for a given job ID. Returns the best solution of the schedule so far, as it might still be running or not even started.")
+    @APIResponses(value = {
+            @APIResponse(responseCode = "200", description = "The best solution of the schedule so far.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = FlightCrewSchedule.class))),
+            @APIResponse(responseCode = "404", description = "No schedule found.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class))),
+            @APIResponse(responseCode = "500", description = "Exception during solving a schedule.",
+                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
+                            schema = @Schema(implementation = ErrorInfo.class)))
+    })
+    @DELETE
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("{jobId}")
+    public FlightCrewSchedule terminateSolving(
+            @Parameter(description = "The job ID returned by the POST method.") @PathParam("jobId") String jobId) {
+        solverManager.terminateEarly(jobId);
+        return getSchedule(jobId);
+    }
+
+    private FlightCrewSchedule getScheduleAndCheckForExceptions(String jobId) {
+        Job job = jobIdToJob.get(jobId);
+        if (job == null) {
+            throw new ScheduleSolverException(jobId, Response.Status.NOT_FOUND, "No schedule found.");
+        }
+        if (job.exception != null) {
+            throw new ScheduleSolverException(jobId, job.exception);
+        }
+        return job.schedule;
+    }
+
+    /**
+     * The method retains only the records of the last MAX_JOBS_CACHE_SIZE completed jobs by removing the oldest ones.
+     */
+    private void cleanJobs() {
+        if (jobIdToJob.size() <= MAX_JOBS_CACHE_SIZE) {
+            return;
+        }
+        List<String> jobsToRemove = jobIdToJob.entrySet().stream()
+                .filter(e -> getStatus(e.getKey()).getSolverStatus() != SolverStatus.NOT_SOLVING)
+                .filter(e -> jobIdToJob.get(e.getKey()).schedule() != null)
+                .sorted((j1, j2) -> jobIdToJob.get(j1.getKey()).createdAt().compareTo(jobIdToJob.get(j2.getKey()).createdAt()))
+                .map(Entry::getKey)
+                .toList();
+        if (jobsToRemove.size() > MAX_JOBS_CACHE_SIZE) {
+            for (int i = 0; i < jobsToRemove.size() - MAX_JOBS_CACHE_SIZE; i++) {
+                jobIdToJob.remove(jobsToRemove.get(i));
+            }
+        }
+    }
+
+    private record Job(FlightCrewSchedule schedule, LocalDateTime createdAt, Throwable exception) {
+
+        static Job ofSchedule(FlightCrewSchedule schedule) {
+            return new Job(schedule, LocalDateTime.now(), null);
+        }
+
+        static Job ofException(Throwable error) {
+            return new Job(null, LocalDateTime.now(), error);
+        }
+    }
+}

src/main/java/org/acme/flighcrewscheduling/rest/exception/ErrorInfo.java

@@ -0,0 +1,4 @@
+package org.acme.flighcrewscheduling.rest.exception;
+
+public record ErrorInfo(String jobId, String message) {
+}

src/main/java/org/acme/flighcrewscheduling/rest/exception/ScheduleSolverException.java

@@ -0,0 +1,30 @@
+package org.acme.flighcrewscheduling.rest.exception;
+
+import jakarta.ws.rs.core.Response;
+
+public class ScheduleSolverException extends RuntimeException {
+
+    private final String jobId;
+
+    private final Response.Status status;
+
+    public ScheduleSolverException(String jobId, Response.Status status, String message) {
+        super(message);
+        this.jobId = jobId;
+        this.status = status;
+    }
+
+    public ScheduleSolverException(String jobId, Throwable cause) {
+        super(cause.getMessage(), cause);
+        this.jobId = jobId;
+        this.status = Response.Status.INTERNAL_SERVER_ERROR;
+    }
+
+    public String getJobId() {
+        return jobId;
+    }
+
+    public Response.Status getStatus() {
+        return status;
+    }
+}

src/main/java/org/acme/flighcrewscheduling/rest/exception/ScheduleSolverExceptionMapper.java

@@ -0,0 +1,19 @@
+package org.acme.flighcrewscheduling.rest.exception;
+
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.ext.ExceptionMapper;
+import jakarta.ws.rs.ext.Provider;
+
+@Provider
+public class ScheduleSolverExceptionMapper implements ExceptionMapper<ScheduleSolverException> {
+
+    @Override
+    public Response toResponse(ScheduleSolverException exception) {
+        return Response
+                .status(exception.getStatus())
+                .type(MediaType.APPLICATION_JSON)
+                .entity(new ErrorInfo(exception.getJobId(), exception.getMessage()))
+                .build();
+    }
+}

src/main/java/org/acme/flighcrewscheduling/solver/FlightCrewSchedulingConstraintProvider.java

@@ -0,0 +1,398 @@
+package org.acme.flighcrewscheduling.solver;
+
+import static ai.timefold.solver.core.api.score.stream.Joiners.equal;
+import static ai.timefold.solver.core.api.score.stream.Joiners.filtering;
+import static ai.timefold.solver.core.api.score.stream.Joiners.greaterThan;
+import static ai.timefold.solver.core.api.score.stream.Joiners.lessThan;
+import static ai.timefold.solver.core.api.score.stream.Joiners.overlapping;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
+
+import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
+import ai.timefold.solver.core.api.score.stream.Constraint;
+import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
+import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
+import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
+
+import org.acme.flighcrewscheduling.domain.Employee;
+import org.acme.flighcrewscheduling.domain.FlightAssignment;
+
+public class FlightCrewSchedulingConstraintProvider implements ConstraintProvider {
+
+    @Override
+    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
+        return new Constraint[] {
+                requiredSkill(constraintFactory),
+                flightConflict(constraintFactory),
+                transferBetweenTwoFlights(constraintFactory),
+                employeeUnavailability(constraintFactory),
+                firstAssignmentNotDepartingFromHome(constraintFactory),
+                lastAssignmentNotArrivingAtHome(constraintFactory),
+
+                // EASA FTL rest period constraints
+                minimumRestAtHomeBase(constraintFactory),
+                minimumRestAwayFromHomeBase(constraintFactory),
+                extendedRecoveryRestPeriod(constraintFactory),
+                minimumRestAfterLongHaul(constraintFactory),
+                minimumRestAfterConsecutiveLongHaul(constraintFactory)
+        };
+    }
+
+    public Constraint requiredSkill(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .filter(flightAssignment -> !flightAssignment.hasRequiredSkills())
+                .penalize(HardSoftLongScore.ofHard(100))
+                .asConstraint("Required skill");
+    }
+
+    public Constraint flightConflict(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEachUniquePair(FlightAssignment.class,
+                equal(FlightAssignment::getEmployee),
+                overlapping(flightAssignment -> flightAssignment.getFlight().getDepartureUTCDateTime(),
+                        flightAssignment -> flightAssignment.getFlight().getArrivalUTCDateTime()))
+                .penalize(HardSoftLongScore.ofHard(10))
+                .asConstraint("Flight conflict");
+    }
+
+    public Constraint transferBetweenTwoFlights(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .join(FlightAssignment.class, equal(FlightAssignment::getEmployee),
+                        lessThan(FlightAssignment::getDepartureUTCDateTime),
+                        filtering((flightAssignment,
+                                flightAssignment2) -> !flightAssignment.getId().equals(flightAssignment2.getId())))
+                .ifNotExists(FlightAssignment.class,
+                        equal(((flightAssignment, flightAssignment2) -> flightAssignment.getEmployee()),
+                                FlightAssignment::getEmployee),
+                        filtering((flightAssignment, flightAssignment2,
+                                otherFlightAssignment) -> !otherFlightAssignment.getId().equals(flightAssignment.getId())
+                                        && !otherFlightAssignment.getId().equals(flightAssignment2.getId())
+                                        && !otherFlightAssignment.getDepartureUTCDateTime()
+                                                .isBefore(flightAssignment.getDepartureUTCDateTime())
+                                        && otherFlightAssignment.getDepartureUTCDateTime()
+                                                .isBefore(flightAssignment2.getDepartureUTCDateTime())))
+                .filter((flightAssignment, flightAssignment2) -> {
+                    var arrivalAirport = flightAssignment.getArrivalAirport();
+                    var departureAirport = flightAssignment2.getDepartureAirport();
+
+                    // Violation if airports don't match
+                    if (!arrivalAirport.equals(departureAirport)) {
+                        return true;
+                    }
+
+                    // Additional check: if taxi time > 300 minutes (5 hours), also a violation
+                    Long taxiTime = arrivalAirport.getTaxiTimeInMinutesTo(departureAirport);
+                    return taxiTime != null && taxiTime > 300;
+                })
+                .penalize(HardSoftLongScore.ofHard(1))
+                .asConstraint("Transfer between two flights");
+    }
+
+    public Constraint employeeUnavailability(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .filter(FlightAssignment::isUnavailableEmployee)
+                .penalize(HardSoftLongScore.ofHard(10))
+                .asConstraint("Employee unavailable");
+    }
+
+    public Constraint firstAssignmentNotDepartingFromHome(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(Employee.class)
+                .join(FlightAssignment.class, equal(Function.identity(), FlightAssignment::getEmployee))
+                .ifNotExists(FlightAssignment.class,
+                        equal((employee, flightAssignment) -> employee, FlightAssignment::getEmployee),
+                        greaterThan((employee, flightAssignment) -> flightAssignment.getDepartureUTCDateTime(),
+                                FlightAssignment::getDepartureUTCDateTime))
+                .filter((employee,
+                        flightAssignment) -> !employee.getHomeAirport()
+                                .equals(flightAssignment.getFlight().getDepartureAirport()))
+                .penalize(HardSoftLongScore.ofSoft(1000))
+                .asConstraint("First assignment not departing from home");
+    }
+
+    public Constraint lastAssignmentNotArrivingAtHome(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(Employee.class)
+                .join(FlightAssignment.class, equal(Function.identity(), FlightAssignment::getEmployee))
+                .ifNotExists(FlightAssignment.class,
+                        equal((employee, flightAssignment) -> employee, FlightAssignment::getEmployee),
+                        lessThan((employee, flightAssignment) -> flightAssignment.getDepartureUTCDateTime(),
+                                FlightAssignment::getDepartureUTCDateTime))
+                .filter((employee,
+                        flightAssignment) -> !employee.getHomeAirport()
+                                .equals(flightAssignment.getFlight().getArrivalAirport()))
+                .penalize(HardSoftLongScore.ofSoft(1000))
+                .asConstraint("Last assignment not arriving at home");
+    }
+
+    public Constraint minimumRestAtHomeBase(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .join(FlightAssignment.class,
+                        equal(FlightAssignment::getEmployee),
+                        lessThan(FlightAssignment::getDutyEndDateTime, FlightAssignment::getDutyStartDateTime),
+                        filtering((assignment1, assignment2) -> !assignment1.getId().equals(assignment2.getId())))
+
+                // Ensure these are consecutive assignments (no other assignment between them)
+                .ifNotExists(FlightAssignment.class,
+                        equal((assignment1, assignment2) -> assignment1.getEmployee(), FlightAssignment::getEmployee),
+                        filtering((assignment1, assignment2, otherAssignment) ->
+                                !otherAssignment.getId().equals(assignment1.getId()) &&
+                                !otherAssignment.getId().equals(assignment2.getId()) &&
+                                otherAssignment.getDutyStartDateTime().isAfter(assignment1.getDutyEndDateTime()) &&
+                                otherAssignment.getDutyStartDateTime().isBefore(assignment2.getDutyStartDateTime())))
+
+                // Filter: applies only when assignment2 departs from employee's home base
+                .filter((assignment1, assignment2) ->
+                        assignment2.isAtHomeBase(assignment2.getDepartureAirport()))
+
+                // Calculate rest violation
+                .penalizeLong(HardSoftLongScore.ofHard(100),
+                        (assignment1, assignment2) -> {
+                            double precedingDutyHours = assignment1.getFlight().getFlightDutyPeriodHours();
+                            double requiredRestHours = Math.max(precedingDutyHours, 12.0);
+
+                            long actualRestMinutes = java.time.Duration.between(
+                                    assignment1.getDutyEndDateTime(),
+                                    assignment2.getDutyStartDateTime()).toMinutes();
+                            double actualRestHours = actualRestMinutes / 60.0;
+
+                            double violationHours = requiredRestHours - actualRestHours;
+                            return violationHours > 0 ? (long) Math.ceil(violationHours * 60) : 0;
+                        })
+                .asConstraint("Minimum rest at home base");
+    }
+
+    public Constraint minimumRestAwayFromHomeBase(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .join(FlightAssignment.class,
+                        equal(FlightAssignment::getEmployee),
+                        lessThan(FlightAssignment::getDutyEndDateTime, FlightAssignment::getDutyStartDateTime),
+                        filtering((assignment1, assignment2) -> !assignment1.getId().equals(assignment2.getId())))
+
+            // Ensure these are consecutive assignments
+                .ifNotExists(FlightAssignment.class,
+                        equal((assignment1, assignment2) -> assignment1.getEmployee(), FlightAssignment::getEmployee),
+                        filtering((assignment1, assignment2, otherAssignment) ->
+                                !otherAssignment.getId().equals(assignment1.getId()) &&
+                                !otherAssignment.getId().equals(assignment2.getId()) &&
+                                otherAssignment.getDutyStartDateTime().isAfter(assignment1.getDutyEndDateTime()) &&
+                                otherAssignment.getDutyStartDateTime().isBefore(assignment2.getDutyStartDateTime())))
+
+                // Filter: applies only when assignment2 does NOT depart from employee's home base
+                .filter((assignment1, assignment2) ->
+                        !assignment2.isAtHomeBase(assignment2.getDepartureAirport()))
+
+                // Calculate rest violation including travel time adjustment
+                .penalizeLong(HardSoftLongScore.ofHard(100),
+                        (assignment1, assignment2) -> {
+                            double precedingDutyHours = assignment1.getFlight().getFlightDutyPeriodHours();
+                            double baseRequiredRestHours = Math.max(precedingDutyHours, 10.0);
+
+                            // Calculate travel time adjustment
+                            var arrivalAirport = assignment1.getArrivalAirport();
+                            var departureAirport = assignment2.getDepartureAirport();
+                            Long taxiTimeMinutes = arrivalAirport.getTaxiTimeInMinutesTo(departureAirport);
+
+                            double travelAdjustmentHours = 0;
+                            if (taxiTimeMinutes != null && taxiTimeMinutes > 30) {
+                                // Add 2x the time above 30 minutes
+                                long excessMinutes = taxiTimeMinutes - 30;
+                                travelAdjustmentHours = (excessMinutes * 2) / 60.0;
+                            }
+
+                            double requiredRestHours = baseRequiredRestHours + travelAdjustmentHours;
+
+                            long actualRestMinutes = java.time.Duration.between(
+                                    assignment1.getDutyEndDateTime(),
+                                    assignment2.getDutyStartDateTime()).toMinutes();
+                            double actualRestHours = actualRestMinutes / 60.0;
+
+                            double violationHours = requiredRestHours - actualRestHours;
+                            return violationHours > 0 ? (long) Math.ceil(violationHours * 60) : 0;
+                        })
+                .asConstraint("Minimum rest away from home base");
+    }
+
+    /**
+     * Extended Recovery Rest Period (ERRP) constraint per EASA FTL regulations.
+     *
+     * <p>Requirement: Within any rolling 168-hour (7-day) window, crew members must have
+     * at least ONE rest period of 36 hours or more.
+     *
+     * <p>This constraint groups assignments by employee, then scans chronologically to detect
+     * any 168-hour period without a qualifying 36+ hour rest.
+     *
+     * <p>Violation example: An employee works 8 consecutive days with only 15-hour rests
+     * between shifts. After 7 days (168 hours), they've never had a 36+ hour rest, violating ERRP.
+     *
+     * @return hard constraint penalizing each 168-hour window lacking a 36+ hour rest
+     */
+    public Constraint extendedRecoveryRestPeriod(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .groupBy(FlightAssignment::getEmployee, ConstraintCollectors.toList())
+                .penalizeLong(HardSoftLongScore.ofHard(1000),
+                        (employee, assignments) -> {
+                            if (assignments.size() < 2) {
+                                return 0;
+                            }
+
+                            List<FlightAssignment> sorted = new ArrayList<>(assignments);
+                            sorted.sort(Comparator.comparing(FlightAssignment::getDutyStartDateTime));
+
+                            return countErrrpViolations(sorted);
+                        })
+                .asConstraint("Extended recovery rest period (ERRP)");
+    }
+
+    /**
+     * Count ERRP violations in a sorted list of assignments.
+     *
+     * @param sortedAssignments list sorted by duty start time
+     * @return number of 168-hour windows without a 36+ hour rest
+     */
+    private static long countErrrpViolations(List<FlightAssignment> sortedAssignments) {
+        long violations = 0;
+        LocalDateTime lastQualifyingRestEnd = null;
+
+        for (int i = 0; i < sortedAssignments.size() - 1; i++) {
+            FlightAssignment current = sortedAssignments.get(i);
+            FlightAssignment next = sortedAssignments.get(i + 1);
+
+            long restHours = java.time.Duration.between(
+                    current.getDutyEndDateTime(),
+                    next.getDutyStartDateTime()).toHours();
+
+            if (restHours >= 36) {
+                lastQualifyingRestEnd = current.getDutyEndDateTime();
+            } else {
+                // Short rest - check if we've exceeded 168h window
+                LocalDateTime windowStart = (lastQualifyingRestEnd != null)
+                        ? lastQualifyingRestEnd
+                        : sortedAssignments.get(0).getDutyStartDateTime();
+
+                long hoursSinceLastQualifyingRest = java.time.Duration.between(
+                        windowStart,
+                        next.getDutyStartDateTime()).toHours();
+
+                if (hoursSinceLastQualifyingRest > 168) {
+                    // Violation: more than 168 hours without a 36+ hour rest
+                    violations++;
+                }
+            }
+        }
+
+        return violations;
+    }
+
+    /**
+     * Minimum rest after standalone long haul flight constraint.
+     *
+     * <p>Requirement: After completing a standalone long haul flight (10+ hours duration),
+     * crew members must have at least 48 hours of rest before their next duty period.
+     *
+     * <p>This applies regardless of location (home base or away from home base).
+     * The enhanced rest period recognizes the additional fatigue from long haul operations.
+     *
+     * <p>This constraint handles ONLY standalone long haul flights.
+     * Consecutive flights that together form a long haul are handled by
+     * {@link #minimumRestAfterConsecutiveLongHaul(ConstraintFactory)}.
+     *
+     * @return hard constraint penalizing each hour of violation (in minutes)
+     */
+    public Constraint minimumRestAfterLongHaul(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class)
+                .join(FlightAssignment.class,
+                        equal(FlightAssignment::getEmployee),
+                        lessThan(FlightAssignment::getDutyEndDateTime, FlightAssignment::getDutyStartDateTime),
+                        filtering((assignment1, assignment2) -> !assignment1.getId().equals(assignment2.getId())))
+
+                // Ensure these are consecutive assignments (no other assignment between them)
+                .ifNotExists(FlightAssignment.class,
+                        equal((assignment1, assignment2) -> assignment1.getEmployee(), FlightAssignment::getEmployee),
+                        filtering((assignment1, assignment2, otherAssignment) ->
+                                !otherAssignment.getId().equals(assignment1.getId()) &&
+                                !otherAssignment.getId().equals(assignment2.getId()) &&
+                                otherAssignment.getDutyStartDateTime().isAfter(assignment1.getDutyEndDateTime()) &&
+                                otherAssignment.getDutyStartDateTime().isBefore(assignment2.getDutyStartDateTime())))
+
+                // Filter: applies only when assignment1 is a standalone long haul
+                // (not forming a sequence with assignment2)
+                .filter((assignment1, assignment2) ->
+                        assignment1.isLongHaulFlight() && !assignment1.formsLongHaulWithNext(assignment2))
+
+                // Calculate rest violation
+                .penalizeLong(HardSoftLongScore.ofHard(100),
+                        (assignment1, assignment2) -> {
+                            final double REQUIRED_REST_HOURS = 48.0;
+
+                            long actualRestMinutes = java.time.Duration.between(
+                                    assignment1.getDutyEndDateTime(),
+                                    assignment2.getDutyStartDateTime()).toMinutes();
+                            double actualRestHours = actualRestMinutes / 60.0;
+
+                            double violationHours = REQUIRED_REST_HOURS - actualRestHours;
+                            return violationHours > 0 ? (long) Math.ceil(violationHours * 60) : 0;
+                        })
+                .asConstraint("Minimum rest after long haul flight");
+    }
+
+    /**
+     * Minimum rest after consecutive flights forming long haul constraint.
+     *
+     * <p>Requirement: When two consecutive flights together form a long haul operation
+     * (combined duration >= 10 hours), crew members must have at least 48 hours of rest
+     * AFTER the second flight before their next duty period.
+     *
+     * <p>Consecutive flights are defined as:
+     * - Arrival airport of first flight matches departure airport of second flight
+     * - Time between flights is less than 2 hours
+     * - Combined flight time >= 10 hours
+     *
+     * <p>This constraint looks at triplets of consecutive assignments (A, B, C) and enforces
+     * 48h rest between B and C when A + B together form a long haul.
+     *
+     * @return hard constraint penalizing each hour of violation (in minutes)
+     */
+    public Constraint minimumRestAfterConsecutiveLongHaul(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(FlightAssignment.class) // B - the second flight in a potential long haul sequence
+                .join(FlightAssignment.class, // C - the flight after B
+                        equal(FlightAssignment::getEmployee),
+                        lessThan(FlightAssignment::getDutyEndDateTime, FlightAssignment::getDutyStartDateTime),
+                        filtering((b, c) -> !b.getId().equals(c.getId())))
+
+                // Ensure B and C are consecutive
+                .ifNotExists(FlightAssignment.class,
+                        equal((b, c) -> b.getEmployee(), FlightAssignment::getEmployee),
+                        filtering((b, c, other) ->
+                                !other.getId().equals(b.getId()) &&
+                                !other.getId().equals(c.getId()) &&
+                                other.getDutyStartDateTime().isAfter(b.getDutyEndDateTime()) &&
+                                other.getDutyStartDateTime().isBefore(c.getDutyStartDateTime())))
+
+                // Now join with A (the flight before B)
+                // Use arrival time instead of duty end time to check temporal ordering
+                .join(FlightAssignment.class, // A - the first flight in the long haul sequence
+                        equal((b, c) -> b.getEmployee(), FlightAssignment::getEmployee),
+                        greaterThan((b, c) -> b.getDepartureUTCDateTime(), FlightAssignment::getArrivalUTCDateTime),
+                        filtering((b, c, a) -> !a.getId().equals(b.getId())))
+
+                // Filter: only proceed if A + B form a long haul (this also checks they're consecutive)
+                .filter((b, c, a) -> a.formsLongHaulWithNext(b))
+
+                // Calculate rest violation between B and C
+                .penalizeLong(HardSoftLongScore.ofHard(100),
+                        (b, c, a) -> {
+                            final double REQUIRED_REST_HOURS = 48.0;
+
+                            long actualRestMinutes = java.time.Duration.between(
+                                    b.getDutyEndDateTime(),
+                                    c.getDutyStartDateTime()).toMinutes();
+                            double actualRestHours = actualRestMinutes / 60.0;
+
+                            double violationHours = REQUIRED_REST_HOURS - actualRestHours;
+                            return violationHours > 0 ? (long) Math.ceil(violationHours * 60) : 0;
+                        })
+                .asConstraint("Minimum rest after consecutive long haul flights");
+    }
+}

src/main/resources/META-INF/resources/app.js

@@ -0,0 +1,431 @@
+let autoRefreshIntervalId = null;
+const formatter = JSJoda.DateTimeFormatter.ofPattern("MM/dd/YYYY HH:mm").withLocale(JSJodaLocale.Locale.ENGLISH);
+
+const zoomMin = 1000 * 60 * 60 * 8 // 2 hours in milliseconds
+const zoomMax = 2 * 7 * 1000 * 60 * 60 * 24 // 2 weeks in milliseconds
+
+const byTimelineOptions = {
+    timeAxis: {scale: "hour", step: 8},
+    orientation: {axis: "top"},
+    stack: false,
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: zoomMin,
+    zoomMax: zoomMax,
+};
+
+const byCrewPanel = document.getElementById("byCrewPanel");
+let byCrewGroupData = new vis.DataSet();
+let byCrewItemData = new vis.DataSet();
+let byCrewTimeline = new vis.Timeline(byCrewPanel, byCrewItemData, byCrewGroupData, byTimelineOptions);
+
+const byFlightPanel = document.getElementById("byFlightPanel");
+let byFlightGroupData = new vis.DataSet();
+let byFlightItemData = new vis.DataSet();
+let byFlightTimeline = new vis.Timeline(byFlightPanel, byFlightItemData, byFlightGroupData, byTimelineOptions);
+
+let scheduleId = null;
+let loadedSchedule = null;
+let viewType = "R";
+
+$(document).ready(function () {
+    replaceQuickstartTimefoldAutoHeaderFooter();
+
+    $("#solveButton").click(function () {
+        solve();
+    });
+    $("#stopSolvingButton").click(function () {
+        stopSolving();
+    });
+    $("#analyzeButton").click(function () {
+        analyze();
+    });
+    $("#byCrewTab").click(function () {
+        viewType = "R";
+        refreshSchedule();
+    });
+    $("#byFlightTab").click(function () {
+        viewType = "F";
+        refreshSchedule();
+    });
+    // HACK to allow vis-timeline to work within Bootstrap tabs
+    $("#byCrewTab").on('shown.bs.tab', function (event) {
+        byCrewTimeline.redraw();
+    })
+    $("#byFlightTab").on('shown.bs.tab', function (event) {
+        byFlightTimeline.redraw();
+    })
+
+    setupAjax();
+    refreshSchedule();
+});
+
+function setupAjax() {
+    $.ajaxSetup({
+        headers: {
+            'Content-Type': 'application/json', 'Accept': 'application/json,text/plain', // plain text is required by solve() returning UUID of the solver job
+        }
+    });
+
+    // Extend jQuery to support $.put() and $.delete()
+    jQuery.each(["put", "delete"], function (i, method) {
+        jQuery[method] = function (url, data, callback, type) {
+            if (jQuery.isFunction(data)) {
+                type = type || callback;
+                callback = data;
+                data = undefined;
+            }
+            return jQuery.ajax({
+                url: url, type: method, dataType: type, data: data, success: callback
+            });
+        };
+    });
+}
+
+function refreshSchedule() {
+    let path = "/schedules/" + scheduleId;
+    if (scheduleId === null) {
+        path = "/demo-data";
+    }
+
+    $.getJSON(path, function (schedule) {
+        loadedSchedule = schedule;
+        $('#exportData').attr('href', 'data:text/plain;charset=utf-8,' + JSON.stringify(loadedSchedule));
+        renderSchedule(schedule);
+    })
+        .fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Getting the schedule has failed.", xhr);
+            refreshSolvingButtons(false);
+        });
+}
+
+function renderSchedule(schedule) {
+    refreshSolvingButtons(schedule.solverStatus != null && schedule.solverStatus !== "NOT_SOLVING");
+    $("#score").text("Score: " + (schedule.score == null ? "?" : schedule.score));
+
+    if (viewType === "R") {
+        renderScheduleByCrew(schedule);
+    }
+    if (viewType === "F") {
+        renderScheduleByFlight(schedule);
+    }
+}
+
+function renderScheduleByCrew(schedule) {
+    const unassignedCrew = $("#unassignedCrew");
+    unassignedCrew.children().remove();
+    let unassignedCrewCount = 0;
+    byCrewGroupData.clear();
+    byCrewItemData.clear();
+
+    $.each(schedule.employees.sort((e1, e2) => e1.name.localeCompare(e2.name)), (_, employee) => {
+        const crewIcon = employee.skills.indexOf("Pilot") >= 0 ? '<span class="fas fa-solid fa-plane-departure" title="Pilot"></span>' :
+            '<span class="fas fa-solid fa-glass-martini" title="Flight Attendant"></span>';
+        let content = `<div class="d-flex flex-column"><div><h5 class="card-title mb-1">${employee.name} (${employee.homeAirport}) ${crewIcon}</h5></div>`;
+
+        byCrewGroupData.add({
+            id: employee.id,
+            content: content,
+        });
+
+        // Unavailable days
+        if (employee.unavailableDays) {
+            let count = 0;
+            employee.unavailableDays.forEach(date => {
+                const unavailableDatetime = JSJoda.LocalDate.parse(date);
+                byCrewItemData.add({
+                    id: `${employee.id}-${count++}`,
+                    group: employee.id,
+                    content: $(`<div />`).html(),
+                    start: unavailableDatetime.atStartOfDay().toString(),
+                    end: unavailableDatetime.atStartOfDay().withHour(23).withMinute(59).toString(),
+                    style: "background-color: gray; min-height: 50px"
+                });
+            });
+        }
+    });
+
+    const flightMap = new Map();
+    schedule.flights.forEach(f => flightMap.set(f.flightNumber, f));
+    $.each(schedule.flightAssignments, (_, assignment) => {
+        const flight = flightMap.get(assignment.flight);
+        if (assignment.employee == null) {
+            unassignedCrewCount++;
+            const departureDateTime = JSJoda.LocalDateTime.parse(flight.departureUTCDateTime);
+            const arrivalDateTime = JSJoda.LocalDateTime.parse(flight.arrivalUTCDateTime);
+            const unassignedElement = $(`<div class="card-body"/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(`${flight.departureAirport} → ${flight.arrivalAirport}`))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`${departureDateTime.until(arrivalDateTime, JSJoda.ChronoUnit.HOURS)} hour(s)`))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`Departure: ${formatter.format(departureDateTime)}`))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`Arrival: ${formatter.format(arrivalDateTime)}`));
+
+            unassignedCrew.append($(`<div class="pl-1"/>`).append($(`<div class="card"/>`).append(unassignedElement)));
+            byCrewItemData.add({
+                id: assignment.id,
+                group: assignment.employee,
+                start: formatter.format(departureDateTime),
+                end: formatter.format(arrivalDateTime),
+                style: "background-color: #EF292999"
+            });
+        } else {
+            const byCrewElement = $("<div />").append($("<div class='d-flex justify-content-center' />").append($(`<h5 class="card-title mb-1"/>`).text(`${flight.departureAirport} → ${flight.arrivalAirport}`)));
+            byCrewItemData.add({
+                id: assignment.id,
+                group: assignment.employee,
+                content: byCrewElement.html(),
+                start: flight.departureUTCDateTime,
+                end: flight.arrivalUTCDateTime,
+                style: "min-height: 50px"
+            });
+        }
+    });
+    if (unassignedCrewCount === 0) {
+        unassignedCrew.append($(`<p/>`).text(`There are no unassigned crew.`));
+    }
+    byCrewTimeline.setWindow(JSJoda.LocalDateTime.now().minusMinutes(1).toString(),
+        JSJoda.LocalDateTime.now().plusDays(4).withHour(23).withMinute(59).toString());
+    byCrewTimeline.redraw();
+}
+
+function renderScheduleByFlight(schedule) {
+    const unassignedCrew = $("#unassignedCrew");
+    unassignedCrew.children().remove();
+    byFlightGroupData.clear();
+    byFlightItemData.clear();
+
+    $.each(schedule.flights.sort((e1, e2) => JSJoda.LocalDateTime.parse(e1.departureUTCDateTime)
+        .compareTo(JSJoda.LocalDateTime.parse(e2.departureUTCDateTime))), (_, flight) => {
+        let content = `<div class="d-flex flex-column"><div><h5 class="card-title mb-1">${flight.departureAirport} → ${flight.arrivalAirport}</h5></div>`;
+
+        byFlightGroupData.add({
+            id: flight.flightNumber,
+            content: content,
+        });
+    });
+
+    const employeeMap = new Map();
+    schedule.employees.forEach(e => employeeMap.set(e.id, e));
+
+    $.each(schedule.flights, (_, flight) => {
+        const content = $(`<div class="card-body"/>`).append($(`<h4 class="card-title mb-1"/>`).text(flight.flightNumber));
+        const unassignedElement = $(`<div class="card-body"/>`).append($(`<h4 class="card-title mb-1"/>`).text(`${flight.departureAirport} → ${flight.arrivalAirport}`));
+        const assignments = schedule.flightAssignments.filter(f => f.flight === flight.flightNumber);
+        let countUnassigned = 0;
+        const missingSkills = [];
+        const pilots = [];
+        const attendants = [];
+        assignments.forEach(assigment => {
+            if (assigment.employee == null) {
+                countUnassigned++;
+                missingSkills.push(assigment.requiredSkill);
+            } else {
+                const employee = employeeMap.get(assigment.employee);
+                if (assigment.requiredSkill === 'Pilot') {
+                    pilots.push(employee.name);
+                } else {
+                    attendants.push(employee.name);
+                }
+            }
+        });
+
+        if (pilots.length > 0 && attendants.length > 0) {
+            content.append($(`<p class="card-text" style="font-weight: bold"/>`).text(`Pilot(s)`));
+            pilots.sort().forEach(pilot => content.append($(`<p class="card-text mx-2"/>`).text(pilot)));
+            content.append($(`<p class="card-text" style="font-weight: bold"/>`).text(`Attendant(s)`));
+            attendants.sort().forEach(attendant => content.append($(`<p class="card-text mx-2"/>`).text(attendant)));
+            byFlightItemData.add({
+                id: flight.flightNumber,
+                group: flight.flightNumber,
+                content: $('<div class="d-flex flex-column" />').append(content).html(),
+                start: flight.departureUTCDateTime,
+                end: flight.arrivalUTCDateTime,
+            });
+        }
+        if (countUnassigned > 0) {
+            unassignedElement.append($(`<p class="card-text ms-2 mb-0"/>`).text(`Unassigned skill(s): ${missingSkills.sort().join(", ")}`));
+            unassignedCrew.append($(`<div class="pl-1"/>`).append($(`<div class="card"/>`).append(unassignedElement)));
+        }
+    });
+
+    byFlightTimeline.setWindow(JSJoda.LocalDateTime.now().minusMinutes(1).toString(),
+        JSJoda.LocalDateTime.now().plusDays(4).withHour(23).withMinute(59).toString());
+    byFlightTimeline.redraw();
+}
+
+function solve() {
+    $.post("/schedules", JSON.stringify(loadedSchedule), function (data) {
+        scheduleId = data;
+        refreshSolvingButtons(true);
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+        showError("Start solving failed.", xhr);
+        refreshSolvingButtons(false);
+    }, "text");
+}
+
+function analyze() {
+    new bootstrap.Modal("#scoreAnalysisModal").show()
+    const scoreAnalysisModalContent = $("#scoreAnalysisModalContent");
+    scoreAnalysisModalContent.children().remove();
+    if (loadedSchedule.score == null) {
+        scoreAnalysisModalContent.text("No score to analyze yet, please first press the 'solve' button.");
+    } else {
+        $('#scoreAnalysisScoreLabel').text(`(${loadedSchedule.score})`);
+        $.put("/schedules/analyze", JSON.stringify(loadedSchedule), function (scoreAnalysis) {
+            let constraints = scoreAnalysis.constraints;
+            constraints.sort((a, b) => {
+                let aComponents = getScoreComponents(a.score), bComponents = getScoreComponents(b.score);
+                if (aComponents.hard < 0 && bComponents.hard > 0) return -1;
+                if (aComponents.hard > 0 && bComponents.soft < 0) return 1;
+                if (Math.abs(aComponents.hard) > Math.abs(bComponents.hard)) {
+                    return -1;
+                } else {
+                    if (aComponents.medium < 0 && bComponents.medium > 0) return -1;
+                    if (aComponents.medium > 0 && bComponents.medium < 0) return 1;
+                    if (Math.abs(aComponents.medium) > Math.abs(bComponents.medium)) {
+                        return -1;
+                    } else {
+                        if (aComponents.soft < 0 && bComponents.soft > 0) return -1;
+                        if (aComponents.soft > 0 && bComponents.soft < 0) return 1;
+
+                        return Math.abs(bComponents.soft) - Math.abs(aComponents.soft);
+                    }
+                }
+            });
+            constraints.map((e) => {
+                let components = getScoreComponents(e.weight);
+                e.type = components.hard != 0 ? 'hard' : (components.medium != 0 ? 'medium' : 'soft');
+                e.weight = components[e.type];
+                let scores = getScoreComponents(e.score);
+                e.implicitScore = scores.hard != 0 ? scores.hard : (scores.medium != 0 ? scores.medium : scores.soft);
+            });
+            scoreAnalysis.constraints = constraints;
+
+            scoreAnalysisModalContent.children().remove();
+            scoreAnalysisModalContent.text("");
+
+            const analysisTable = $(`<table class="table"/>`).css({textAlign: 'center'});
+            const analysisTHead = $(`<thead/>`).append($(`<tr/>`)
+                .append($(`<th></th>`))
+                .append($(`<th>Constraint</th>`).css({textAlign: 'left'}))
+                .append($(`<th>Type</th>`))
+                .append($(`<th># Matches</th>`))
+                .append($(`<th>Weight</th>`))
+                .append($(`<th>Score</th>`))
+                .append($(`<th></th>`)));
+            analysisTable.append(analysisTHead);
+            const analysisTBody = $(`<tbody/>`)
+            $.each(scoreAnalysis.constraints, (index, constraintAnalysis) => {
+                let icon = constraintAnalysis.type == "hard" && constraintAnalysis.implicitScore < 0 ? '<span class="fas fa-exclamation-triangle" style="color: red"></span>' : '';
+                if (!icon) icon = constraintAnalysis.matches.length == 0 ? '<span class="fas fa-check-circle" style="color: green"></span>' : '';
+
+                let row = $(`<tr/>`);
+                row.append($(`<td/>`).html(icon))
+                    .append($(`<td/>`).text(constraintAnalysis.name).css({textAlign: 'left'}))
+                    .append($(`<td/>`).text(constraintAnalysis.type))
+                    .append($(`<td/>`).html(`<b>${constraintAnalysis.matches.length}</b>`))
+                    .append($(`<td/>`).text(constraintAnalysis.weight))
+                    .append($(`<td/>`).text(constraintAnalysis.implicitScore));
+                analysisTBody.append(row);
+                row.append($(`<td/>`));
+            });
+            analysisTable.append(analysisTBody);
+            scoreAnalysisModalContent.append(analysisTable);
+        }).fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Analyze failed.", xhr);
+        }, "text");
+    }
+}
+
+function getScoreComponents(score) {
+    let components = {hard: 0, medium: 0, soft: 0};
+
+    $.each([...score.matchAll(/(-?[0-9]+)(hard|medium|soft)/g)], (i, parts) => {
+        components[parts[2]] = parseInt(parts[1], 10);
+    });
+
+    return components;
+}
+
+function refreshSolvingButtons(solving) {
+    if (solving) {
+        $("#solveButton").hide();
+        $("#stopSolvingButton").show();
+        if (autoRefreshIntervalId == null) {
+            autoRefreshIntervalId = setInterval(refreshSchedule, 2000);
+        }
+    } else {
+        $("#solveButton").show();
+        $("#stopSolvingButton").hide();
+        if (autoRefreshIntervalId != null) {
+            clearInterval(autoRefreshIntervalId);
+            autoRefreshIntervalId = null;
+        }
+    }
+}
+
+function stopSolving() {
+    $.delete("/schedules/" + scheduleId, function () {
+        refreshSolvingButtons(false);
+        refreshSchedule();
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+        showError("Stop solving failed.", xhr);
+    });
+}
+
+function copyTextToClipboard(id) {
+    var text = $("#" + id).text().trim();
+
+    var dummy = document.createElement("textarea");
+    document.body.appendChild(dummy);
+    dummy.value = text;
+    dummy.select();
+    document.execCommand("copy");
+    document.body.removeChild(dummy);
+}
+
+// TODO: move to the webjar
+function replaceQuickstartTimefoldAutoHeaderFooter() {
+    const timefoldHeader = $("header#timefold-auto-header");
+    if (timefoldHeader != null) {
+        timefoldHeader.addClass("bg-black")
+        timefoldHeader.append($(`<div class="container-fluid">
+        <nav class="navbar sticky-top navbar-expand-lg navbar-dark shadow mb-3">
+          <a class="navbar-brand" href="https://timefold.ai">
+            <img src="/webjars/timefold/img/timefold-logo-horizontal-negative.svg" alt="Timefold logo" width="200">
+          </a>
+          <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
+            <span class="navbar-toggler-icon"></span>
+          </button>
+          <div class="collapse navbar-collapse" id="navbarNav">
+            <ul class="nav nav-pills">
+              <li class="nav-item active" id="navUIItem">
+                <button class="nav-link active" id="navUI" data-bs-toggle="pill" data-bs-target="#demo" type="button">Demo UI</button>
+              </li>
+              <li class="nav-item" id="navRestItem">
+                <button class="nav-link" id="navRest" data-bs-toggle="pill" data-bs-target="#rest" type="button">Guide</button>
+              </li>
+              <li class="nav-item" id="navOpenApiItem">
+                <button class="nav-link" id="navOpenApi" data-bs-toggle="pill" data-bs-target="#openapi" type="button">REST API</button>
+              </li>
+            </ul>
+          </div>
+        </nav>
+      </div>`));
+    }
+
+    const timefoldFooter = $("footer#timefold-auto-footer");
+    if (timefoldFooter != null) {
+        timefoldFooter.append($(`<footer class="bg-black text-white-50">
+               <div class="container">
+                 <div class="hstack gap-3 p-4">
+                   <div class="ms-auto"><a class="text-white" href="https://timefold.ai">Timefold</a></div>
+                   <div class="vr"></div>
+                   <div><a class="text-white" href="https://timefold.ai/docs">Documentation</a></div>
+                   <div class="vr"></div>
+                   <div><a class="text-white" href="https://github.com/TimefoldAI/timefold-quickstarts">Code</a></div>
+                   <div class="vr"></div>
+                   <div class="me-auto"><a class="text-white" href="https://timefold.ai/product/support/">Support</a></div>
+                 </div>
+               </div>
+             </footer>`));
+    }
+}

src/main/resources/META-INF/resources/index.html

@@ -0,0 +1,162 @@
+<html lang="en">
+<head>
+    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
+    <meta content="width=device-width, initial-scale=1" name="viewport">
+    <title>Flight Crew Scheduling - Timefold Solver on Quarkus</title>
+    <link rel="stylesheet" href="/webjars/bootstrap/css/bootstrap.min.css"/>
+    <link rel="stylesheet" href="/webjars/font-awesome/css/all.css"/>
+    <link rel="stylesheet" href="/webjars/timefold/css/timefold-webui.css"/>
+    <link rel="icon" href="/webjars/timefold/img/timefold-favicon.svg" type="image/svg+xml">
+    <style>
+        .vis-time-axis .vis-grid.vis-saturday,
+        .vis-time-axis .vis-grid.vis-sunday {
+            background: #D3D7CFFF;
+        }
+
+        .vis-item-content {
+            width: 100%;
+        }
+    </style>
+</head>
+<body>
+<header id="timefold-auto-header">
+    <!-- Filled in by app.js -->
+</header>
+<div class="tab-content">
+    <div id="demo" class="tab-pane fade show active container">
+        <div class="sticky-top d-flex justify-content-center align-items-center" aria-live="polite" aria-atomic="true">
+            <div id="notificationPanel" style="position: absolute; top: .5rem;"></div>
+        </div>
+        <h1>Flight Crew Scheduling Solver</h1>
+        <p>Generate the optimal schedule for your flight crew scheduling.</p>
+
+        <div class="mb-2">
+            <button id="solveButton" type="button" class="btn btn-success">
+                <span class="fas fa-play"></span> Solve
+            </button>
+            <button id="stopSolvingButton" type="button" class="btn btn-danger">
+                <span class="fas fa-stop"></span> Stop solving
+            </button>
+            <span id="score" class="score ms-2 align-middle fw-bold">Score: ?</span>
+            <button id="analyzeButton" type="button" class="ms-2 btn btn-secondary">
+                <span class="fas fa-question"></span>
+            </button>
+
+            <div class="float-end">
+                <ul class="nav nav-pills" role="tablist">
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link active" id="byCrewTab" data-bs-toggle="tab"
+                                data-bs-target="#byCrewPanel" type="button" role="tab" aria-controls="byCrewPanel"
+                                aria-selected="true">By crew
+                        </button>
+                    </li>
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link" id="byFlightTab" data-bs-toggle="tab"
+                                data-bs-target="#byFlightPanel" type="button" role="tab" aria-controls="byFlightPanel"
+                                aria-selected="true">By Flight
+                        </button>
+                    </li>
+                </ul>
+            </div>
+        </div>
+        <div class="tab-content">
+            <div class="tab-pane fade show active" id="byCrewPanel" role="tabpanel" aria-labelledby="byCrewTab">
+                <div id="crewVisualization"></div>
+            </div>
+            <div class="tab-pane fade" id="byFlightPanel" role="tabpanel" aria-labelledby="byFlightTab">
+                <div id="flightVisualization"></div>
+            </div>
+        </div>
+
+        <h2>Unassigned</h2>
+        <div id="unassignedCrew" class="row row-cols-4 g-3 mb-4"></div>
+    </div>
+
+    <div id="rest" class="tab-pane fade  container-fluid">
+        <h1>REST API Guide</h1>
+
+        <h2>Flight Crew Scheduling solver integration via cURL</h2>
+
+        <h3>1. Download demo data</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl1')">Copy</button>
+            <code id="curl1">curl -X GET -H 'Accept:application/json' http://localhost:8080/demo-data -o sample.json</code>
+    </pre>
+
+        <h3>2. Post the sample data for solving</h3>
+        <p>The POST operation returns a <code>jobId</code> that should be used in subsequent commands.</p>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl2')">Copy</button>
+            <code id="curl2">curl -X POST -H 'Content-Type:application/json' http://localhost:8080/schedules -d@sample.json</code>
+    </pre>
+
+        <h3>3. Get the current status and score</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl3')">Copy</button>
+            <code id="curl3">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}/status</code>
+    </pre>
+
+        <h3>4. Get the complete solution</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl4')">Copy</button>
+            <code id="curl4">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId} -o solution.json</code>
+    </pre>
+
+        <h3>5. Fetch the analysis of the solution</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl5')">Copy</button>
+            <code id="curl5">curl -X PUT -H 'Content-Type:application/json' http://localhost:8080/schedules/analyze -d@solution.json</code>
+    </pre>
+
+        <h3>6. Terminate solving early</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl6')">Copy</button>
+            <code id="curl6">curl -X DELETE -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}</code>
+    </pre>
+    </div>
+
+    <div id="openapi" class="tab-pane fade container-fluid">
+        <h1>REST API Reference</h1>
+        <div class="ratio ratio-1x1">
+            <!-- "scrolling" attribute is obsolete, but e.g. Chrome does not support "overflow:hidden" -->
+            <iframe src="/q/swagger-ui" style="overflow:hidden;" scrolling="no"></iframe>
+        </div>
+    </div>
+</div>
+<footer id="timefold-auto-footer"></footer>
+<div class="modal fadebd-example-modal-lg" id="scoreAnalysisModal" tabindex="-1"
+     aria-labelledby="scoreAnalysisModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-lg modal-dialog-scrollable">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h1 class="modal-title fs-5" id="scoreAnalysisModalLabel">Score analysis <span
+                        id="scoreAnalysisScoreLabel"></span></h1>
+
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body" id="scoreAnalysisModalContent">
+                <!-- Filled in by app.js -->
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">Close</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="/webjars/bootstrap/js/bootstrap.bundle.min.js"></script>
+<script src="/webjars/jquery/jquery.min.js"></script>
+<script src="/webjars/js-joda/dist/js-joda.min.js"></script>
+<script src="/webjars/js-joda__locale_en-us/dist/index.js"></script>
+<script src="/webjars/timefold/js/timefold-webui.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/vis-timeline@7.7.2/standalone/umd/vis-timeline-graph2d.min.js"
+        integrity="sha256-Jy2+UO7rZ2Dgik50z3XrrNpnc5+2PAx9MhL2CicodME=" crossorigin="anonymous"></script>
+<script src="/app.js"></script>
+</body>
+</html>

src/main/resources/application.properties

@@ -0,0 +1,53 @@
+########################
+# Timefold Solver properties
+########################
+
+# The solver runs for 30 seconds. To run for 5 minutes use "5m" and for 2 hours use "2h".
+quarkus.timefold.solver.termination.spent-limit=30s
+
+# To change how many solvers to run in parallel
+# timefold.solver-manager.parallel-solver-count=4
+
+# Temporary comment this out to detect bugs in your code (lowers performance)
+# quarkus.timefold.solver.environment-mode=FULL_ASSERT
+
+# Temporary comment this out to return a feasible solution as soon as possible
+# quarkus.timefold.solver.termination.best-score-limit=0hard/*soft
+
+# To see what Timefold is doing, turn on DEBUG or TRACE logging.
+quarkus.log.category."ai.timefold.solver".level=INFO
+%test.quarkus.log.category."ai.timefold.solver".level=INFO
+%prod.quarkus.log.category."ai.timefold.solver".level=INFO
+
+# XML file for power tweaking, defaults to solverConfig.xml (directly under src/main/resources)
+# quarkus.timefold.solver-config-xml=org/.../flightCrewSchedulingSolverConfig.xml
+
+########################
+# Timefold Solver Enterprise properties
+########################
+
+# To run increase CPU cores usage per solver
+%enterprise.quarkus.timefold.solver.move-thread-count=AUTO
+
+########################
+# Native build properties
+########################
+
+# Enable Swagger UI also in the native mode
+quarkus.swagger-ui.always-include=true
+
+########################
+# Production/HuggingFace properties
+########################
+
+# Allow all hosts (required for HuggingFace Spaces)
+quarkus.http.cors=true
+quarkus.http.cors.origins=/.*/
+
+########################
+# Test overrides
+########################
+
+# Effectively disable spent-time termination in favor of the best-score-limit
+%test.quarkus.timefold.solver.termination.spent-limit=1h
+%test.quarkus.timefold.solver.termination.best-score-limit=0hard/*soft

src/test/java/org/acme/flighcrewscheduling/rest/FlightCrewSchedulingEnvironmentTest.java

@@ -0,0 +1,59 @@
+package org.acme.flighcrewscheduling.rest;
+
+import static io.restassured.RestAssured.given;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+
+import jakarta.inject.Inject;
+
+import ai.timefold.solver.core.api.solver.Solver;
+import ai.timefold.solver.core.api.solver.SolverFactory;
+import ai.timefold.solver.core.config.solver.EnvironmentMode;
+import ai.timefold.solver.core.config.solver.SolverConfig;
+
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+
+import io.quarkus.test.junit.QuarkusTest;
+
+@QuarkusTest
+@EnabledIfSystemProperty(named = "slowly", matches = "true")
+class FlightCrewSchedulingEnvironmentTest {
+
+    @Inject
+    SolverConfig solverConfig;
+
+    @Test
+    void solveFullAssert() {
+        solve(EnvironmentMode.FULL_ASSERT);
+    }
+
+    @Test
+    void solveStepAssert() {
+        solve(EnvironmentMode.STEP_ASSERT);
+    }
+
+    void solve(EnvironmentMode environmentMode) {
+        // Load the problem
+        FlightCrewSchedule problem = given()
+                .when().get("/demo-data")
+                .then()
+                .statusCode(200)
+                .extract()
+                .as(FlightCrewSchedule.class);
+
+        // Update the environment
+        SolverConfig updatedConfig = solverConfig.copyConfig();
+        updatedConfig.withEnvironmentMode(environmentMode)
+                .withTerminationSpentLimit(Duration.ofSeconds(30))
+                .getTerminationConfig().withBestScoreLimit(null);
+        SolverFactory<FlightCrewSchedule> solverFactory = SolverFactory.create(updatedConfig);
+
+        // Solve the problem
+        Solver<FlightCrewSchedule> solver = solverFactory.buildSolver();
+        FlightCrewSchedule solution = solver.solve(problem);
+        assertThat(solution.getScore()).isNotNull();
+    }
+}

src/test/java/org/acme/flighcrewscheduling/rest/FlightCrewSchedulingResourceIT.java

@@ -0,0 +1,50 @@
+package org.acme.flighcrewscheduling.rest;
+
+import static io.restassured.RestAssured.get;
+import static io.restassured.RestAssured.given;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import java.time.Duration;
+
+import ai.timefold.solver.core.api.solver.SolverStatus;
+
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.test.junit.QuarkusIntegrationTest;
+import io.restassured.http.ContentType;
+
+@QuarkusIntegrationTest
+class FlightCrewSchedulingResourceIT {
+
+    @Test
+    void solveNative() {
+        FlightCrewSchedule schedule = given()
+                .when().get("/demo-data")
+                .then()
+                .statusCode(200)
+                .extract()
+                .as(FlightCrewSchedule.class);
+
+        String jobId = given()
+                .contentType(ContentType.JSON)
+                .body(schedule)
+                .expect().contentType(ContentType.TEXT)
+                .when().post("/schedules")
+                .then()
+                .statusCode(200)
+                .extract()
+                .asString();
+
+        await()
+                .atMost(Duration.ofMinutes(1))
+                .pollInterval(Duration.ofMillis(500L))
+                .until(() -> SolverStatus.NOT_SOLVING.name().equals(
+                        get("/schedules/" + jobId + "/status")
+                                .jsonPath().get("solverStatus")));
+
+        FlightCrewSchedule solution = get("/schedules/" + jobId).then().extract().as(FlightCrewSchedule.class);
+        assertThat(solution).isNotNull();
+    }
+}

src/test/java/org/acme/flighcrewscheduling/rest/FlightCrewSchedulingResourceTest.java

@@ -0,0 +1,108 @@
+package org.acme.flighcrewscheduling.rest;
+
+import static io.restassured.RestAssured.get;
+import static io.restassured.RestAssured.given;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import java.time.Duration;
+
+import ai.timefold.solver.core.api.solver.SolverStatus;
+
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+
+@QuarkusTest
+class FlightCrewSchedulingResourceTest {
+
+    @Test
+    void solveDemoDataUntilFeasible() {
+        FlightCrewSchedule schedule = given()
+                .when().get("/demo-data")
+                .then()
+                .statusCode(200)
+                .extract()
+                .as(FlightCrewSchedule.class);
+
+        String jobId = given()
+                .contentType(ContentType.JSON)
+                .body(schedule)
+                .expect().contentType(ContentType.TEXT)
+                .when().post("/schedules")
+                .then()
+                .statusCode(200)
+                .extract()
+                .asString();
+
+        await()
+                .atMost(Duration.ofMinutes(1))
+                .pollInterval(Duration.ofMillis(500L))
+                .until(() -> SolverStatus.NOT_SOLVING.name().equals(
+                        get("/schedules/" + jobId + "/status")
+                                .jsonPath().get("solverStatus")));
+
+        FlightCrewSchedule solution = get("/schedules/" + jobId).then().extract().as(FlightCrewSchedule.class);
+        assertThat(solution.getSolverStatus()).isEqualTo(SolverStatus.NOT_SOLVING);
+        assertThat(solution.getFlightAssignments().stream()
+                .allMatch(assignment -> assignment.getEmployee() != null)).isTrue();
+        assertThat(solution.getScore().isFeasible()).isTrue();
+    }
+
+    @Test
+    void analyze() {
+        FlightCrewSchedule schedule = given()
+                .when().get("/demo-data")
+                .then()
+                .statusCode(200)
+                .extract()
+                .as(FlightCrewSchedule.class);
+
+        String jobId = given()
+                .contentType(ContentType.JSON)
+                .body(schedule)
+                .expect().contentType(ContentType.TEXT)
+                .when().post("/schedules")
+                .then()
+                .statusCode(200)
+                .extract()
+                .asString();
+
+        await()
+                .atMost(Duration.ofMinutes(1))
+                .pollInterval(Duration.ofMillis(500L))
+                .until(() -> SolverStatus.NOT_SOLVING.name().equals(
+                        get("/schedules/" + jobId + "/status")
+                                .jsonPath().get("solverStatus")));
+
+        FlightCrewSchedule solution = get("/schedules/" + jobId).then().extract().as(FlightCrewSchedule.class);
+
+        String analysis = given()
+                .contentType(ContentType.JSON)
+                .body(solution)
+                .expect().contentType(ContentType.JSON)
+                .when()
+                .put("/schedules/analyze")
+                .then()
+                .extract()
+                .asString();
+        // There are too many constraints to validate
+        assertThat(analysis).isNotNull();
+
+        String analysis2 = given()
+                .contentType(ContentType.JSON)
+                .queryParam("fetchPolicy", "FETCH_SHALLOW")
+                .body(solution)
+                .expect().contentType(ContentType.JSON)
+                .when()
+                .put("/schedules/analyze")
+                .then()
+                .extract()
+                .asString();
+        // There are too many constraints to validate
+        assertThat(analysis2).isNotNull();
+    }
+
+}

src/test/java/org/acme/flighcrewscheduling/solver/FlightCrewSchedulingConstraintProviderTest.java

@@ -0,0 +1,1026 @@
+package org.acme.flighcrewscheduling.solver;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import jakarta.inject.Inject;
+
+import ai.timefold.solver.test.api.score.stream.ConstraintVerifier;
+
+import org.acme.flighcrewscheduling.domain.Airport;
+import org.acme.flighcrewscheduling.domain.Employee;
+import org.acme.flighcrewscheduling.domain.Flight;
+import org.acme.flighcrewscheduling.domain.FlightAssignment;
+import org.acme.flighcrewscheduling.domain.FlightCrewSchedule;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.test.junit.QuarkusTest;
+
+@QuarkusTest
+class FlightCrewSchedulingConstraintProviderTest {
+
+    private final ConstraintVerifier<FlightCrewSchedulingConstraintProvider, FlightCrewSchedule> constraintVerifier;
+
+    @Inject
+    public FlightCrewSchedulingConstraintProviderTest(
+            ConstraintVerifier<FlightCrewSchedulingConstraintProvider, FlightCrewSchedule> constraintVerifier) {
+        this.constraintVerifier = constraintVerifier;
+    }
+
+    @Test
+    void requiredSkill() {
+        FlightAssignment assignment = new FlightAssignment("1", null, 0, "1");
+        Employee employee = new Employee("1");
+        employee.setSkills(List.of("2"));
+        assignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::requiredSkill)
+                .given(assignment)
+                .penalizesBy(1); // missing requiredSkill
+    }
+
+    @Test
+    void flightConflict() {
+        Employee employee = new Employee("1");
+
+        Flight flight = new Flight("1", null, LocalDateTime.now(), null, LocalDateTime.now().plusMinutes(10));
+        FlightAssignment assignment = new FlightAssignment("1", flight);
+        assignment.setEmployee(employee);
+
+        Flight overlappingFlight =
+                new Flight("1", null, LocalDateTime.now().plusMinutes(1), null, LocalDateTime.now().plusMinutes(11));
+        FlightAssignment overlappingAssignment = new FlightAssignment("2", overlappingFlight);
+        overlappingAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::flightConflict)
+                .given(assignment, overlappingAssignment)
+                .penalizesBy(1); // one overlapping thirdFlight
+    }
+
+    @Test
+    void transferBetweenTwoFlights() {
+        Employee employee = new Employee("1");
+
+        Airport firstAirport = new Airport("1");
+        Airport secondAirport = new Airport("2");
+
+        Flight firstFlight =
+                new Flight("1", firstAirport, LocalDateTime.now(), secondAirport, LocalDateTime.now().plusMinutes(10));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        Flight firstInvalidFlight =
+                new Flight("2", firstAirport, LocalDateTime.now().plusMinutes(11), secondAirport,
+                        LocalDateTime.now().plusMinutes(12));
+        FlightAssignment firstInvalidAssignment = new FlightAssignment("2", firstInvalidFlight);
+        firstInvalidAssignment.setEmployee(employee);
+
+        Flight secondInvalidFlight =
+                new Flight("3", firstAirport, LocalDateTime.now().plusMinutes(13), secondAirport,
+                        LocalDateTime.now().plusMinutes(14));
+        FlightAssignment secondInvalidAssignment = new FlightAssignment("3", secondInvalidFlight);
+        secondInvalidAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::transferBetweenTwoFlights)
+                .given(firstAssignment, firstInvalidAssignment, secondInvalidAssignment)
+                .penalizesBy(2); // two invalid connections
+    }
+
+    @Test
+    void employeeUnavailability() {
+        var date = LocalDate.now();
+        var employee = new Employee("1");
+        employee.setUnavailableDays(List.of(date));
+
+        var flight =
+                new Flight("1", null, date.atStartOfDay(), null, date.atStartOfDay().plusMinutes(10));
+        var assignment = new FlightAssignment("1", flight);
+        assignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::employeeUnavailability)
+                .given(assignment)
+                .penalizesBy(1); // unavailable at departure
+
+        flight.setDepartureUTCDateTime(date.minusDays(1).atStartOfDay());
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::employeeUnavailability)
+                .given(assignment)
+                .penalizesBy(1); // unavailable during flight
+
+        flight.setDepartureUTCDateTime(date.plusDays(1).atStartOfDay());
+        flight.setArrivalUTCDateTime(date.plusDays(1).atStartOfDay().plusMinutes(10));
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::employeeUnavailability)
+                .given(assignment)
+                .penalizesBy(0); // employee available
+    }
+
+    @Test
+    void firstAssignmentNotDepartingFromHome() {
+        Employee employee = new Employee("1");
+        employee.setHomeAirport(new Airport("1"));
+        employee.setUnavailableDays(List.of(LocalDate.now()));
+
+        Flight flight =
+                new Flight("1", new Airport("2"), LocalDateTime.now(), new Airport("3"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment assignment = new FlightAssignment("1", flight);
+        assignment.setEmployee(employee);
+
+        Flight secondFlight =
+                new Flight("2", new Airport("2"), LocalDateTime.now().plusMinutes(1), new Airport("3"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        Flight thirdFlight =
+                new Flight("3", new Airport("2"), LocalDateTime.now().plusMinutes(1), new Airport("3"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        Employee secondEmployee = new Employee("2");
+        secondEmployee.setHomeAirport(new Airport("3"));
+        secondEmployee.setUnavailableDays(List.of(LocalDate.now()));
+
+        Flight fourthFlight =
+                new Flight("4", new Airport("3"), LocalDateTime.now(), new Airport("4"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment fourthAssignment = new FlightAssignment("4", fourthFlight);
+        fourthAssignment.setEmployee(secondEmployee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::firstAssignmentNotDepartingFromHome)
+                .given(employee, secondEmployee, assignment, secondAssignment, thirdAssignment, fourthAssignment)
+                .penalizesBy(1); // invalid first airport
+    }
+
+    @Test
+    void lastAssignmentNotArrivingAtHome() {
+        Employee employee = new Employee("1");
+        employee.setHomeAirport(new Airport("1"));
+        employee.setUnavailableDays(List.of(LocalDate.now()));
+
+        Flight firstFlight =
+                new Flight("1", new Airport("2"), LocalDateTime.now(), new Airport("3"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        Flight secondFlight =
+                new Flight("2", new Airport("3"), LocalDateTime.now().plusMinutes(11), new Airport("4"),
+                        LocalDateTime.now().plusMinutes(12));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        Employee secondEmployee = new Employee("2");
+        secondEmployee.setHomeAirport(new Airport("2"));
+        secondEmployee.setUnavailableDays(List.of(LocalDate.now()));
+
+        Flight thirdFlight =
+                new Flight("3", new Airport("2"), LocalDateTime.now(), new Airport("3"),
+                        LocalDateTime.now().plusMinutes(10));
+        FlightAssignment thirdFlightAssignment = new FlightAssignment("3", thirdFlight);
+        thirdFlightAssignment.setEmployee(secondEmployee);
+
+        Flight fourthFlight =
+                new Flight("4", new Airport("3"), LocalDateTime.now().plusMinutes(11), new Airport("2"),
+                        LocalDateTime.now().plusMinutes(12));
+        FlightAssignment fourthFlightAssignment = new FlightAssignment("4", fourthFlight);
+        fourthFlightAssignment.setEmployee(secondEmployee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::lastAssignmentNotArrivingAtHome)
+                .given(employee, secondEmployee, firstAssignment, secondAssignment, thirdFlightAssignment,
+                        fourthFlightAssignment)
+                .penalizesBy(1); // invalid last airport
+    }
+
+    @Test
+    void minimumRestAtHomeBase_satisfied() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 8 hours duration, FDP = 8h + 65min = ~8.08h
+        // Required rest at home base = max(8.08, 12) = 12 hours
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                new Airport("JFK"), now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight departs from home base 13 hours after first flight duty end
+        // Duty end of first = arrival + 20 min = now + 8h + 20min
+        // Second flight duty start = departure - 45 min
+        // Gap = 13 hours (satisfies 12 hour minimum)
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(13).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(1));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAtHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(0); // 13 hours rest satisfies 12 hour minimum
+    }
+
+    @Test
+    void minimumRestAtHomeBase_violated() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 8 hours duration
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                new Airport("JFK"), now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight departs from home base only 10 hours after first flight duty end
+        // Violates 12 hour minimum by 2 hours = 120 minutes
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(10).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(1));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAtHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(120); // 2 hours = 120 minutes violation
+    }
+
+    @Test
+    void minimumRestAtHomeBase_notApplicableAwayFromHome() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                new Airport("JFK"), now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight does NOT depart from home base - constraint should not apply
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(5).plusMinutes(45);
+        Flight secondFlight = new Flight("2", new Airport("JFK"), secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(1));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAtHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(0); // constraint doesn't apply when not at home base
+    }
+
+    @Test
+    void minimumRestAwayFromHomeBase_satisfied() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        Airport jfk = new Airport("JFK");
+        Airport atl = new Airport("ATL");
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight ends at JFK
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                jfk, now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight departs from ATL (away from home)
+        // Required rest = max(8.08, 10) = 10 hours (no taxi time adjustment for test simplicity)
+        // Provide 11 hours rest
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(11).plusMinutes(45);
+        Flight secondFlight = new Flight("2", atl, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(2));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAwayFromHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(0); // 11 hours satisfies 10 hour minimum
+    }
+
+    @Test
+    void minimumRestAwayFromHomeBase_violated() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        Airport jfk = new Airport("JFK");
+        Airport atl = new Airport("ATL");
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                jfk, now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight away from home with only 8 hours rest
+        // Violates 10 hour minimum by 2 hours = 120 minutes
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(8).plusMinutes(45);
+        Flight secondFlight = new Flight("2", atl, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(2));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAwayFromHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(120); // 2 hours = 120 minutes violation
+    }
+
+    @Test
+    void minimumRestAwayFromHomeBase_withTravelTimeAdjustment() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        Airport jfk = new Airport("JFK");
+        jfk.setTaxiTimeInMinutes(java.util.Map.of("ATL", 180L)); // 3 hours taxi time
+
+        Airport atl = new Airport("ATL");
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flight firstFlight = new Flight("1", new Airport("LHR"), now,
+                jfk, now.plusHours(8));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Taxi time = 180 minutes, excess = 180 - 30 = 150 minutes
+        // Travel adjustment = 150 * 2 / 60 = 5 hours
+        // Required rest = max(8.08, 10) + 5 = 15 hours
+        // Provide only 12 hours rest - violates by 3 hours = 180 minutes
+        LocalDateTime secondDeparture = now.plusHours(8).plusMinutes(20).plusHours(12).plusMinutes(45);
+        Flight secondFlight = new Flight("2", atl, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(2));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAwayFromHomeBase)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(180); // 3 hours violation due to travel time adjustment
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_satisfied_frequentLongRests() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+
+        // Pattern: Work 3 days, 40h rest, repeat (well within compliance)
+        List<Object> given = new ArrayList<>();
+        given.add(employee);
+
+        LocalDateTime currentTime = start;
+        for (int cycle = 0; cycle < 3; cycle++) {
+            // 3 assignments with short rests
+            for (int i = 0; i < 3; i++) {
+                Flight flight = new Flight("C" + cycle + "F" + i, homeAirport, currentTime,
+                        new Airport("JFK"), currentTime.plusHours(8));
+                FlightAssignment assignment = new FlightAssignment("C" + cycle + "A" + i, flight);
+                assignment.setEmployee(employee);
+                given.add(assignment);
+
+                // 15 hour rest between assignments
+                currentTime = currentTime.plusHours(8).plusMinutes(20).plusHours(15).plusMinutes(45);
+            }
+            // Long rest (40 hours) after every 3 assignments
+            currentTime = currentTime.minusMinutes(45).plusHours(40).plusMinutes(45);
+        }
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(given.toArray())
+                .penalizesBy(0);
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_violated_continuousShortRests() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+
+        // Create 10 assignments over 10 days with only 15-hour rests (< 36h)
+        // This spans ~230 hours without a qualifying rest - should violate
+        List<Object> given = new ArrayList<>();
+        given.add(employee);
+
+        LocalDateTime currentTime = start;
+        for (int i = 0; i < 10; i++) {
+            Flight flight = new Flight("F" + i, homeAirport, currentTime,
+                    new Airport("JFK"), currentTime.plusHours(8));
+            FlightAssignment assignment = new FlightAssignment("A" + i, flight);
+            assignment.setEmployee(employee);
+            given.add(assignment);
+
+            // 15 hour rest (duty end to next duty start)
+            // Duty end = arrival + 20min = currentTime + 8h 20min
+            // Next duty start = duty end + 15h
+            // Next departure = duty start + 45min
+            currentTime = currentTime.plusHours(23).plusMinutes(20);
+        }
+
+        // Expected violations: multiple windows will exceed 168h without 36h rest
+        // With 10 assignments over ~230 hours with no 36h rest, there are 2 violations
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(given.toArray())
+                .penalizesBy(2);
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_satisfied_sparseSchedule() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+
+        // Two assignments 10 days apart with long rest
+        Flight flight1 = new Flight("F1", homeAirport, start,
+                new Airport("JFK"), start.plusHours(8));
+        FlightAssignment a1 = new FlightAssignment("A1", flight1);
+        a1.setEmployee(employee);
+
+        // 230 hour (9.5 day) rest period - well over 36h
+        LocalDateTime secondDeparture = start.plusHours(8).plusMinutes(20)
+                .plusHours(230).plusMinutes(45);
+        Flight flight2 = new Flight("F2", homeAirport, secondDeparture,
+                new Airport("JFK"), secondDeparture.plusHours(8));
+        FlightAssignment a2 = new FlightAssignment("A2", flight2);
+        a2.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(employee, a1, a2)
+                .penalizesBy(0);
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_edgeCase_singleAssignment() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+        Flight flight = new Flight("F1", homeAirport, start,
+                new Airport("JFK"), start.plusHours(8));
+        FlightAssignment assignment = new FlightAssignment("A1", flight);
+        assignment.setEmployee(employee);
+
+        // Single assignment - no violation possible
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(employee, assignment)
+                .penalizesBy(0);
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_satisfied_weeklyPattern() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+
+        // Realistic pattern: Work Mon-Fri with 15h rests, then 48h weekend rest
+        List<Object> given = new ArrayList<>();
+        given.add(employee);
+
+        LocalDateTime currentTime = start;
+
+        // Week 1: Mon-Fri
+        for (int i = 0; i < 5; i++) {
+            Flight flight = new Flight("W1F" + i, homeAirport, currentTime,
+                    new Airport("JFK"), currentTime.plusHours(8));
+            FlightAssignment assignment = new FlightAssignment("W1A" + i, flight);
+            assignment.setEmployee(employee);
+            given.add(assignment);
+            currentTime = currentTime.plusHours(23).plusMinutes(20); // 15h rest
+        }
+
+        // Weekend rest: 48 hours
+        currentTime = currentTime.minusMinutes(45).plusHours(48).plusMinutes(45);
+
+        // Week 2: Mon-Fri
+        for (int i = 0; i < 5; i++) {
+            Flight flight = new Flight("W2F" + i, homeAirport, currentTime,
+                    new Airport("JFK"), currentTime.plusHours(8));
+            FlightAssignment assignment = new FlightAssignment("W2A" + i, flight);
+            assignment.setEmployee(employee);
+            given.add(assignment);
+            currentTime = currentTime.plusHours(23).plusMinutes(20);
+        }
+
+        // Should satisfy - 48h rest every week
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(given.toArray())
+                .penalizesBy(0);
+    }
+
+    @Test
+    void extendedRecoveryRestPeriod_multipleEmployees_isolated() {
+        // Employee 1: Violates ERRP
+        Employee employee1 = new Employee("1");
+        employee1.setHomeAirport(new Airport("LHR"));
+
+        // Employee 2: Satisfies ERRP
+        Employee employee2 = new Employee("2");
+        employee2.setHomeAirport(new Airport("LHR"));
+
+        LocalDateTime start = LocalDateTime.of(2025, 1, 1, 8, 0);
+        List<Object> given = new ArrayList<>();
+        given.add(employee1);
+        given.add(employee2);
+
+        // Employee 1: Continuous short rests (violation)
+        LocalDateTime time1 = start;
+        for (int i = 0; i < 10; i++) {
+            Flight flight = new Flight("E1F" + i, new Airport("LHR"), time1,
+                    new Airport("JFK"), time1.plusHours(8));
+            FlightAssignment assignment = new FlightAssignment("E1A" + i, flight);
+            assignment.setEmployee(employee1);
+            given.add(assignment);
+            time1 = time1.plusHours(23).plusMinutes(20);
+        }
+
+        // Employee 2: Long rests (no violation)
+        LocalDateTime time2 = start;
+        for (int i = 0; i < 3; i++) {
+            Flight flight = new Flight("E2F" + i, new Airport("LHR"), time2,
+                    new Airport("JFK"), time2.plusHours(8));
+            FlightAssignment assignment = new FlightAssignment("E2A" + i, flight);
+            assignment.setEmployee(employee2);
+            given.add(assignment);
+            time2 = time2.plusHours(8).plusMinutes(20).plusHours(50).plusMinutes(45);
+        }
+
+        // Should only penalize employee1's violations (2 violations for employee1)
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::extendedRecoveryRestPeriod)
+                .given(given.toArray())
+                .penalizesBy(2);
+    }
+
+    @Test
+    void transferBetweenTwoFlights_withExcessiveTaxiTime() {
+        Employee employee = new Employee("1");
+
+        Airport lhr = new Airport("LHR");
+        // Set taxi time to same airport as 400 minutes (> 5 hours limit)
+        lhr.setTaxiTimeInMinutes(java.util.Map.of("LHR", 400L));
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flight firstFlight = new Flight("1", lhr, now, lhr, now.plusHours(2));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight also at LHR but taxi time is excessive
+        Flight secondFlight = new Flight("2", lhr, now.plusHours(3), lhr, now.plusHours(5));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::transferBetweenTwoFlights)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(1); // same airport but excessive taxi time
+    }
+
+    @Test
+    void transferBetweenTwoFlights_withAcceptableTaxiTime() {
+        Employee employee = new Employee("1");
+
+        Airport lhr = new Airport("LHR");
+        // Set acceptable taxi time (< 5 hours)
+        lhr.setTaxiTimeInMinutes(java.util.Map.of("LHR", 200L));
+
+        LocalDateTime now = LocalDateTime.now();
+
+        Flight firstFlight = new Flight("1", lhr, now, lhr, now.plusHours(2));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        Flight secondFlight = new Flight("2", lhr, now.plusHours(3), lhr, now.plusHours(5));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::transferBetweenTwoFlights)
+                .given(firstAssignment, secondAssignment)
+                .penalizesBy(0); // acceptable taxi time at same airport
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_satisfied() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: Long haul (9 hours)
+        Flight longHaulFlight = new Flight("1", homeAirport, now,
+                new Airport("JFK"), now.plusHours(9));
+        FlightAssignment longHaulAssignment = new FlightAssignment("1", longHaulFlight);
+        longHaulAssignment.setEmployee(employee);
+
+        // Second flight: 50 hours rest after long haul (exceeds 48h requirement)
+        // Duty end of long haul = arrival + 20 min = now + 9h + 20min
+        // Second duty start = duty end + 50h
+        LocalDateTime secondDeparture = now.plusHours(9).plusMinutes(20)
+                .plusHours(50).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(2));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(longHaulAssignment, secondAssignment)
+                .penalizesBy(0); // 50 hours rest satisfies 48 hour minimum
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_violated() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: Long haul (10 hours)
+        Flight longHaulFlight = new Flight("1", homeAirport, now,
+                new Airport("JFK"), now.plusHours(10));
+        FlightAssignment longHaulAssignment = new FlightAssignment("1", longHaulFlight);
+        longHaulAssignment.setEmployee(employee);
+
+        // Second flight: Only 30 hours rest after long haul
+        // Violates 48 hour minimum by 18 hours = 1080 minutes
+        LocalDateTime secondDeparture = now.plusHours(10).plusMinutes(20)
+                .plusHours(30).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("ATL"), secondDeparture.plusHours(3));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(longHaulAssignment, secondAssignment)
+                .penalizesBy(1080); // 18 hours = 1080 minutes violation
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_notApplicableToShortHaul() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: Short haul (3 hours, below 8h threshold)
+        Flight shortHaulFlight = new Flight("1", homeAirport, now,
+                new Airport("BRU"), now.plusHours(3));
+        FlightAssignment shortHaulAssignment = new FlightAssignment("1", shortHaulFlight);
+        shortHaulAssignment.setEmployee(employee);
+
+        // Second flight: Only 15 hours rest
+        // Constraint should not apply because first flight is not long haul
+        LocalDateTime secondDeparture = now.plusHours(3).plusMinutes(20)
+                .plusHours(15).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("ATL"), secondDeparture.plusHours(8));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(shortHaulAssignment, secondAssignment)
+                .penalizesBy(0); // constraint doesn't apply to short haul flights
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_exactlyTenHours() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: Exactly 10 hours (boundary case - should be long haul)
+        Flight boundaryFlight = new Flight("1", homeAirport, now,
+                new Airport("JFK"), now.plusHours(10));
+        FlightAssignment boundaryAssignment = new FlightAssignment("1", boundaryFlight);
+        boundaryAssignment.setEmployee(employee);
+
+        // Second flight: Only 24 hours rest
+        // Should violate because 10h exactly is considered long haul
+        LocalDateTime secondDeparture = now.plusHours(10).plusMinutes(20)
+                .plusHours(24).plusMinutes(45);
+        Flight secondFlight = new Flight("2", homeAirport, secondDeparture,
+                new Airport("ATL"), secondDeparture.plusHours(3));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(boundaryAssignment, secondAssignment)
+                .penalizesBy(1440); // 24 hours = 1440 minutes violation
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_awayFromHomeBase() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        Airport jfk = new Airport("JFK");
+        Airport atl = new Airport("ATL");
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: Long haul ending at JFK (away from home) - 10 hours
+        Flight longHaulFlight = new Flight("1", homeAirport, now,
+                jfk, now.plusHours(10));
+        FlightAssignment longHaulAssignment = new FlightAssignment("1", longHaulFlight);
+        longHaulAssignment.setEmployee(employee);
+
+        // Second flight: Departing from ATL with only 36 hours rest
+        // Should still violate 48h requirement even away from home
+        LocalDateTime secondDeparture = now.plusHours(10).plusMinutes(20)
+                .plusHours(36).plusMinutes(45);
+        Flight secondFlight = new Flight("2", atl, secondDeparture,
+                new Airport("BRU"), secondDeparture.plusHours(7));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(longHaulAssignment, secondAssignment)
+                .penalizesBy(720); // 12 hours = 720 minutes violation
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_multipleLongHauls() {
+        Employee employee = new Employee("1");
+        Airport homeAirport = new Airport("LHR");
+        employee.setHomeAirport(homeAirport);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First long haul
+        Flight firstLongHaul = new Flight("1", homeAirport, now,
+                new Airport("JFK"), now.plusHours(9));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstLongHaul);
+        firstAssignment.setEmployee(employee);
+
+        // Second long haul after 50h rest (satisfies first constraint)
+        LocalDateTime secondDeparture = now.plusHours(9).plusMinutes(20)
+                .plusHours(50).plusMinutes(45);
+        Flight secondLongHaul = new Flight("2", homeAirport, secondDeparture,
+                new Airport("ATL"), secondDeparture.plusHours(10));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondLongHaul);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight after only 20h rest (violates second constraint)
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(10).plusMinutes(20)
+                .plusHours(20).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", homeAirport, thirdDeparture,
+                new Airport("BRU"), thirdDeparture.plusHours(2));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(1680); // 28 hours violation for second-to-third
+    }
+
+    @Test
+    void minimumRestAfterLongHaul_multipleEmployeesIsolated() {
+        // Employee 1: Violates constraint
+        Employee employee1 = new Employee("1");
+        employee1.setHomeAirport(new Airport("LHR"));
+
+        // Employee 2: Satisfies constraint
+        Employee employee2 = new Employee("2");
+        employee2.setHomeAirport(new Airport("LHR"));
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // Employee 1: Long haul with insufficient rest - changed to 10 hours
+        Flight e1Flight1 = new Flight("F1", new Airport("LHR"), now,
+                new Airport("JFK"), now.plusHours(10));
+        FlightAssignment e1Assignment1 = new FlightAssignment("A1", e1Flight1);
+        e1Assignment1.setEmployee(employee1);
+
+        Flight e1Flight2 = new Flight("F2", new Airport("LHR"),
+                now.plusHours(10).plusMinutes(20).plusHours(30).plusMinutes(45),
+                new Airport("ATL"), now.plusHours(43));
+        FlightAssignment e1Assignment2 = new FlightAssignment("A2", e1Flight2);
+        e1Assignment2.setEmployee(employee1);
+
+        // Employee 2: Long haul with sufficient rest
+        Flight e2Flight1 = new Flight("F3", new Airport("LHR"), now,
+                new Airport("BNE"), now.plusHours(20));
+        FlightAssignment e2Assignment1 = new FlightAssignment("A3", e2Flight1);
+        e2Assignment1.setEmployee(employee2);
+
+        Flight e2Flight2 = new Flight("F4", new Airport("LHR"),
+                now.plusHours(20).plusMinutes(20).plusHours(60).plusMinutes(45),
+                new Airport("JFK"), now.plusHours(88));
+        FlightAssignment e2Assignment2 = new FlightAssignment("A4", e2Flight2);
+        e2Assignment2.setEmployee(employee2);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterLongHaul)
+                .given(employee1, employee2, e1Assignment1, e1Assignment2, e2Assignment1, e2Assignment2)
+                .penalizesBy(1080); // Only employee1's violation (18 hours)
+    }
+
+    @Test
+    void minimumRestAfterConsecutiveLongHaul_satisfied() {
+        Employee employee = new Employee("1");
+        Airport lhr = new Airport("LHR");
+        Airport jfk = new Airport("JFK");
+        Airport lax = new Airport("LAX");
+        employee.setHomeAirport(lhr);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 5 hours (short haul alone)
+        Flight firstFlight = new Flight("1", lhr, now,
+                jfk, now.plusHours(5));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight: 6 hours, consecutive with first (total 11 hours = long haul)
+        // Departs 1 hour after first arrives (within 2 hour window)
+        LocalDateTime secondDeparture = now.plusHours(5).plusHours(1);
+        Flight secondFlight = new Flight("2", jfk, secondDeparture,
+                lax, secondDeparture.plusHours(6));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight: 50 hours rest after the consecutive long haul
+        // Should satisfy 48 hour requirement
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(6).plusMinutes(20)
+                .plusHours(50).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", lhr, thirdDeparture,
+                lax, thirdDeparture.plusHours(3));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterConsecutiveLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(0); // 50 hours rest satisfies 48 hour minimum
+    }
+
+    @Test
+    void minimumRestAfterConsecutiveLongHaul_violated() {
+        Employee employee = new Employee("1");
+        Airport lhr = new Airport("LHR");
+        Airport jfk = new Airport("JFK");
+        Airport lax = new Airport("LAX");
+        employee.setHomeAirport(lhr);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 5 hours
+        Flight firstFlight = new Flight("1", lhr, now,
+                jfk, now.plusHours(5));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight: 6 hours, consecutive (total 11 hours = long haul)
+        LocalDateTime secondDeparture = now.plusHours(5).plusHours(1);
+        Flight secondFlight = new Flight("2", jfk, secondDeparture,
+                lax, secondDeparture.plusHours(6));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight: Only 30 hours rest after consecutive long haul
+        // Violates 48 hour minimum by 18 hours = 1080 minutes
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(6).plusMinutes(20)
+                .plusHours(30).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", lhr, thirdDeparture,
+                lax, thirdDeparture.plusHours(3));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterConsecutiveLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(1080); // 18 hours = 1080 minutes violation
+    }
+
+    @Test
+    void minimumRestAfterConsecutiveLongHaul_notApplicableToNonConsecutive() {
+        Employee employee = new Employee("1");
+        Airport lhr = new Airport("LHR");
+        Airport jfk = new Airport("JFK");
+        Airport atl = new Airport("ATL");
+        employee.setHomeAirport(lhr);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 5 hours
+        Flight firstFlight = new Flight("1", lhr, now,
+                jfk, now.plusHours(5));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight: 6 hours but NOT consecutive (different airport)
+        LocalDateTime secondDeparture = now.plusHours(5).plusHours(1);
+        Flight secondFlight = new Flight("2", atl, secondDeparture, // ATL, not JFK
+                lhr, secondDeparture.plusHours(6));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight: Only 20 hours rest
+        // Should NOT violate because first + second don't form consecutive long haul
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(6).plusMinutes(20)
+                .plusHours(20).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", lhr, thirdDeparture,
+                jfk, thirdDeparture.plusHours(5));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterConsecutiveLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(0); // constraint doesn't apply to non-consecutive flights
+    }
+
+    @Test
+    void minimumRestAfterConsecutiveLongHaul_notApplicableToShortTotal() {
+        Employee employee = new Employee("1");
+        Airport lhr = new Airport("LHR");
+        Airport jfk = new Airport("JFK");
+        Airport lax = new Airport("LAX");
+        employee.setHomeAirport(lhr);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 3 hours
+        Flight firstFlight = new Flight("1", lhr, now,
+                jfk, now.plusHours(3));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight: 4 hours, consecutive (total only 7 hours = NOT long haul)
+        LocalDateTime secondDeparture = now.plusHours(3).plusHours(1);
+        Flight secondFlight = new Flight("2", jfk, secondDeparture,
+                lax, secondDeparture.plusHours(4));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight: Only 20 hours rest
+        // Should NOT violate because combined duration < 10 hours
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(4).plusMinutes(20)
+                .plusHours(20).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", lhr, thirdDeparture,
+                lax, thirdDeparture.plusHours(3));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterConsecutiveLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(0); // constraint doesn't apply when total < 10 hours
+    }
+
+    @Test
+    void minimumRestAfterConsecutiveLongHaul_tooLongGapBetweenFlights() {
+        Employee employee = new Employee("1");
+        Airport lhr = new Airport("LHR");
+        Airport jfk = new Airport("JFK");
+        Airport lax = new Airport("LAX");
+        employee.setHomeAirport(lhr);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // First flight: 5 hours
+        Flight firstFlight = new Flight("1", lhr, now,
+                jfk, now.plusHours(5));
+        FlightAssignment firstAssignment = new FlightAssignment("1", firstFlight);
+        firstAssignment.setEmployee(employee);
+
+        // Second flight: 6 hours but 3 hours after first (> 2 hour limit)
+        // Not considered consecutive despite total being 11 hours
+        LocalDateTime secondDeparture = now.plusHours(5).plusHours(3);
+        Flight secondFlight = new Flight("2", jfk, secondDeparture,
+                lax, secondDeparture.plusHours(6));
+        FlightAssignment secondAssignment = new FlightAssignment("2", secondFlight);
+        secondAssignment.setEmployee(employee);
+
+        // Third flight: Only 20 hours rest
+        // Should NOT violate because gap between flights is too long
+        LocalDateTime thirdDeparture = secondDeparture.plusHours(6).plusMinutes(20)
+                .plusHours(20).plusMinutes(45);
+        Flight thirdFlight = new Flight("3", lhr, thirdDeparture,
+                lax, thirdDeparture.plusHours(3));
+        FlightAssignment thirdAssignment = new FlightAssignment("3", thirdFlight);
+        thirdAssignment.setEmployee(employee);
+
+        constraintVerifier.verifyThat(FlightCrewSchedulingConstraintProvider::minimumRestAfterConsecutiveLongHaul)
+                .given(firstAssignment, secondAssignment, thirdAssignment)
+                .penalizesBy(0); // constraint doesn't apply when gap > 2 hours
+    }
+}