Elevator System Design

// ── Enums ─────────────────────────────────────────────────────
public enum Direction   { UP, DOWN, IDLE }

public enum ElevatorState { MOVING, STOPPED, MAINTENANCE }

public enum RequestType { INTERNAL, EXTERNAL }   // button inside vs hallway

// ── ElevatorRequest ───────────────────────────────────────────
public class ElevatorRequest {
    private final int         floor;
    private final Direction   direction;   // which way the person wants to go
    private final RequestType type;

    public ElevatorRequest(int floor, Direction direction, RequestType type) {
        this.floor     = floor;
        this.direction = direction;
        this.type      = type;
    }

    public int         getFloor()     { return floor; }
    public Direction   getDirection() { return direction; }
    public RequestType getType()      { return type; }

    @Override
    public String toString() {
        return String.format("Request[floor=%d, dir=%s, type=%s]", floor, direction, type);
    }
}

// ── Elevator ──────────────────────────────────────────────────
import java.util.TreeSet;

public class Elevator {
    private final int       id;
    private int             currentFloor;
    private Direction       direction;
    private ElevatorState   state;
    private final int       minFloor;
    private final int       maxFloor;

    // Two sorted sets act as the up-queue and down-queue (SCAN algorithm)
    private final TreeSet<Integer> upQueue   = new TreeSet<>();   // floors to visit going up
    private final TreeSet<Integer> downQueue = new TreeSet<>(java.util.Collections.reverseOrder()); // going down

    public Elevator(int id, int minFloor, int maxFloor) {
        this.id           = id;
        this.currentFloor = minFloor;
        this.direction    = Direction.IDLE;
        this.state        = ElevatorState.STOPPED;
        this.minFloor     = minFloor;
        this.maxFloor     = maxFloor;
    }

    /** Add a stop to this elevator's queue */
    public void addRequest(int floor) {
        if (floor > currentFloor || direction == Direction.UP)
            upQueue.add(floor);
        else
            downQueue.add(floor);
    }

    /**
     * Move one step: open door at current floor if queued,
     * then advance to next floor in the SCAN order.
     */
    public void step() {
        if (state == ElevatorState.MAINTENANCE) return;

        // Serve current floor first
        if (upQueue.contains(currentFloor))   upQueue.remove(currentFloor);
        if (downQueue.contains(currentFloor)) downQueue.remove(currentFloor);

        if (!upQueue.isEmpty() && (direction == Direction.UP || downQueue.isEmpty())) {
            direction    = Direction.UP;
            state        = ElevatorState.MOVING;
            currentFloor = upQueue.first();
            System.out.println("Elevator " + id + " → floor " + currentFloor + " (UP)");
        } else if (!downQueue.isEmpty()) {
            direction    = Direction.DOWN;
            state        = ElevatorState.MOVING;
            currentFloor = downQueue.first();
            System.out.println("Elevator " + id + " → floor " + currentFloor + " (DOWN)");
        } else {
            direction = Direction.IDLE;
            state     = ElevatorState.STOPPED;
        }
    }

    public int           getId()           { return id; }
    public int           getCurrentFloor() { return currentFloor; }
    public Direction     getDirection()    { return direction; }
    public ElevatorState getState()        { return state; }
    public boolean       isIdle()          { return direction == Direction.IDLE; }

    /** Estimated cost to serve a new floor request (used by dispatcher) */
    public int costToServe(int targetFloor) {
        return Math.abs(targetFloor - currentFloor);
    }
}

// ── ElevatorDispatcher (Strategy Pattern) ─────────────────────
public interface DispatchStrategy {
    Elevator selectElevator(List<Elevator> elevators, ElevatorRequest request);
}

// ── Nearest Car (simplest & most common) ──────────────────────
public class NearestCarStrategy implements DispatchStrategy {
    @Override
    public Elevator selectElevator(List<Elevator> elevators, ElevatorRequest request) {
        return elevators.stream()
            .filter(e -> e.getState() != ElevatorState.MAINTENANCE)
            .min(Comparator.comparingInt(e -> e.costToServe(request.getFloor())))
            .orElseThrow(() -> new IllegalStateException("No elevators available"));
    }
}

