Meeting Scheduler

public final class TimeSlot {
    public final Instant start, end;

    public TimeSlot(Instant start, Instant end) {
        if (!end.isAfter(start)) throw new IllegalArgumentException("end must be after start");
        this.start = start; this.end = end;
    }

    public boolean overlaps(TimeSlot other) {
        return start.isBefore(other.end) && other.start.isBefore(end);
    }
}

public class Room {
    private final String id;
    private final String name;
    private final int capacity;
    // Sorted by start time for fast conflict checks
    private final TreeMap<Instant, Meeting> bookings = new TreeMap<>();

    public Room(String id, String name, int capacity) {
        this.id = id; this.name = name; this.capacity = capacity;
    }

    public synchronized boolean isAvailable(TimeSlot slot) {
        // Check meetings starting just before or during the slot
        Map.Entry<Instant, Meeting> floor = bookings.floorEntry(slot.start);
        if (floor != null && floor.getValue().getSlot().overlaps(slot)) return false;

        Map.Entry<Instant, Meeting> ceiling = bookings.ceilingEntry(slot.start);
        if (ceiling != null && ceiling.getValue().getSlot().overlaps(slot)) return false;

        return true;
    }

    public synchronized boolean book(Meeting m) {
        if (!isAvailable(m.getSlot())) return false;
        bookings.put(m.getSlot().start, m);
        return true;
    }

    public synchronized void cancel(Meeting m) {
        bookings.remove(m.getSlot().start);
    }

    public int getCapacity() { return capacity; }
    public String getId() { return id; }
}

public enum MeetingStatus { SCHEDULED, CANCELLED, COMPLETED }

public class Meeting {
    private final String id;
    private final User organizer;
    private final List<User> attendees;
    private final Room room;
    private final TimeSlot slot;
    private MeetingStatus status = MeetingStatus.SCHEDULED;

    public Meeting(User organizer, List<User> attendees, Room room, TimeSlot slot) {
        this.id = UUID.randomUUID().toString();
        this.organizer = organizer;
        this.attendees = List.copyOf(attendees);
        this.room = room;
        this.slot = slot;
    }

    public TimeSlot getSlot() { return slot; }
    public List<User> getAttendees() { return attendees; }
    public Room getRoom() { return room; }
    public void cancel() { this.status = MeetingStatus.CANCELLED; }
}

public class Calendar {
    private final List<Room> rooms;
    private final NotificationService notifier;
    // For checking attendee conflicts across rooms
    private final Map<User, TreeMap<Instant, Meeting>> userBookings = new ConcurrentHashMap<>();

    public Calendar(List<Room> rooms, NotificationService n) {
        this.rooms = rooms; this.notifier = n;
    }

    public synchronized Meeting book(User organizer, List<User> attendees,
                                      Room room, TimeSlot slot) {
        // Room available?
        if (!room.isAvailable(slot)) throw new ConflictException("Room busy");

        // Attendees free?
        for (User u : attendees) {
            if (hasUserConflict(u, slot))
                throw new ConflictException("Attendee " + u + " busy");
        }
        if (attendees.size() > room.getCapacity())
            throw new IllegalArgumentException("Room too small");

        Meeting m = new Meeting(organizer, attendees, room, slot);
        room.book(m);
        for (User u : attendees) {
            userBookings.computeIfAbsent(u, k -> new TreeMap<>())
                        .put(slot.start, m);
        }
        notifier.sendInvite(m);
        return m;
    }

    public synchronized void cancel(Meeting m) {
        m.getRoom().cancel(m);
        for (User u : m.getAttendees()) {
            userBookings.getOrDefault(u, new TreeMap<>()).remove(m.getSlot().start);
        }
        m.cancel();
        notifier.sendCancellation(m);
    }

    public List<Room> findAvailableRooms(TimeSlot slot, int capacity) {
        return rooms.stream()
            .filter(r -> r.getCapacity() >= capacity && r.isAvailable(slot))
            .toList();
    }

    private boolean hasUserConflict(User u, TimeSlot slot) {
        TreeMap<Instant, Meeting> ms = userBookings.get(u);
        if (ms == null) return false;
        Map.Entry<Instant, Meeting> floor = ms.floorEntry(slot.start);
        if (floor != null && floor.getValue().getSlot().overlaps(slot)) return true;
        Map.Entry<Instant, Meeting> ceiling = ms.ceilingEntry(slot.start);
        return ceiling != null && ceiling.getValue().getSlot().overlaps(slot);
    }
}

public class RecurringMeeting {
    private final Meeting prototype;
    private final RecurrenceRule rule;   // daily, weekly, custom
    private final LocalDate until;

    public List<Meeting> expand() {
        // Generate concrete Meeting instances for each occurrence
    }
}