Elevator System

public enum Direction {
    UP,
    DOWN,
    IDLE;

    public Direction opposite() {
        return switch (this) {
            case UP -> DOWN;
            case DOWN -> UP;
            case IDLE -> IDLE;
        };
    }
}

public enum RequestType {
    PICKUP_UP,
    PICKUP_DOWN,
    DESTINATION;

    public boolean matches(Direction direction) {
        return this == DESTINATION
                || (this == PICKUP_UP && direction == Direction.UP)
                || (this == PICKUP_DOWN && direction == Direction.DOWN);
    }
}

import java.util.Objects;

public final class Request {
    private final int floor;
    private final RequestType type;

    public Request(int floor, RequestType type) {
        this.floor = floor;
        this.type = Objects.requireNonNull(type);
    }

    public int getFloor() {
        return floor;
    }

    public RequestType getType() {
        return type;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Request request)) return false;
        return floor == request.floor && type == request.type;
    }

    @Override
    public int hashCode() {
        return Objects.hash(floor, type);
    }

    @Override
    public String toString() {
        return "Request{floor=" + floor + ", type=" + type + "}";
    }
}

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;

public final class Elevator {
    private final int id;
    private final int minFloor;
    private final int maxFloor;
    private int currentFloor;
    private Direction direction;
    private final Set<Request> requests = new LinkedHashSet<>();

    public Elevator(int id, int minFloor, int maxFloor, int startFloor) {
        if (minFloor > maxFloor) {
            throw new IllegalArgumentException("minFloor must be <= maxFloor");
        }
        if (startFloor < minFloor || startFloor > maxFloor) {
            throw new IllegalArgumentException("startFloor is out of range");
        }
        this.id = id;
        this.minFloor = minFloor;
        this.maxFloor = maxFloor;
        this.currentFloor = startFloor;
        this.direction = Direction.IDLE;
    }

    public boolean addRequest(Request request) {
        if (request == null || !isValidFloor(request.getFloor())) {
            return false;
        }
        if (request.getFloor() == currentFloor) {
            return true; // already served
        }
        return requests.add(request); // false for a duplicate
    }

    public void tick() {
        if (requests.isEmpty()) {
            direction = Direction.IDLE;
            return;
        }

        if (direction == Direction.IDLE) {
            direction = directionToNearestRequest();
        }

        if (serveCurrentFloor()) {
            if (requests.isEmpty()) direction = Direction.IDLE;
            return; // stopping consumes this tick
        }

        if (!hasRequestAhead(direction)) {
            direction = direction.opposite();
            return; // reversing consumes this tick
        }

        currentFloor += direction == Direction.UP ? 1 : -1;
    }

    private boolean serveCurrentFloor() {
        return requests.removeIf(request ->
                request.getFloor() == currentFloor
                        && request.getType().matches(direction));
    }

    private boolean hasRequestAhead(Direction travelDirection) {
        return requests.stream().anyMatch(request ->
                travelDirection == Direction.UP
                        ? request.getFloor() > currentFloor
                        : request.getFloor() < currentFloor);
    }

    private Direction directionToNearestRequest() {
        Request nearest = requests.stream()
                .min((left, right) -> {
                    int leftDistance = Math.abs(left.getFloor() - currentFloor);
                    int rightDistance = Math.abs(right.getFloor() - currentFloor);
                    int byDistance = Integer.compare(leftDistance, rightDistance);
                    return byDistance != 0
                            ? byDistance
                            : Integer.compare(left.getFloor(), right.getFloor());
                })
                .orElseThrow();

        return nearest.getFloor() > currentFloor
                ? Direction.UP
                : Direction.DOWN;
    }

    private boolean isValidFloor(int floor) {
        return floor >= minFloor && floor <= maxFloor;
    }

    public int getId() {
        return id;
    }

    public int getCurrentFloor() {
        return currentFloor;
    }

    public Direction getDirection() {
        return direction;
    }

    public Set<Request> getRequests() {
        return Collections.unmodifiableSet(requests);
    }
}

import java.util.List;

public interface DispatchStrategy {
    Elevator select(List<Elevator> elevators, Request hallCall);
}

import java.util.Comparator;
import java.util.List;

