Meeting Room Scheduler

1import java.time.*;
2import java.util.*;
3/** Atomic in-memory calendar. Intervals are half-open instants; recurrence starts in a named zone. */
4public final class Solution {
5    private Solution() {}
6    public record Range(Instant start,Instant end){public Range{Objects.requireNonNull(start);Objects.requireNonNull(end);if(!start.isBefore(end))throw new IllegalArgumentException("range");}}
7    public record Need(int people,Set<String> equipment){public Need{if(people<1)throw new IllegalArgumentException("people");equipment=Set.copyOf(equipment);}}
8    public record Room(String id,int capacity,Set<String> equipment){public Room{if(id==null||id.isBlank()||capacity<1)throw new IllegalArgumentException("room");equipment=Set.copyOf(equipment);}}
9    public record Booking(String id,String roomId,Range range,Need need,int version,boolean cancelled){}
10    public static boolean overlaps(Range a,Range b){return a.start().isBefore(b.end())&&b.start().isBefore(a.end());}
11    public static List<Range> weekly(LocalDateTime first,ZoneId zone,Duration duration,int occurrences){
12        Objects.requireNonNull(first);Objects.requireNonNull(zone);Objects.requireNonNull(duration);
13        if(occurrences<1||occurrences>52||duration.isZero()||duration.isNegative())throw new IllegalArgumentException("recurrence");
14        var ranges=new ArrayList<Range>();
15        for(int i=0;i<occurrences;i++){
16            var local=first.plusWeeks(i);var offsets=zone.getRules().getValidOffsets(local);
17            if(offsets.size()!=1)throw new IllegalArgumentException("ambiguous or nonexistent local time");
18            Instant start=local.toInstant(offsets.getFirst());ranges.add(new Range(start,start.plus(duration)));
19        }
20        return List.copyOf(ranges);
21    }
22    public static final class Calendar {
23        private final Map<String,Room> rooms=new TreeMap<>();
24        private final Map<String,TreeMap<Instant,Booking>> timelines=new HashMap<>();
25        private final Map<String,Booking> bookings=new HashMap<>();
26        private long sequence;
27        public Calendar(List<Room> rooms){for(var r:rooms){if(this.rooms.put(r.id(),r)!=null)throw new IllegalArgumentException("duplicate room");timelines.put(r.id(),new TreeMap<>());}}
28        private Room room(String id){var r=rooms.get(id);if(r==null)throw new IllegalArgumentException("room");return r;}
29        private boolean fits(Room r,Need n){return r.capacity()>=n.people()&&r.equipment().containsAll(n.equipment());}
30        private boolean conflict(String roomId,Range range,String ignore){
31            var map=timelines.get(roomId);var before=map.floorEntry(range.start());
32            if(before!=null&&before.getValue().id().equals(ignore))before=map.lowerEntry(before.getKey());
33            if(before!=null&&overlaps(before.getValue().range(),range))return true;
34            var after=map.ceilingEntry(range.start());
35            if(after!=null&&after.getValue().id().equals(ignore))after=map.higherEntry(after.getKey());
36            return after!=null&&overlaps(after.getValue().range(),range);
37        }
38        public synchronized List<String> find(Need need,Range range){Objects.requireNonNull(need);Objects.requireNonNull(range);return rooms.values().stream().filter(r->fits(r,need)&&!conflict(r.id(),range,"")).map(Room::id).toList();}
39        public synchronized Booking book(String roomId,Need need,Range range){
40            Objects.requireNonNull(need);Objects.requireNonNull(range);if(!fits(room(roomId),need)||conflict(roomId,range,""))throw new IllegalStateException("unavailable");
41            var b=new Booking("B"+(++sequence),roomId,range,need,0,false);timelines.get(roomId).put(range.start(),b);bookings.put(b.id(),b);return b;
42        }
43        public synchronized List<Booking> bookSeries(String roomId,Need need,List<Range> occurrences){
44            Objects.requireNonNull(need);var ranges=new ArrayList<>(List.copyOf(occurrences));if(ranges.isEmpty()||ranges.size()>52)throw new IllegalArgumentException("series");
45            ranges.sort(Comparator.comparing(Range::start));if(!fits(room(roomId),need))throw new IllegalStateException("requirements");
46            for(int i=0;i<ranges.size();i++)if(conflict(roomId,ranges.get(i),"")||(i>0&&overlaps(ranges.get(i-1),ranges.get(i))))throw new IllegalStateException("series conflict");
47            var result=new ArrayList<Booking>();for(var range:ranges)result.add(book(roomId,need,range));return List.copyOf(result);
48        }
49        public synchronized Booking reschedule(String id,String targetRoom,Range range,int expectedVersion){
50            Objects.requireNonNull(range);var old=get(id);if(old.cancelled()||old.version()!=expectedVersion)throw new IllegalStateException("stale or cancelled");
51            if(!fits(room(targetRoom),old.need())||conflict(targetRoom,range,id))throw new IllegalStateException("unavailable");
52            var updated=new Booking(id,targetRoom,range,old.need(),Math.incrementExact(old.version()),false);
53            timelines.get(old.roomId()).remove(old.range().start());timelines.get(targetRoom).put(range.start(),updated);bookings.put(id,updated);return updated;
54        }
55        public synchronized Booking cancel(String id,int expectedVersion){
56            var old=get(id);if(old.cancelled())return old;
57            if(old.version()!=expectedVersion)throw new IllegalStateException("stale version");
58            var updated=new Booking(id,old.roomId(),old.range(),old.need(),Math.incrementExact(old.version()),true);timelines.get(old.roomId()).remove(old.range().start());bookings.put(id,updated);return updated;
59        }
60        public synchronized Booking get(String id){var b=bookings.get(id);if(b==null)throw new IllegalArgumentException("booking");return b;}
61        public synchronized int activeCount(){return timelines.values().stream().mapToInt(Map::size).sum();}
62    }
63}
64