lynkeduppro-crm/src/lib/crm-messaging-adapter.ts

// The CRM's implementation of the SDK's MessagingAdapter. HYBRID transport:
//   • BFF (appshell crm.messenger.*) for the conversation list, thread creation, and directory
//     — these need server-side tenancy/auth.
//   • IIOS MessageSocket (delegated token from crm.messenger.realtime) for everything live:
//     history+join, send, typing, read receipts, reactions.
// When no socket is available (token failed / demo), it degrades to a 4s history poll.

import type {
  Conversation,
  Membership,
  Message,
  MessageEvent,
  MessagingAdapter,
  Reaction,
  SendOpts,
  Unsubscribe,
} from "@insignia/iios-messaging-ui";
import type { MessageSocket, Message as KernelMessage } from "@insignia/iios-kernel-client";

/** The imperative appshell data door (useAppShell().sdk). Typed structurally, not to its class. */
export interface DataDoor {
  query<T>(action: string, variables?: Record<string, unknown>): Promise<T>;
  command<T>(action: string, variables?: Record<string, unknown>): Promise<T>;
}

interface DirectoryDTO { id: string; displayName: string; kind: "staff" | "customer" }
interface ConversationDTO {
  threadId: string; subject: string | null; membership: Membership | null;
  participants: string[]; unread: number; lastMessage?: string; lastAt?: string;
}
interface MessageDTO { interactionId: string; actorId: string | null; kind: string; occurredAt: string; text: string | null }

const POLL_MS = 4000;
const REACTION = "reaction";

interface Poll { seen: Set<string>; primed: boolean; timer: ReturnType<typeof setInterval> | null }

export class CrmMessagingAdapter implements MessagingAdapter {
  private names: Map<string, string> | null = null;
  private readonly listeners = new Map<string, Set<(e: MessageEvent) => void>>();
  private readonly polls = new Map<string, Poll>();
  private readonly joined = new Set<string>();
  /** messageId → emoji → userSet, so a single annotation delta can be re-emitted as a full set. */
  private readonly reactions = new Map<string, Map<string, Set<string>>>();

  /** Only present with a socket — the UI hides the reaction affordance without it. */
  react?: (threadId: string, messageId: string, emoji: string) => Promise<void>;

  constructor(
    private readonly sdk: DataDoor,
    private readonly me: string,
    private readonly socket?: MessageSocket,
  ) {
    if (socket) {
      socket.on("message", (m) => {
        this.ingestReactions(m);
        this.emit(m.threadId, { kind: "message", message: this.fromKernel(m) });
      });
      socket.on("typing", (e) => this.emit(e.threadId, { kind: "typing", userId: e.userId }));
      // Receipts carry no threadId → fan to all open threads; the UI filters by messageId.
      socket.on("receipt", (e) => this.broadcast({ kind: "receipt", messageId: e.interactionId, actorId: e.actorId }));
      socket.on("annotation", (e) => {
        if (e.type !== REACTION) return;
        this.setReactionUsers(e.interactionId, e.value, e.users);
        this.emit(e.threadId, { kind: "reaction", messageId: e.interactionId, reactions: this.reactionsOf(e.interactionId) });
      });
      this.react = async (threadId, messageId, emoji) => {
        await socket.react(threadId, messageId, emoji);
      };
    }
  }

  currentActorId(): string {
    return this.me;
  }

  async listConversations(): Promise<Conversation[]> {
    const [convs, names] = await Promise.all([
      this.sdk.query<ConversationDTO[]>("crm.messenger.conversation.list", {}),
      this.directory(),
    ]);
    return convs.map((c) => this.toConversation(c, names));
  }

  async openThread(p: { participantIds: string[]; membership?: Membership; subject?: string }): Promise<{ threadId: string }> {
    const res = await this.sdk.command<{ threadId: string }>("crm.messenger.conversation.open", {
      participantIds: p.participantIds,
      ...(p.membership ? { membership: p.membership } : {}),
      ...(p.subject ? { subject: p.subject } : {}),
    });
    return { threadId: res.threadId };
  }

  async history(threadId: string): Promise<Message[]> {
    if (this.socket) {
      const res = await this.socket.openThread(threadId); // joins so live events flow
      this.joined.add(threadId);
      return res.history.map((m) => {
        this.ingestReactions(m);
        return this.fromKernel(m);
      });
    }
    const msgs = await this.sdk.query<MessageDTO[]>("crm.messenger.history", { threadId });
    return msgs.map((m) => this.fromDto(m));
  }

  async send(threadId: string, content: string, opts?: SendOpts): Promise<Message> {
    if (this.socket) {
      const m = await this.socket.sendMessage(
        threadId,
        content,
        opts?.parentInteractionId ? { parentInteractionId: opts.parentInteractionId } : undefined,
      );
      return this.fromKernel(m);
    }
    const m = await this.sdk.command<MessageDTO>("crm.messenger.send", { threadId, content });
    const msg = this.fromDto(m);
    this.polls.get(threadId)?.seen.add(msg.id);
    return msg;
  }

