20. Chat Application (WhatsApp-style) Advanced

interface MessageStatus {
  MessageStatus onDelivered();
  MessageStatus onRead();
}

class ChatService {
  Message sendMessage(User sender, Conversation conversation, String content);
  List<Message> reconnect(User user, long lastSeenSequence);   // exactly-once replay
}

interface MessageStatus {
  MessageStatus onDelivered();
  MessageStatus onRead();
}

class ChatService {
  Message sendMessage(User sender, Conversation conversation, String content);
  List<Message> reconnect(User user, long lastSeenSequence);   // exactly-once replay
}

class MessageStatus {
public:
  virtual std::shared_ptr<MessageStatus> onDelivered() = 0;
  virtual std::shared_ptr<MessageStatus> onRead() = 0;
};

class ChatService {
public:
  std::shared_ptr<Message> sendMessage(std::shared_ptr<User> sender, std::shared_ptr<Conversation> conversation, const std::string& content);
  std::vector<std::shared_ptr<Message>> reconnect(std::shared_ptr<User> user, long lastSeenSequence);   // exactly-once replay
};

class MessageStatus {
  onDelivered() { throw new Error('not implemented'); }
  onRead() { throw new Error('not implemented'); }
}

class ChatService {
  sendMessage(sender, conversation, content) {}
  reconnect(user, lastSeenSequence) {}   // exactly-once replay
}

interface MessageStatus {
  onDelivered(): MessageStatus;
  onRead(): MessageStatus;
}

class ChatService {
  sendMessage(sender: User, conversation: Conversation, content: string): Message {}
  reconnect(user: User, lastSeenSequence: number): Message[] {}   // exactly-once replay
}

Conversation.send(sender, content):
  lock(this.sequenceCounter)
  try:
    seq = ++this.nextSequence      // server-assigned, monotonic per conversation
    message = new Message(sender, content, seq)
  finally:
    unlock(this.sequenceCounter)
  this.messages.append(message)
  for participant in this.participants:      // Observer fan-out
    if presenceTracker.isOnline(participant):
      deliver(participant, message)
    else:
      offlineQueueFor(participant).enqueue(message)
  return message

ChatService.reconnect(user, lastSeenSequence):
  missed = offlineQueueFor(user).allAfter(lastSeenSequence)   // idempotent: same cursor -> same result
  offlineQueueFor(user).clearUpTo(lastSeenSequence + missed.size)
  return missed

Message send(User sender, String content) {
  Message message;
  lock(this.sequenceCounter);
  try {
    long seq = ++this.nextSequence;      // server-assigned, monotonic per conversation
    message = new Message(sender, content, seq);
  } finally {
    unlock(this.sequenceCounter);
  }
  this.messages.add(message);
  for (User participant : this.participants) {      // Observer fan-out
    if (presenceTracker.isOnline(participant)) {
      deliver(participant, message);
    } else {
      offlineQueueFor(participant).enqueue(message);
    }
  }
  return message;
}

List<Message> reconnect(User user, long lastSeenSequence) {
  List<Message> missed = offlineQueueFor(user).allAfter(lastSeenSequence);   // idempotent: same cursor -> same result
  offlineQueueFor(user).clearUpTo(lastSeenSequence + missed.size());
  return missed;
}

std::shared_ptr<Message> Conversation::send(std::shared_ptr<User> sender, const std::string& content) {
  std::shared_ptr<Message> message;
  lock(sequenceCounter_);
  try {
    long seq = ++nextSequence_;      // server-assigned, monotonic per conversation
    message = std::make_shared<Message>(sender, content, seq);
  } catch (...) {
    unlock(sequenceCounter_);
    throw;
  }
  unlock(sequenceCounter_);
  messages_.push_back(message);
  for (auto& participant : participants_) {      // Observer fan-out
    if (presenceTracker->isOnline(participant)) {
      deliver(participant, message);
    } else {
      offlineQueueFor(participant)->enqueue(message);
    }
  }
  return message;
}

std::vector<std::shared_ptr<Message>> ChatService::reconnect(std::shared_ptr<User> user, long lastSeenSequence) {
  auto missed = offlineQueueFor(user)->allAfter(lastSeenSequence);   // idempotent: same cursor -> same result
  offlineQueueFor(user)->clearUpTo(lastSeenSequence + missed.size());
  return missed;
}

send(sender, content) {
  let message;
  lock(this.sequenceCounter);
  try {
    const seq = ++this.nextSequence;      // server-assigned, monotonic per conversation
    message = new Message(sender, content, seq);
  } finally {
    unlock(this.sequenceCounter);
  }
  this.messages.push(message);
  for (const participant of this.participants) {      // Observer fan-out
    if (presenceTracker.isOnline(participant)) {
      deliver(participant, message);
    } else {
      offlineQueueFor(participant).enqueue(message);
    }
  }
  return message;
}

