Meeting Room Scheduler

public enum Equipment {
  PROJECTOR,
  WHITEBOARD,
  VIDEO
}

import java.time.LocalDateTime;

public record TimeSlot(LocalDateTime start, LocalDateTime end) {
  public TimeSlot {
      if (start == null || end == null) {
          throw new IllegalArgumentException("Start and end are required");
      }
      if (!start.isBefore(end)) {
          throw new IllegalArgumentException("Start must be before end");
      }
  }

  public boolean overlaps(TimeSlot other) {
      if (other == null) {
          throw new IllegalArgumentException("Other slot is required");
      }
      return start.isBefore(other.end)
              && other.start.isBefore(end);
  }
}

import java.util.Set;

public record MeetingRequest(
      String title,
      String organizerId,
      TimeSlot slot,
      int attendeeCount,
      Set<Equipment> requiredEquipment
) {
  public MeetingRequest {
      if (title == null || title.isBlank()) {
          throw new IllegalArgumentException("Title is required");
      }
      if (organizerId == null || organizerId.isBlank()) {
          throw new IllegalArgumentException("Organizer is required");
      }
      if (slot == null || attendeeCount <= 0 || requiredEquipment == null) {
          throw new IllegalArgumentException("Valid slot, attendees, and equipment are required");
      }
      requiredEquipment = Set.copyOf(requiredEquipment);
  }
}

import java.util.Set;

public record Meeting(
      String id,
      String title,
      String organizerId,
      String roomId,
      TimeSlot slot,
      int attendeeCount,
      Set<Equipment> requiredEquipment
) {
  public Meeting {
      if (id == null || id.isBlank()
              || title == null || title.isBlank()
              || organizerId == null || organizerId.isBlank()
              || roomId == null || roomId.isBlank()) {
          throw new IllegalArgumentException("Meeting identity fields are required");
      }
      if (slot == null || attendeeCount <= 0 || requiredEquipment == null) {
          throw new IllegalArgumentException("Valid slot, attendees, and equipment are required");
      }
      requiredEquipment = Set.copyOf(requiredEquipment);
  }
}

public enum ScheduleStatus {
  SCHEDULED,
  NO_ROOM_AVAILABLE
}

public enum CancellationStatus {
  CANCELED,
  MEETING_NOT_FOUND,
  NOT_ORGANIZER
}

import java.util.Optional;

public record ScheduleResult(
      ScheduleStatus status,
      Optional<Meeting> meeting
) {
  public ScheduleResult {
      if (status == null || meeting == null) {
          throw new IllegalArgumentException("Result fields are required");
      }
  }

  public static ScheduleResult accepted(Meeting meeting) {
      return new ScheduleResult(
              ScheduleStatus.SCHEDULED,
              Optional.of(meeting)
      );
  }

  public static ScheduleResult rejected() {
      return new ScheduleResult(
              ScheduleStatus.NO_ROOM_AVAILABLE,
              Optional.empty()
      );
  }
}

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public final class Room {
  private final String id;
  private final String name;
  private final int capacity;
  private final Set<Equipment> equipment;
  private final TreeMap<LocalDateTime, Meeting> schedule = new TreeMap<>();

  public Room(String id, String name, int capacity, Set<Equipment> equipment) {
      if (id == null || id.isBlank() || name == null || name.isBlank()) {
          throw new IllegalArgumentException("Room id and name are required");
      }
      if (capacity <= 0 || equipment == null) {
          throw new IllegalArgumentException("Valid capacity and equipment are required");
      }
      this.id = id;
      this.name = name;
      this.capacity = capacity;
      this.equipment = Set.copyOf(equipment);
  }

  public String id() {
      return id;
  }

  public String name() {
      return name;
  }

  public int capacity() {
      return capacity;
  }

  public Set<Equipment> equipment() {
      return equipment;
  }

  public boolean canHost(MeetingRequest request) {
      return capacity >= request.attendeeCount()
              && equipment.containsAll(request.requiredEquipment())
              && isAvailable(request.slot());
  }

  public boolean isAvailable(TimeSlot requested) {
      Map.Entry<LocalDateTime, Meeting> previous =
              schedule.floorEntry(requested.start());
      if (previous != null && previous.getValue().slot().overlaps(requested)) {
          return false;
      }

      Map.Entry<LocalDateTime, Meeting> next =
              schedule.ceilingEntry(requested.start());
      return next == null || !next.getValue().slot().overlaps(requested);
  }

  public boolean reserve(Meeting meeting) {
      if (!id.equals(meeting.roomId())
              || capacity < meeting.attendeeCount()
              || !equipment.containsAll(meeting.requiredEquipment())
              || !isAvailable(meeting.slot())) {
          return false;
      }
      schedule.put(meeting.slot().start(), meeting);
      return true;
  }

  public boolean remove(Meeting meeting) {
      if (meeting == null || !id.equals(meeting.roomId())) {
          return false;
      }
      return schedule.remove(meeting.slot().start(), meeting);
  }

  public List<Meeting> meetings() {
      return List.copyOf(schedule.values());
  }
}

import java.util.List;
import java.util.Optional;

public interface RoomSelectionStrategy {
  Optional<Room> select(List<Room> rooms, MeetingRequest request);
}

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