// ── Zone Strategy (each elevator serves a floor range) ────────
public class ZoneStrategy implements DispatchStrategy {
    private final int zonesPerElevator;

    public ZoneStrategy(int totalFloors, int elevatorCount) {
        this.zonesPerElevator = totalFloors / elevatorCount;
    }

    @Override
    public Elevator selectElevator(List<Elevator> elevators, ElevatorRequest request) {
        int zoneIndex = request.getFloor() / zonesPerElevator;
        zoneIndex = Math.min(zoneIndex, elevators.size() - 1);
        Elevator zoneElevator = elevators.get(zoneIndex);
        if (zoneElevator.getState() == ElevatorState.MAINTENANCE) {
            // fallback to nearest
            return new NearestCarStrategy().selectElevator(elevators, request);
        }
        return zoneElevator;
    }
}

// ── ElevatorSystem (Singleton) ────────────────────────────────
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class ElevatorSystem {
    private static volatile ElevatorSystem instance;
    private final List<Elevator>    elevators;
    private final int               totalFloors;
    private DispatchStrategy        dispatchStrategy;
    private final ReentrantLock     lock = new ReentrantLock();

    private ElevatorSystem(int totalFloors, int elevatorCount) {
        this.totalFloors      = totalFloors;
        this.elevators        = new ArrayList<>();
        this.dispatchStrategy = new NearestCarStrategy();
        for (int i = 0; i < elevatorCount; i++)
            elevators.add(new Elevator(i + 1, 1, totalFloors));
    }

    public static ElevatorSystem getInstance(int floors, int elevators) {
        if (instance == null) {
            synchronized (ElevatorSystem.class) {
                if (instance == null) instance = new ElevatorSystem(floors, elevators);
            }
        }
        return instance;
    }

    public void setDispatchStrategy(DispatchStrategy s) { this.dispatchStrategy = s; }

    /** External call: person presses UP or DOWN on a floor */
    public void requestElevator(int floor, Direction direction) {
        lock.lock();
        try {
            ElevatorRequest req = new ElevatorRequest(floor, direction, RequestType.EXTERNAL);
            Elevator chosen = dispatchStrategy.selectElevator(elevators, req);
            chosen.addRequest(floor);
            System.out.printf("Dispatched Elevator %d for external request at floor %d (%s)%n",
                chosen.getId(), floor, direction);
        } finally { lock.unlock(); }
    }

    /** Internal call: person inside cabin presses a floor button */
    public void selectFloor(int elevatorId, int floor) {
        lock.lock();
        try {
            Elevator elevator = elevators.stream()
                .filter(e -> e.getId() == elevatorId)
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Unknown elevator: " + elevatorId));
            elevator.addRequest(floor);
            System.out.printf("Elevator %d floor button: %d%n", elevatorId, floor);
        } finally { lock.unlock(); }
    }

    /** Advance all elevators one step (called in a simulation loop / scheduler) */
    public void tick() {
        elevators.forEach(Elevator::step);
    }

    public void printStatus() {
        System.out.println("=== Elevator Status ===");
        for (Elevator e : elevators) {
            System.out.printf("  Elevator %d | Floor: %2d | Dir: %-5s | State: %s%n",
                e.getId(), e.getCurrentFloor(), e.getDirection(), e.getState());
        }
    }
}

// ── Demo ───────────────────────────────────────────────────────
public class Main {
    public static void main(String[] args) {
        ElevatorSystem system = ElevatorSystem.getInstance(20, 3);
        system.setDispatchStrategy(new NearestCarStrategy());

        // External requests from hallway buttons
        system.requestElevator(5,  Direction.UP);    // person on floor 5 wants to go up
        system.requestElevator(12, Direction.DOWN);  // person on floor 12 wants to go down
        system.requestElevator(1,  Direction.UP);    // person on floor 1 wants to go up

        // Simulate elevator movement over several ticks
        for (int i = 0; i < 5; i++) {
            system.tick();
            system.printStatus();
            System.out.println();
        }

        // Internal request — person inside Elevator 1 presses floor 8
        system.selectFloor(1, 8);

        for (int i = 0; i < 5; i++) {
            system.tick();
            system.printStatus();
            System.out.println();
        }
    }
}