reconnect(user, lastSeenSequence) {
  const missed = offlineQueueFor(user).allAfter(lastSeenSequence);   // idempotent: same cursor -> same result
  offlineQueueFor(user).clearUpTo(lastSeenSequence + missed.length);
  return missed;
}

send(sender: User, content: string): Message {
  let message: Message;
  lock(this.sequenceCounter);
  try {
    const seq = ++this.nextSequence;      // server-assigned, monotonic per conversation
    message = new Message(sender, content, seq);
  } finally {
    unlock(this.sequenceCounter);
  }
  this.messages.push(message);
  for (const participant of this.participants) {      // Observer fan-out
    if (presenceTracker.isOnline(participant)) {
      deliver(participant, message);
    } else {
      offlineQueueFor(participant).enqueue(message);
    }
  }
  return message;
}

reconnect(user: User, lastSeenSequence: number): Message[] {
  const missed = offlineQueueFor(user).allAfter(lastSeenSequence);   // idempotent: same cursor -> same result
  offlineQueueFor(user).clearUpTo(lastSeenSequence + missed.length);
  return missed;
}

// Problem 20: Chat Application (WhatsApp-style)
// Patterns: Mediator + Observer (Conversation), State (MessageStatus per recipient), Facade (ChatService)
import java.util.*;

public class p20 {

    // ---------- User ----------
    static class User {
        final String id;
        final Set<String> connectedDevices = new HashSet<>();
        User(String id) { this.id = id; }
    }

    // ---------- MessageStatus (per-recipient state machine) ----------
    interface MessageStatus {
        MessageStatus onDelivered();
        MessageStatus onRead();
        String name();
    }

    static class SentStatus implements MessageStatus {
        @Override public MessageStatus onDelivered() { return new DeliveredStatus(); }
        @Override public MessageStatus onRead() { throw new IllegalStateException("Must be delivered before read"); }
        @Override public String name() { return "SENT"; }
    }
    static class DeliveredStatus implements MessageStatus {
        @Override public MessageStatus onDelivered() { return this; }
        @Override public MessageStatus onRead() { return new ReadStatus(); }
        @Override public String name() { return "DELIVERED"; }
    }
    static class ReadStatus implements MessageStatus {
        @Override public MessageStatus onDelivered() { return this; }
        @Override public MessageStatus onRead() { return this; }
        @Override public String name() { return "READ"; }
    }

    // ---------- Message ----------
    static class Message {
        final User sender;
        final String content;
        final long sequenceNo;
        final Map<String, MessageStatus> receipts = new HashMap<>(); // recipientId -> status

        Message(User sender, String content, long sequenceNo, List<User> recipients) {
            this.sender = sender; this.content = content; this.sequenceNo = sequenceNo;
            for (User r : recipients) receipts.put(r.id, new SentStatus());
        }

        void markDelivered(String userId) { receipts.computeIfPresent(userId, (k, s) -> s.onDelivered()); }
        void markRead(String userId) { receipts.computeIfPresent(userId, (k, s) -> s.onRead()); }
    }

    // ---------- PresenceTracker ----------
    static class PresenceTracker {
        private final Map<String, Set<String>> connectedDeviceIds = new HashMap<>();

        void deviceConnected(String userId, String deviceId) {
            connectedDeviceIds.computeIfAbsent(userId, k -> new HashSet<>()).add(deviceId);
        }
        void deviceDisconnected(String userId, String deviceId) {
            Set<String> devices = connectedDeviceIds.get(userId);
            if (devices != null) devices.remove(deviceId);
        }
        boolean isOnline(String userId) {
            Set<String> devices = connectedDeviceIds.get(userId);
            return devices != null && !devices.isEmpty();
        }
    }

    // Simple per-user append-only log of messages missed while offline.
    // NOTE (interview-scale simplification): the cursor passed to reconnect() is treated as an
    // index into this per-user queue (not the message's own per-conversation sequenceNo), since
    // a user's offline queue spans multiple conversations whose sequence numbers aren't
    // comparable to each other. Same cursor -> same slice, so replay is idempotent.
    static class OfflineQueue {
        private final List<Message> messages = new ArrayList<>();
        void enqueue(Message m) { messages.add(m); }
        List<Message> allAfter(long cursor) {
            int from = Math.min((int) cursor, messages.size());
            return new ArrayList<>(messages.subList(from, messages.size()));
        }
        void clearUpTo(long cursor) {
            int upTo = Math.min((int) cursor, messages.size());
            messages.subList(0, upTo).clear();
        }
    }

    // ---------- Conversation (Mediator + Observer subject) ----------
    static abstract class Conversation {
        final String id;
        final List<User> participants = new ArrayList<>();
        final List<Message> messages = new ArrayList<>();
        long nextSequence = 0;
        private final PresenceTracker presenceTracker;
        private final Map<String, OfflineQueue> offlineQueues; // shared reference, owned by ChatService