public final class SmallestSuitableRoomStrategy
      implements RoomSelectionStrategy {

  @Override
  public Optional<Room> select(
          List<Room> rooms,
          MeetingRequest request
  ) {
      return rooms.stream()
              .filter(room -> room.canHost(request))
              .min(Comparator.comparingInt(Room::capacity)
                      .thenComparing(Room::id));
  }
}

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public final class MeetingScheduler {
  private final List<Room> rooms;
  private final Map<String, Room> roomsById;
  private final Map<String, Meeting> meetingsById = new LinkedHashMap<>();
  private final RoomSelectionStrategy strategy;
  private int nextMeetingNumber = 1;

  public MeetingScheduler(
          List<Room> rooms,
          RoomSelectionStrategy strategy
  ) {
      if (rooms == null || rooms.isEmpty() || strategy == null) {
          throw new IllegalArgumentException("Rooms and strategy are required");
      }
      this.rooms = List.copyOf(rooms);
      this.strategy = strategy;
      this.roomsById = new LinkedHashMap<>();
      for (Room room : rooms) {
          if (roomsById.putIfAbsent(room.id(), room) != null) {
              throw new IllegalArgumentException("Duplicate room: " + room.id());
          }
      }
  }

  public ScheduleResult schedule(MeetingRequest request) {
      if (request == null) {
          throw new IllegalArgumentException("Request is required");
      }

      Optional<Room> selected = strategy.select(rooms, request);
      if (selected.isEmpty()) {
          return ScheduleResult.rejected();
      }

      Room room = selected.get();
      String meetingId = "M" + nextMeetingNumber;
      Meeting meeting = new Meeting(
              meetingId,
              request.title(),
              request.organizerId(),
              room.id(),
              request.slot(),
              request.attendeeCount(),
              request.requiredEquipment()
      );

      if (!room.reserve(meeting)) {
          return ScheduleResult.rejected();
      }
      nextMeetingNumber++;
      meetingsById.put(meeting.id(), meeting);
      return ScheduleResult.accepted(meeting);
  }

  public CancellationStatus cancel(
          String meetingId,
          String organizerId
  ) {
      Meeting meeting = meetingsById.get(meetingId);
      if (meeting == null) {
          return CancellationStatus.MEETING_NOT_FOUND;
      }
      if (!meeting.organizerId().equals(organizerId)) {
          return CancellationStatus.NOT_ORGANIZER;
      }

      Room room = roomsById.get(meeting.roomId());
      if (!room.remove(meeting)) {
          throw new IllegalStateException("Meeting index and room disagree");
      }
      meetingsById.remove(meetingId);
      return CancellationStatus.CANCELED;
  }

  public List<Meeting> meetingsForRoom(String roomId) {
      Room room = roomsById.get(roomId);
      return room == null ? List.of() : room.meetings();
  }
}

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
import java.util.Set;

public final class MeetingRoomSchedulerDemo {
  public static void main(String[] args) {
      LocalDate day = LocalDate.of(2026, 8, 14);
      MeetingScheduler scheduler = sampleScheduler();

      TimeSlot firstSlot = slot(day, 9, 0, 10, 0);
      TimeSlot touchingSlot = slot(day, 10, 0, 10, 30);
      System.out.println("back-to-back overlap: "
              + firstSlot.overlaps(touchingSlot));

      ScheduleResult first = scheduler.schedule(request(
              "Daily sync", "organizer-a", firstSlot, 4
      ));
      System.out.println("first room: "
              + first.meeting().orElseThrow().roomId());

      ScheduleResult touching = scheduler.schedule(request(
              "Design review", "organizer-b", touchingSlot, 4
      ));
      System.out.println("back-to-back room: "
              + touching.meeting().orElseThrow().roomId());

      ScheduleResult fallback = scheduler.schedule(request(
              "Interview", "organizer-c", slot(day, 9, 30, 10, 0), 4
      ));
      System.out.println("conflict fallback room: "
              + fallback.meeting().orElseThrow().roomId());

      ScheduleResult rejected = scheduler.schedule(request(
              "Urgent review", "organizer-d", slot(day, 9, 45, 10, 0), 4
      ));
      System.out.println("fully occupied: " + rejected.status());

      String firstId = first.meeting().orElseThrow().id();
      System.out.println("wrong cancellation: "
              + scheduler.cancel(firstId, "organizer-b"));
      System.out.println("owner cancellation: "
              + scheduler.cancel(firstId, "organizer-a"));

      ScheduleResult reopened = scheduler.schedule(request(
              "Replacement", "organizer-e", slot(day, 9, 0, 9, 30), 4
      ));
      System.out.println("reopened room: "
              + reopened.meeting().orElseThrow().roomId());
  }

  private static MeetingScheduler sampleScheduler() {
      Room focus = new Room(
              "R1", "Focus", 4,
              Set.of(Equipment.PROJECTOR, Equipment.WHITEBOARD)
      );
      Room cedar = new Room(
              "R2", "Cedar", 6,
              Set.of(Equipment.WHITEBOARD)
      );
      Room atlas = new Room(
              "R3", "Atlas", 10,
              Set.of(
                      Equipment.PROJECTOR,
                      Equipment.WHITEBOARD,
                      Equipment.VIDEO
              )
      );
      return new MeetingScheduler(
              List.of(focus, cedar, atlas),
              new SmallestSuitableRoomStrategy()
      );
  }

  private static MeetingRequest request(
          String title,
          String organizer,
          TimeSlot slot,
          int attendees
  ) {
      return new MeetingRequest(
              title,
              organizer,
              slot,
              attendees,
              Set.of(Equipment.PROJECTOR)
      );
  }

  private static TimeSlot slot(
          LocalDate day,
          int startHour,
          int startMinute,
          int endHour,
          int endMinute
  ) {
      return new TimeSlot(
              LocalDateTime.of(day, LocalTime.of(startHour, startMinute)),
              LocalDateTime.of(day, LocalTime.of(endHour, endMinute))
      );
  }
}