Meeting calendar application

class User {
  constructor(id, name) {
    this.id = id;
    this.name = name;
  }
}

class Meeting {
  constructor(id, organizerId, title, start, end, inviteeIds) {
    this.id = id;
    this.organizerId = organizerId;
    this.title = title;
    this.start = start;
    this.end = end;
    this.responses = new Map([[organizerId, "ACCEPTED"]]);
    for (const userId of inviteeIds) this.responses.set(userId, "PENDING");
  }
  overlaps(other) {
    return this.start < other.end && other.start < this.end;
  }
}

class StrictPolicy {
  allows(conflicts) {
    return conflicts.length === 0;
  }
}

class PermissivePolicy {
  allows() {
    return true;
  }
}

class InboxObserver {
  constructor() {
    this.inboxes = new Map();
  }
  update(event) {
    if (!this.inboxes.has(event.userId)) this.inboxes.set(event.userId, []);
    this.inboxes.get(event.userId).push(event.type + ":" + event.meetingId);
  }
  inbox(userId) {
    return this.inboxes.get(userId) || [];
  }
}

class CalendarService {
  constructor(policy) {
    this.policy = policy;
    this.users = new Map();
    this.meetings = new Map();
    this.observers = [];
    this.nextId = 1;
  }
  addUser(user) {
    this.users.set(user.id, user);
  }
  subscribe(observer) {
    this.observers.push(observer);
  }
  emit(type, meeting, userId) {
    for (const observer of this.observers) observer.update({ type, meetingId: meeting.id, userId });
  }
  conflictsFor(userId, meeting) {
    const found = [];
    for (const other of this.meetings.values()) {
      const accepted = other.responses.get(userId) === "ACCEPTED";
      if (accepted && other.id !== meeting.id && other.overlaps(meeting)) found.push(other.id);
    }
    return found;
  }
  schedule(organizerId, title, start, end, inviteeIds) {
    if (!this.users.has(organizerId)) return { ok: false, reason: "unknown organizer" };
    if (!(start < end)) return { ok: false, reason: "invalid time range" };
    const invitees = [...new Set(inviteeIds)].filter((id) => id !== organizerId);
    if (invitees.some((id) => !this.users.has(id))) return { ok: false, reason: "unknown invitee" };
    const meeting = new Meeting("M" + this.nextId, organizerId, title, start, end, invitees);
    const conflicts = this.conflictsFor(organizerId, meeting);
    if (!this.policy.allows(conflicts)) return { ok: false, reason: "organizer is busy", conflicts };
    this.nextId++;
    this.meetings.set(meeting.id, meeting);
    for (const id of invitees) this.emit("invited", meeting, id);
    return { ok: true, meeting };
  }
  respond(meetingId, userId, accept) {
    const meeting = this.meetings.get(meetingId);
    if (!meeting || !meeting.responses.has(userId) || userId === meeting.organizerId) {
      return { ok: false, reason: "not an invitee" };
    }
    if (accept) {
      const conflicts = this.conflictsFor(userId, meeting);
      if (!this.policy.allows(conflicts)) return { ok: false, reason: "overlaps an accepted meeting", conflicts };
    }
    meeting.responses.set(userId, accept ? "ACCEPTED" : "REJECTED");
    this.emit(accept ? "accepted" : "rejected", meeting, meeting.organizerId);
    return { ok: true };
  }
  cancel(meetingId, userId) {
    const meeting = this.meetings.get(meetingId);
    if (!meeting || meeting.organizerId !== userId) return false;
    this.meetings.delete(meetingId);
    for (const id of meeting.responses.keys()) if (id !== userId) this.emit("cancelled", meeting, id);
    return true;
  }
  view(userId, from, to) {
    const rows = [];
    for (const m of this.meetings.values()) {
      const status = m.responses.get(userId);
      if (!status || status === "REJECTED") continue;
      if (m.start < to && from < m.end) rows.push({ id: m.id, title: m.title, start: m.start, end: m.end, status });
    }
    return rows.sort((a, b) => a.start - b.start);
  }
}

function createService(policy) {
  const service = new CalendarService(policy);
  for (const id of ["ann", "bob", "cy"]) service.addUser(new User(id, id));
  const inbox = new InboxObserver();
  service.subscribe(inbox);
  return { service, inbox };
}