        Conversation(String id, PresenceTracker presenceTracker, Map<String, OfflineQueue> offlineQueues) {
            this.id = id; this.presenceTracker = presenceTracker; this.offlineQueues = offlineQueues;
        }

        void addParticipant(User user) {
            if (!participants.contains(user)) participants.add(user);
        }

        Message send(User sender, String content) {
            long seq = ++nextSequence; // server-assigned, monotonic per conversation
            List<User> recipients = new ArrayList<>();
            for (User p : participants) if (!p.id.equals(sender.id)) recipients.add(p);
            Message message = new Message(sender, content, seq, recipients);
            messages.add(message);

            for (User participant : recipients) { // Observer fan-out
                if (presenceTracker.isOnline(participant.id)) {
                    message.markDelivered(participant.id);
                } else {
                    offlineQueues.computeIfAbsent(participant.id, k -> new OfflineQueue()).enqueue(message);
                }
            }
            return message;
        }
    }

    static class DirectConversation extends Conversation {
        DirectConversation(String id, User a, User b, PresenceTracker tracker, Map<String, OfflineQueue> offlineQueues) {
            super(id, tracker, offlineQueues);
            participants.add(a); participants.add(b);
        }
        @Override void addParticipant(User user) {
            throw new UnsupportedOperationException("DirectConversation is fixed at 2 participants");
        }
    }

    static class GroupConversation extends Conversation {
        GroupConversation(String id, List<User> initialParticipants, PresenceTracker tracker, Map<String, OfflineQueue> offlineQueues) {
            super(id, tracker, offlineQueues);
            participants.addAll(initialParticipants);
        }
        void removeParticipant(User user) { participants.remove(user); }
    }

    // ---------- ChatService (Facade) ----------
    static class ChatService {
        private final PresenceTracker presenceTracker = new PresenceTracker();
        private final Map<String, OfflineQueue> offlineQueues = new HashMap<>();
        private int nextConversationId = 1;

        PresenceTracker getPresenceTracker() { return presenceTracker; }

        DirectConversation createDirectConversation(User a, User b) {
            return new DirectConversation("C" + (nextConversationId++), a, b, presenceTracker, offlineQueues);
        }

        GroupConversation createGroupConversation(List<User> participants) {
            return new GroupConversation("C" + (nextConversationId++), participants, presenceTracker, offlineQueues);
        }

        Message sendMessage(User sender, Conversation conversation, String content) {
            return conversation.send(sender, content);
        }

        // Exactly-once replay: client passes back the cursor from its last successful reconnect.
        List<Message> reconnect(User user, long lastSeenSequence) {
            OfflineQueue queue = offlineQueues.computeIfAbsent(user.id, k -> new OfflineQueue());
            List<Message> missed = queue.allAfter(lastSeenSequence);
            queue.clearUpTo(lastSeenSequence + missed.size());
            for (Message m : missed) m.markDelivered(user.id);
            return missed;
        }
    }

    // ---------- Demo ----------
    public static void main(String[] args) {
        ChatService chatService = new ChatService();
        User alice = new User("alice");
        User bob = new User("bob");
        User carol = new User("carol");

        chatService.getPresenceTracker().deviceConnected("alice", "alice-phone");
        chatService.getPresenceTracker().deviceConnected("bob", "bob-laptop");
        // carol is offline (no connected device)

        GroupConversation group = chatService.createGroupConversation(Arrays.asList(alice, bob, carol));

        Message m1 = chatService.sendMessage(alice, group, "Hello everyone!");
        System.out.println("Sent seq=" + m1.sequenceNo + " bob receipt=" + m1.receipts.get("bob").name()
                + " carol receipt=" + m1.receipts.get("carol").name());

        Message m2 = chatService.sendMessage(bob, group, "Hi Alice!");
        System.out.println("Sent seq=" + m2.sequenceNo);

        // Carol reconnects and should receive both missed messages, exactly once, in order.
        List<Message> missed = chatService.reconnect(carol, 0);
        System.out.println("Carol missed " + missed.size() + " messages, first content='" + missed.get(0).content + "'");

        // Idempotent retry with an already-advanced cursor should now return nothing new.
        List<Message> replay = chatService.reconnect(carol, missed.size());
        System.out.println("Carol replay after ack: " + replay.size() + " messages (expect 0)");

        m1.markRead("bob");
        System.out.println("Bob's receipt for m1 after reading: " + m1.receipts.get("bob").name());
    }
}

// Problem 20: Chat Application (WhatsApp-style)
// Patterns: Mediator + Observer (Conversation), State (MessageStatus per recipient), Facade (ChatService)
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <memory>
#include <string>
#include <algorithm>
#include <stdexcept>

