Design Elevator System

// ========== Enums ==========
enum Direction { UP, DOWN, IDLE }
enum ElevatorState { MOVING, STOPPED, IDLE, MAINTENANCE }

// ========== Elevator ==========
class Elevator {
    private int id;
    private int currentFloor;
    private Direction direction;
    private ElevatorState state;
    private TreeSet<Integer> upRequests;    // Floors to visit going up
    private TreeSet<Integer> downRequests;  // Floors to visit going down
    
    public Elevator(int id) {
        this.id = id;
        this.currentFloor = 0;
        this.direction = Direction.IDLE;
        this.state = ElevatorState.IDLE;
        this.upRequests = new TreeSet<>();
        this.downRequests = new TreeSet<>(Collections.reverseOrder());
    }
    
    public void addRequest(int floor) {
        if (floor > currentFloor) {
            upRequests.add(floor);
        } else if (floor < currentFloor) {
            downRequests.add(floor);
        }
        if (state == ElevatorState.IDLE) {
            direction = floor > currentFloor ? Direction.UP : Direction.DOWN;
        }
    }
    
    public void move() {
        if (direction == Direction.UP) {
            if (!upRequests.isEmpty()) {
                int next = upRequests.first();
                moveToFloor(next);
                upRequests.remove(next);
            } else if (!downRequests.isEmpty()) {
                direction = Direction.DOWN;
            } else {
                direction = Direction.IDLE;
                state = ElevatorState.IDLE;
            }
        } else if (direction == Direction.DOWN) {
            if (!downRequests.isEmpty()) {
                int next = downRequests.first();
                moveToFloor(next);
                downRequests.remove(next);
            } else if (!upRequests.isEmpty()) {
                direction = Direction.UP;
            } else {
                direction = Direction.IDLE;
                state = ElevatorState.IDLE;
            }
        }
    }
    
    private void moveToFloor(int floor) {
        state = ElevatorState.MOVING;
        System.out.println("Elevator " + id + ": " + currentFloor + " -> " + floor);
        currentFloor = floor;
        state = ElevatorState.STOPPED;
        openDoor();
    }
    
    private void openDoor() {
        System.out.println("Elevator " + id + ": Door open at floor " + currentFloor);
    }
    
    public int getCurrentFloor() { return currentFloor; }
    public Direction getDirection() { return direction; }
    public boolean isIdle() { return state == ElevatorState.IDLE; }
    
    // Cost for scheduler (lower is better)
    public int getCost(int floor, Direction requestDir) {
        int distance = Math.abs(floor - currentFloor);
        if (direction == Direction.IDLE) return distance;
        if (direction == requestDir) {
            if ((direction == Direction.UP && floor >= currentFloor) ||
                (direction == Direction.DOWN && floor <= currentFloor)) {
                return distance;
            }
        }
        return distance + 10; // Penalty for opposite direction
    }
}

// ========== Scheduler ==========
interface ElevatorScheduler {
    Elevator selectElevator(List<Elevator> elevators, int floor, Direction dir);
}

class LookScheduler implements ElevatorScheduler {
    @Override
    public Elevator selectElevator(List<Elevator> elevators, int floor, Direction dir) {
        return elevators.stream()
            .min(Comparator.comparingInt(e -> e.getCost(floor, dir)))
            .orElse(elevators.get(0));
    }
}

// ========== System ==========
class ElevatorSystem {
    private static ElevatorSystem instance;
    private List<Elevator> elevators;
    private ElevatorScheduler scheduler;
    
    private ElevatorSystem(int numElevators) {
        elevators = new ArrayList<>();
        for (int i = 0; i < numElevators; i++) {
            elevators.add(new Elevator(i));
        }
        scheduler = new LookScheduler();
    }
    
    public static ElevatorSystem getInstance(int n) {
        if (instance == null) instance = new ElevatorSystem(n);
        return instance;
    }
    
    public void requestElevator(int floor, Direction direction) {
        Elevator best = scheduler.selectElevator(elevators, floor, direction);
        best.addRequest(floor);
        System.out.println("Request floor " + floor + " assigned to Elevator " + 
            elevators.indexOf(best));
    }
    
    public void step() {
        for (Elevator e : elevators) {
            e.move();
        }
    }
}