  subscribe(threadId: string, cb: (e: MessageEvent) => void): Unsubscribe {
    if (!this.listeners.has(threadId)) this.listeners.set(threadId, new Set());
    this.listeners.get(threadId)!.add(cb);

    if (this.socket) {
      if (!this.joined.has(threadId)) {
        this.joined.add(threadId);
        void this.socket.openThread(threadId).catch(() => this.joined.delete(threadId));
      }
    } else {
      this.startPoll(threadId);
    }

    return () => {
      const set = this.listeners.get(threadId);
      set?.delete(cb);
      if (set && set.size === 0) {
        this.listeners.delete(threadId);
        const poll = this.polls.get(threadId);
        if (poll?.timer) clearInterval(poll.timer);
        this.polls.delete(threadId);
      }
    };
  }

  sendTyping(threadId: string): void {
    this.socket?.typing(threadId);
  }

  async markRead(threadId: string, messageId: string): Promise<void> {
    if (this.socket) await this.socket.markRead(threadId, messageId);
  }

  // ── polling fallback (no socket) ───────────────────────────────
  private startPoll(threadId: string): void {
    if (this.polls.has(threadId)) return;
    const poll: Poll = { seen: new Set(), primed: false, timer: null };
    this.polls.set(threadId, poll);
    const tick = async (): Promise<void> => {
      if (!this.polls.has(threadId)) return;
      try {
        const msgs = await this.sdk.query<MessageDTO[]>("crm.messenger.history", { threadId });
        for (const m of msgs) {
          if (poll.seen.has(m.interactionId)) continue;
          poll.seen.add(m.interactionId);
          if (poll.primed) this.emit(threadId, { kind: "message", message: this.fromDto(m) });
        }
        poll.primed = true;
      } catch {
        /* transient — retry next tick */
      }
    };
    void tick();
    poll.timer = setInterval(tick, POLL_MS);
  }

  // ── mapping ────────────────────────────────────────────────────
  private async directory(): Promise<Map<string, string>> {
    if (!this.names) {
      const dir = await this.sdk.query<DirectoryDTO[]>("crm.messenger.directory", { kind: "all", limit: 200 });
      this.names = new Map(dir.map((d) => [d.id, d.displayName]));
    }
    return this.names;
  }

  private toConversation(c: ConversationDTO, names: Map<string, string>): Conversation {
    const others = c.participants.filter((p) => p !== this.me);
    const title = c.subject?.trim() || others.map((id) => names.get(id) ?? id).join(", ") || "Conversation";
    return {
      threadId: c.threadId,
      title,
      subject: c.subject,
      membership: c.membership,
      participants: c.participants,
      unread: c.unread,
      ...(c.lastMessage ? { lastMessage: c.lastMessage } : {}),
      ...(c.lastAt ? { lastAt: c.lastAt } : {}),
    };
  }

  /** Kernel Message (socket) → SDK Message. actorId = senderId (userId space), matching currentActorId. */
  private fromKernel(m: KernelMessage): Message {
    return {
      id: m.id,
      actorId: m.senderId ?? null,
      text: m.content ?? "",
      at: m.createdAt,
      parentInteractionId: m.parentInteractionId ?? null,
      reactions: this.reactionsOf(m.id),
    };
  }

  /** BFF DTO (poll fallback) → SDK Message. Note: actorId is IIOS actor-id space here. */
  private fromDto(m: MessageDTO): Message {
    return { id: m.interactionId, actorId: m.actorId, text: m.text ?? "", at: m.occurredAt };
  }

  // ── reaction state ─────────────────────────────────────────────
  private ingestReactions(m: KernelMessage): void {
    for (const a of m.annotations ?? []) {
      if (a.type === REACTION) this.setReactionUsers(m.id, a.value, a.users);
    }
  }

  private setReactionUsers(messageId: string, emoji: string, users: string[]): void {
    let byEmoji = this.reactions.get(messageId);
    if (!byEmoji) {
      byEmoji = new Map();
      this.reactions.set(messageId, byEmoji);
    }
    if (users.length === 0) byEmoji.delete(emoji);
    else byEmoji.set(emoji, new Set(users));
  }

  private reactionsOf(messageId: string): Reaction[] {
    const byEmoji = this.reactions.get(messageId);
    if (!byEmoji) return [];
    const out: Reaction[] = [];
    for (const [emoji, users] of byEmoji) {
      if (users.size > 0) out.push({ emoji, count: users.size, mine: users.has(this.me) });
    }
    return out;
  }

  // ── event fan-out ──────────────────────────────────────────────
  private emit(threadId: string, e: MessageEvent): void {
    this.listeners.get(threadId)?.forEach((cb) => cb(e));
  }

  private broadcast(e: MessageEvent): void {
    for (const set of this.listeners.values()) set.forEach((cb) => cb(e));
  }
}