using namespace std;

// ---------- User ----------
struct User {
    string id;
    set<string> connectedDevices;
    User(string id_) : id(move(id_)) {}
};

// ---------- MessageStatus (per-recipient state machine) ----------
class MessageStatus {
public:
    virtual ~MessageStatus() = default;
    virtual shared_ptr<MessageStatus> onDelivered() = 0;
    virtual shared_ptr<MessageStatus> onRead() = 0;
    virtual string name() const = 0;
};

class SentStatus : public MessageStatus {
public:
    shared_ptr<MessageStatus> onDelivered() override;
    shared_ptr<MessageStatus> onRead() override { throw runtime_error("Must be delivered before read"); }
    string name() const override { return "SENT"; }
};
class DeliveredStatus : public MessageStatus {
public:
    shared_ptr<MessageStatus> onDelivered() override { return make_shared<DeliveredStatus>(); }
    shared_ptr<MessageStatus> onRead() override;
    string name() const override { return "DELIVERED"; }
};
class ReadStatus : public MessageStatus {
public:
    shared_ptr<MessageStatus> onDelivered() override { return make_shared<ReadStatus>(); }
    shared_ptr<MessageStatus> onRead() override { return make_shared<ReadStatus>(); }
    string name() const override { return "READ"; }
};
shared_ptr<MessageStatus> SentStatus::onDelivered() { return make_shared<DeliveredStatus>(); }
shared_ptr<MessageStatus> DeliveredStatus::onRead() { return make_shared<ReadStatus>(); }

// ---------- Message ----------
class Message {
public:
    shared_ptr<User> sender;
    string content;
    long long sequenceNo;
    map<string, shared_ptr<MessageStatus>> receipts; // recipientId -> status

    Message(shared_ptr<User> sender_, string content_, long long seq, const vector<shared_ptr<User>>& recipients)
        : sender(sender_), content(move(content_)), sequenceNo(seq) {
        for (auto& r : recipients) receipts[r->id] = make_shared<SentStatus>();
    }

    void markDelivered(const string& userId) {
        auto it = receipts.find(userId);
        if (it != receipts.end()) it->second = it->second->onDelivered();
    }
    void markRead(const string& userId) {
        auto it = receipts.find(userId);
        if (it != receipts.end()) it->second = it->second->onRead();
    }
};

// ---------- PresenceTracker ----------
class PresenceTracker {
    map<string, set<string>> connectedDeviceIds;
public:
    void deviceConnected(const string& userId, const string& deviceId) { connectedDeviceIds[userId].insert(deviceId); }
    void deviceDisconnected(const string& userId, const string& deviceId) {
        auto it = connectedDeviceIds.find(userId);
        if (it != connectedDeviceIds.end()) it->second.erase(deviceId);
    }
    bool isOnline(const string& userId) {
        auto it = connectedDeviceIds.find(userId);
        return it != connectedDeviceIds.end() && !it->second.empty();
    }
};

// Simple per-user append-only log of messages missed while offline.
// NOTE (interview-scale simplification): the cursor passed to reconnect() is treated as an
// index into this per-user queue (not the message's own per-conversation sequenceNo), since
// a user's offline queue spans multiple conversations whose sequence numbers aren't
// comparable to each other. Same cursor -> same slice, so replay is idempotent.
class OfflineQueue {
    vector<shared_ptr<Message>> messages;
public:
    void enqueue(shared_ptr<Message> m) { messages.push_back(m); }
    vector<shared_ptr<Message>> allAfter(long long cursor) {
        size_t from = min((size_t) max<long long>(cursor, 0), messages.size());
        return vector<shared_ptr<Message>>(messages.begin() + from, messages.end());
    }
    void clearUpTo(long long cursor) {
        size_t upTo = min((size_t) max<long long>(cursor, 0), messages.size());
        messages.erase(messages.begin(), messages.begin() + upTo);
    }
};

// ---------- Conversation (Mediator + Observer subject) ----------
class Conversation {
protected:
    PresenceTracker* presenceTracker;
    map<string, shared_ptr<OfflineQueue>>* offlineQueues; // shared reference, owned by ChatService
public:
    string id;
    vector<shared_ptr<User>> participants;
    vector<shared_ptr<Message>> messages;
    long long nextSequence = 0;

    Conversation(string id_, PresenceTracker* tracker, map<string, shared_ptr<OfflineQueue>>* queues)
        : presenceTracker(tracker), offlineQueues(queues), id(move(id_)) {}
    virtual ~Conversation() = default;

    virtual void addParticipant(shared_ptr<User> user) {
        if (find(participants.begin(), participants.end(), user) == participants.end()) participants.push_back(user);
    }