public final class DirectionAwareDispatchStrategy
        implements DispatchStrategy {

    @Override
    public Elevator select(List<Elevator> elevators, Request hallCall) {
        if (elevators == null || elevators.isEmpty()) {
            throw new IllegalArgumentException("At least one elevator is required");
        }
        if (hallCall == null || hallCall.getType() == RequestType.DESTINATION) {
            throw new IllegalArgumentException("A hall call is required");
        }

        Direction requestedDirection = hallCall.getType() == RequestType.PICKUP_UP
                ? Direction.UP
                : Direction.DOWN;

        return elevators.stream()
                .min(Comparator
                        .comparingInt((Elevator elevator) -> priority(
                                elevator, hallCall.getFloor(), requestedDirection))
                        .thenComparingInt(elevator -> Math.abs(
                                elevator.getCurrentFloor() - hallCall.getFloor()))
                        .thenComparingInt(Elevator::getId))
                .orElseThrow();
    }

    private int priority(
            Elevator elevator,
            int requestedFloor,
            Direction requestedDirection) {

        boolean movingTowardCaller =
                elevator.getDirection() == requestedDirection
                        && (requestedDirection == Direction.UP
                            ? elevator.getCurrentFloor() <= requestedFloor
                            : elevator.getCurrentFloor() >= requestedFloor);

        if (movingTowardCaller) return 0;
        if (elevator.getDirection() == Direction.IDLE) return 1;
        return 2;
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

public final class ElevatorController {
    private final int minFloor;
    private final int maxFloor;
    private final List<Elevator> elevators;
    private final DispatchStrategy dispatchStrategy;

    public ElevatorController(
            int elevatorCount,
            int minFloor,
            int maxFloor,
            DispatchStrategy dispatchStrategy) {

        if (elevatorCount <= 0) {
            throw new IllegalArgumentException("elevatorCount must be positive");
        }
        if (minFloor > maxFloor) {
            throw new IllegalArgumentException("minFloor must be <= maxFloor");
        }

        this.minFloor = minFloor;
        this.maxFloor = maxFloor;
        this.dispatchStrategy = Objects.requireNonNull(dispatchStrategy);
        this.elevators = new ArrayList<>();

        for (int id = 1; id <= elevatorCount; id++) {
            elevators.add(new Elevator(id, minFloor, maxFloor, minFloor));
        }
    }

    public boolean requestElevator(int floor, Direction direction) {
        if (!isValidFloor(floor) || direction == null || direction == Direction.IDLE) {
            return false;
        }

        RequestType type = direction == Direction.UP
                ? RequestType.PICKUP_UP
                : RequestType.PICKUP_DOWN;
        Request hallCall = new Request(floor, type);
        Elevator selected = dispatchStrategy.select(elevators, hallCall);
        return selected.addRequest(hallCall);
    }

    public boolean selectDestination(int elevatorId, int floor) {
        Elevator elevator = findElevator(elevatorId);
        if (elevator == null || !isValidFloor(floor)) return false;
        return elevator.addRequest(new Request(floor, RequestType.DESTINATION));
    }

    public void tick() {
        elevators.forEach(Elevator::tick);
    }

    private Elevator findElevator(int elevatorId) {
        return elevators.stream()
                .filter(elevator -> elevator.getId() == elevatorId)
                .findFirst()
                .orElse(null);
    }

    private boolean isValidFloor(int floor) {
        return floor >= minFloor && floor <= maxFloor;
    }

    public List<Elevator> getElevators() {
        return Collections.unmodifiableList(elevators);
    }
}

public final class ElevatorDemo {
    public static void main(String[] args) {
        ElevatorController controller = new ElevatorController(
                3,
                0,
                9,
                new DirectionAwareDispatchStrategy());

        controller.requestElevator(5, Direction.UP);

        for (int tick = 1; tick <= 8; tick++) {
            controller.tick();
            System.out.println("Tick " + tick);
            controller.getElevators().forEach(elevator ->
                    System.out.printf(
                            "Car %d: floor=%d, direction=%s, requests=%s%n",
                            elevator.getId(),
                            elevator.getCurrentFloor(),
                            elevator.getDirection(),
                            elevator.getRequests()));
        }
    }
}