    shared_ptr<Message> send(shared_ptr<User> sender, const string& content) {
        long long seq = ++nextSequence; // server-assigned, monotonic per conversation
        vector<shared_ptr<User>> recipients;
        for (auto& p : participants) if (p->id != sender->id) recipients.push_back(p);
        auto message = make_shared<Message>(sender, content, seq, recipients);
        messages.push_back(message);

        for (auto& participant : recipients) { // Observer fan-out
            if (presenceTracker->isOnline(participant->id)) {
                message->markDelivered(participant->id);
            } else {
                auto& q = (*offlineQueues)[participant->id];
                if (!q) q = make_shared<OfflineQueue>();
                q->enqueue(message);
            }
        }
        return message;
    }
};

class DirectConversation : public Conversation {
public:
    DirectConversation(string id_, shared_ptr<User> a, shared_ptr<User> b, PresenceTracker* tracker,
                        map<string, shared_ptr<OfflineQueue>>* queues)
        : Conversation(move(id_), tracker, queues) {
        participants.push_back(a); participants.push_back(b);
    }
    void addParticipant(shared_ptr<User> user) override {
        throw runtime_error("DirectConversation is fixed at 2 participants");
    }
};

class GroupConversation : public Conversation {
public:
    GroupConversation(string id_, vector<shared_ptr<User>> initial, PresenceTracker* tracker,
                       map<string, shared_ptr<OfflineQueue>>* queues)
        : Conversation(move(id_), tracker, queues) {
        participants = move(initial);
    }
    void removeParticipant(shared_ptr<User> user) {
        participants.erase(remove(participants.begin(), participants.end(), user), participants.end());
    }
};

// ---------- ChatService (Facade) ----------
class ChatService {
    PresenceTracker presenceTracker;
    map<string, shared_ptr<OfflineQueue>> offlineQueues;
    int nextConversationId = 1;
public:
    PresenceTracker& getPresenceTracker() { return presenceTracker; }

    shared_ptr<DirectConversation> createDirectConversation(shared_ptr<User> a, shared_ptr<User> b) {
        return make_shared<DirectConversation>("C" + to_string(nextConversationId++), a, b, &presenceTracker, &offlineQueues);
    }

    shared_ptr<GroupConversation> createGroupConversation(vector<shared_ptr<User>> participants) {
        return make_shared<GroupConversation>("C" + to_string(nextConversationId++), move(participants), &presenceTracker, &offlineQueues);
    }

    shared_ptr<Message> sendMessage(shared_ptr<User> sender, shared_ptr<Conversation> conversation, const string& content) {
        return conversation->send(sender, content);
    }

    // Exactly-once replay: client passes back the cursor from its last successful reconnect.
    vector<shared_ptr<Message>> reconnect(shared_ptr<User> user, long long lastSeenSequence) {
        auto& q = offlineQueues[user->id];
        if (!q) q = make_shared<OfflineQueue>();
        auto missed = q->allAfter(lastSeenSequence);
        q->clearUpTo(lastSeenSequence + (long long) missed.size());
        for (auto& m : missed) m->markDelivered(user->id);
        return missed;
    }
};

// ---------- Demo ----------
int main() {
    ChatService chatService;
    auto alice = make_shared<User>("alice");
    auto bob = make_shared<User>("bob");
    auto carol = make_shared<User>("carol");

    chatService.getPresenceTracker().deviceConnected("alice", "alice-phone");
    chatService.getPresenceTracker().deviceConnected("bob", "bob-laptop");
    // carol is offline (no connected device)

    auto group = chatService.createGroupConversation({alice, bob, carol});

    auto m1 = chatService.sendMessage(alice, group, "Hello everyone!");
    cout << "Sent seq=" << m1->sequenceNo << " bob receipt=" << m1->receipts["bob"]->name()
         << " carol receipt=" << m1->receipts["carol"]->name() << endl;

    auto m2 = chatService.sendMessage(bob, group, "Hi Alice!");
    cout << "Sent seq=" << m2->sequenceNo << endl;

    auto missed = chatService.reconnect(carol, 0);
    cout << "Carol missed " << missed.size() << " messages, first content='" << missed[0]->content << "'" << endl;

    auto replay = chatService.reconnect(carol, (long long) missed.size());
    cout << "Carol replay after ack: " << replay.size() << " messages (expect 0)" << endl;

    m1->markRead("bob");
    cout << "Bob's receipt for m1 after reading: " << m1->receipts["bob"]->name() << endl;

    return 0;
}

// Problem 20: Chat Application (WhatsApp-style)
// Patterns: Mediator + Observer (Conversation), State (MessageStatus per recipient), Facade (ChatService)

// ---------- User ----------
class User {
  constructor(id) { this.id = id; this.connectedDevices = new Set(); }
}

// ---------- MessageStatus (per-recipient state machine) ----------
class SentStatus {
  onDelivered() { return new DeliveredStatus(); }
  onRead() { throw new Error('Must be delivered before read'); }
  name() { return 'SENT'; }
}
class DeliveredStatus {
  onDelivered() { return this; }
  onRead() { return new ReadStatus(); }
  name() { return 'DELIVERED'; }
}
class ReadStatus {
  onDelivered() { return this; }
  onRead() { return this; }
  name() { return 'READ'; }
}

// ---------- Message ----------
class Message {
  constructor(sender, content, sequenceNo, recipients) {
    this.sender = sender; this.content = content; this.sequenceNo = sequenceNo;
    this.receipts = new Map(); // recipientId -> status
    for (const r of recipients) this.receipts.set(r.id, new SentStatus());
  }
  markDelivered(userId) {
    if (this.receipts.has(userId)) this.receipts.set(userId, this.receipts.get(userId).onDelivered());
  }
  markRead(userId) {
    if (this.receipts.has(userId)) this.receipts.set(userId, this.receipts.get(userId).onRead());
  }
}

// ---------- PresenceTracker ----------
class PresenceTracker {
  constructor() { this.connectedDeviceIds = new Map(); }
  deviceConnected(userId, deviceId) {
    if (!this.connectedDeviceIds.has(userId)) this.connectedDeviceIds.set(userId, new Set());
    this.connectedDeviceIds.get(userId).add(deviceId);
  }
  deviceDisconnected(userId, deviceId) {
    const devices = this.connectedDeviceIds.get(userId);
    if (devices) devices.delete(deviceId);
  }
  isOnline(userId) {
    const devices = this.connectedDeviceIds.get(userId);
    return !!devices && devices.size > 0;
  }
}

// Simple per-user append-only log of messages missed while offline.
// NOTE (interview-scale simplification): the cursor passed to reconnect() is treated as an
// index into this per-user queue (not the message's own per-conversation sequenceNo), since
// a user's offline queue spans multiple conversations whose sequence numbers aren't
// comparable to each other. Same cursor -> same slice, so replay is idempotent.
class OfflineQueue {
  constructor() { this.messages = []; }
  enqueue(m) { this.messages.push(m); }
  allAfter(cursor) {
    const from = Math.min(cursor, this.messages.length);
    return this.messages.slice(from);
  }
  clearUpTo(cursor) {
    const upTo = Math.min(cursor, this.messages.length);
    this.messages.splice(0, upTo);
  }
}

// ---------- Conversation (Mediator + Observer subject) ----------
class Conversation {
  constructor(id, presenceTracker, offlineQueues) {
    this.id = id;
    this.participants = [];
    this.messages = [];
    this.nextSequence = 0;
    this.presenceTracker = presenceTracker;
    this.offlineQueues = offlineQueues; // shared Map reference, owned by ChatService
  }

  addParticipant(user) {
    if (!this.participants.includes(user)) this.participants.push(user);
  }

  send(sender, content) {
    const seq = ++this.nextSequence; // server-assigned, monotonic per conversation
    const recipients = this.participants.filter(p => p.id !== sender.id);
    const message = new Message(sender, content, seq, recipients);
    this.messages.push(message);

    for (const participant of recipients) { // Observer fan-out
      if (this.presenceTracker.isOnline(participant.id)) {
        message.markDelivered(participant.id);
      } else {
        if (!this.offlineQueues.has(participant.id)) this.offlineQueues.set(participant.id, new OfflineQueue());
        this.offlineQueues.get(participant.id).enqueue(message);
      }
    }
    return message;
  }
}

class DirectConversation extends Conversation {
  constructor(id, a, b, presenceTracker, offlineQueues) {
    super(id, presenceTracker, offlineQueues);
    this.participants.push(a, b);
  }
  addParticipant() { throw new Error('DirectConversation is fixed at 2 participants'); }
}

class GroupConversation extends Conversation {
  constructor(id, initialParticipants, presenceTracker, offlineQueues) {
    super(id, presenceTracker, offlineQueues);
    this.participants.push(...initialParticipants);
  }
  removeParticipant(user) { this.participants = this.participants.filter(p => p !== user); }
}

// ---------- ChatService (Facade) ----------
class ChatService {
  constructor() {
    this.presenceTracker = new PresenceTracker();
    this.offlineQueues = new Map();
    this.nextConversationId = 1;
  }

  createDirectConversation(a, b) {
    return new DirectConversation(`C${this.nextConversationId++}`, a, b, this.presenceTracker, this.offlineQueues);
  }

  createGroupConversation(participants) {
    return new GroupConversation(`C${this.nextConversationId++}`, participants, this.presenceTracker, this.offlineQueues);
  }

  sendMessage(sender, conversation, content) {
    return conversation.send(sender, content);
  }

  // Exactly-once replay: client passes back the cursor from its last successful reconnect.
  reconnect(user, lastSeenSequence) {
    if (!this.offlineQueues.has(user.id)) this.offlineQueues.set(user.id, new OfflineQueue());
    const queue = this.offlineQueues.get(user.id);
    const missed = queue.allAfter(lastSeenSequence);
    queue.clearUpTo(lastSeenSequence + missed.length);
    for (const m of missed) m.markDelivered(user.id);
    return missed;
  }
}

// ---------- Demo ----------
function main() {
  const chatService = new ChatService();
  const alice = new User('alice');
  const bob = new User('bob');
  const carol = new User('carol');

  chatService.presenceTracker.deviceConnected('alice', 'alice-phone');
  chatService.presenceTracker.deviceConnected('bob', 'bob-laptop');
  // carol is offline (no connected device)

  const group = chatService.createGroupConversation([alice, bob, carol]);

  const m1 = chatService.sendMessage(alice, group, 'Hello everyone!');
  console.log(`Sent seq=${m1.sequenceNo} bob receipt=${m1.receipts.get('bob').name()} carol receipt=${m1.receipts.get('carol').name()}`);

  const m2 = chatService.sendMessage(bob, group, 'Hi Alice!');
  console.log(`Sent seq=${m2.sequenceNo}`);

  const missed = chatService.reconnect(carol, 0);
  console.log(`Carol missed ${missed.length} messages, first content='${missed[0].content}'`);

  const replay = chatService.reconnect(carol, missed.length);
  console.log(`Carol replay after ack: ${replay.length} messages (expect 0)`);

  m1.markRead('bob');
  console.log(`Bob's receipt for m1 after reading: ${m1.receipts.get('bob').name()}`);
}

if (require.main === module) main();

module.exports = {
  User, SentStatus, DeliveredStatus, ReadStatus, Message, PresenceTracker,
  OfflineQueue, Conversation, DirectConversation, GroupConversation, ChatService,
};

// Problem 20: Chat Application (WhatsApp-style)
// Patterns: Mediator + Observer (Conversation), State (MessageStatus per recipient), Facade (ChatService)

// ---------- User ----------
class User {
  connectedDevices: Set<string> = new Set();
  constructor(public id: string) {}
}

// ---------- MessageStatus (per-recipient state machine) ----------
interface MessageStatus {
  onDelivered(): MessageStatus;
  onRead(): MessageStatus;
  name(): string;
}

class SentStatus implements MessageStatus {
  onDelivered(): MessageStatus { return new DeliveredStatus(); }
  onRead(): MessageStatus { throw new Error('Must be delivered before read'); }
  name(): string { return 'SENT'; }
}
class DeliveredStatus implements MessageStatus {
  onDelivered(): MessageStatus { return this; }
  onRead(): MessageStatus { return new ReadStatus(); }
  name(): string { return 'DELIVERED'; }
}
class ReadStatus implements MessageStatus {
  onDelivered(): MessageStatus { return this; }
  onRead(): MessageStatus { return this; }
  name(): string { return 'READ'; }
}

// ---------- Message ----------
class Message {
  readonly receipts = new Map<string, MessageStatus>(); // recipientId -> status

  constructor(public sender: User, public content: string, public sequenceNo: number, recipients: User[]) {
    for (const r of recipients) this.receipts.set(r.id, new SentStatus());
  }

  markDelivered(userId: string): void {
    const status = this.receipts.get(userId);
    if (status) this.receipts.set(userId, status.onDelivered());
  }
  markRead(userId: string): void {
    const status = this.receipts.get(userId);
    if (status) this.receipts.set(userId, status.onRead());
  }
}

// ---------- PresenceTracker ----------
class PresenceTracker {
  private connectedDeviceIds = new Map<string, Set<string>>();

  deviceConnected(userId: string, deviceId: string): void {
    if (!this.connectedDeviceIds.has(userId)) this.connectedDeviceIds.set(userId, new Set());
    this.connectedDeviceIds.get(userId)!.add(deviceId);
  }
  deviceDisconnected(userId: string, deviceId: string): void {
    this.connectedDeviceIds.get(userId)?.delete(deviceId);
  }
  isOnline(userId: string): boolean {
    const devices = this.connectedDeviceIds.get(userId);
    return !!devices && devices.size > 0;
  }
}

// Simple per-user append-only log of messages missed while offline.
// NOTE (interview-scale simplification): the cursor passed to reconnect() is treated as an
// index into this per-user queue (not the message's own per-conversation sequenceNo), since
// a user's offline queue spans multiple conversations whose sequence numbers aren't
// comparable to each other. Same cursor -> same slice, so replay is idempotent.
class OfflineQueue {
  private messages: Message[] = [];
  enqueue(m: Message): void { this.messages.push(m); }
  allAfter(cursor: number): Message[] {
    const from = Math.min(cursor, this.messages.length);
    return this.messages.slice(from);
  }
  clearUpTo(cursor: number): void {
    const upTo = Math.min(cursor, this.messages.length);
    this.messages.splice(0, upTo);
  }
}

// ---------- Conversation (Mediator + Observer subject) ----------
abstract class Conversation {
  participants: User[] = [];
  messages: Message[] = [];
  nextSequence = 0;

  constructor(
    public readonly id: string,
    protected presenceTracker: PresenceTracker,
    protected offlineQueues: Map<string, OfflineQueue>, // shared reference, owned by ChatService
  ) {}

  addParticipant(user: User): void {
    if (!this.participants.includes(user)) this.participants.push(user);
  }

  send(sender: User, content: string): Message {
    const seq = ++this.nextSequence; // server-assigned, monotonic per conversation
    const recipients = this.participants.filter(p => p.id !== sender.id);
    const message = new Message(sender, content, seq, recipients);
    this.messages.push(message);

    for (const participant of recipients) { // Observer fan-out
      if (this.presenceTracker.isOnline(participant.id)) {
        message.markDelivered(participant.id);
      } else {
        if (!this.offlineQueues.has(participant.id)) this.offlineQueues.set(participant.id, new OfflineQueue());
        this.offlineQueues.get(participant.id)!.enqueue(message);
      }
    }
    return message;
  }
}

class DirectConversation extends Conversation {
  constructor(id: string, a: User, b: User, presenceTracker: PresenceTracker, offlineQueues: Map<string, OfflineQueue>) {
    super(id, presenceTracker, offlineQueues);
    this.participants.push(a, b);
  }
  override addParticipant(_user: User): void { throw new Error('DirectConversation is fixed at 2 participants'); }
}

class GroupConversation extends Conversation {
  constructor(id: string, initialParticipants: User[], presenceTracker: PresenceTracker, offlineQueues: Map<string, OfflineQueue>) {
    super(id, presenceTracker, offlineQueues);
    this.participants.push(...initialParticipants);
  }
  removeParticipant(user: User): void { this.participants = this.participants.filter(p => p !== user); }
}

// ---------- ChatService (Facade) ----------
class ChatService {
  readonly presenceTracker = new PresenceTracker();
  private offlineQueues = new Map<string, OfflineQueue>();
  private nextConversationId = 1;

  createDirectConversation(a: User, b: User): DirectConversation {
    return new DirectConversation(`C${this.nextConversationId++}`, a, b, this.presenceTracker, this.offlineQueues);
  }

  createGroupConversation(participants: User[]): GroupConversation {
    return new GroupConversation(`C${this.nextConversationId++}`, participants, this.presenceTracker, this.offlineQueues);
  }

  sendMessage(sender: User, conversation: Conversation, content: string): Message {
    return conversation.send(sender, content);
  }

  // Exactly-once replay: client passes back the cursor from its last successful reconnect.
  reconnect(user: User, lastSeenSequence: number): Message[] {
    if (!this.offlineQueues.has(user.id)) this.offlineQueues.set(user.id, new OfflineQueue());
    const queue = this.offlineQueues.get(user.id)!;
    const missed = queue.allAfter(lastSeenSequence);
    queue.clearUpTo(lastSeenSequence + missed.length);
    for (const m of missed) m.markDelivered(user.id);
    return missed;
  }
}

// ---------- Demo ----------
function main(): void {
  const chatService = new ChatService();
  const alice = new User('alice');
  const bob = new User('bob');
  const carol = new User('carol');

  chatService.presenceTracker.deviceConnected('alice', 'alice-phone');
  chatService.presenceTracker.deviceConnected('bob', 'bob-laptop');
  // carol is offline (no connected device)

  const group = chatService.createGroupConversation([alice, bob, carol]);

  const m1 = chatService.sendMessage(alice, group, 'Hello everyone!');
  console.log(`Sent seq=${m1.sequenceNo} bob receipt=${m1.receipts.get('bob')!.name()} carol receipt=${m1.receipts.get('carol')!.name()}`);

  const m2 = chatService.sendMessage(bob, group, 'Hi Alice!');
  console.log(`Sent seq=${m2.sequenceNo}`);

  const missed = chatService.reconnect(carol, 0);
  console.log(`Carol missed ${missed.length} messages, first content='${missed[0].content}'`);

  const replay = chatService.reconnect(carol, missed.length);
  console.log(`Carol replay after ack: ${replay.length} messages (expect 0)`);

  m1.markRead('bob');
  console.log(`Bob's receipt for m1 after reading: ${m1.receipts.get('bob')!.name()}`);
}

main();

export {
  User, MessageStatus, SentStatus, DeliveredStatus, ReadStatus, Message, PresenceTracker,
  OfflineQueue, Conversation, DirectConversation, GroupConversation, ChatService,
};