type TabRegistryEntry = {
  tabId: string;
  connectionId: string;
  sessionId?: string;
  userIdHash?: string;
  appVersion: string;
  protocolVersion: number;
  route: string;
  visibility: DocumentVisibilityState | "unknown";
  lifecycleState: "active" | "passive" | "hidden" | "frozen-ish" | "unloading" | "unknown";
  role: "normal" | "candidate" | "leader" | "observer";
  capabilities: {
    broadcastChannel: boolean;
    webLocks: boolean;
    sharedWorker: boolean;
    serviceWorker: boolean;
    indexedDB: boolean;
  };
  startedAt: number;
  lastSeenAt: number;
  expiresAt: number;
};

const TAB_ID_KEY = "app:tab-id";

export function getOrCreateTabId(): string {
  const existing = sessionStorage.getItem(TAB_ID_KEY);
  if (existing) return existing;

  const id = crypto.randomUUID();
  sessionStorage.setItem(TAB_ID_KEY, id);
  return id;
}

export function createConnectionId(): string {
  return crypto.randomUUID();
}

type RegistryKey = `${string}:${string}`; // tabId:connectionId

type PresenceMessage =
  | {
      type: "TAB_HELLO";
      messageId: string;
      sender: TabRegistryEntry;
      sentAt: number;
    }
  | {
      type: "TAB_HEARTBEAT";
      messageId: string;
      tabId: string;
      connectionId: string;
      patch: Partial<Pick<TabRegistryEntry,
        "route" | "visibility" | "lifecycleState" | "role" | "lastSeenAt" | "expiresAt"
      >>;
      sentAt: number;
    }
  | {
      type: "TAB_BYE";
      messageId: string;
      tabId: string;
      connectionId: string;
      reason: "pagehide" | "beforeunload" | "logout" | "manual";
      sentAt: number;
    }
  | {
      type: "TAB_QUERY";
      messageId: string;
      requester: { tabId: string; connectionId: string };
      sentAt: number;
    }
  | {
      type: "TAB_SNAPSHOT";
      messageId: string;
      sender: { tabId: string; connectionId: string };
      entries: TabRegistryEntry[];
      sentAt: number;
    };

const HEARTBEAT_INTERVAL_MS = 5_000;
const PRESENCE_TTL_MS = 15_000;
const SUSPECT_AFTER_MS = 8_000;
const SWEEP_INTERVAL_MS = 5_000;

function classifyEntry(entry: TabRegistryEntry, now = Date.now()) {
  const age = now - entry.lastSeenAt;

  if (now > entry.expiresAt) return "expired";
  if (age > SUSPECT_AFTER_MS) return "suspect";
  return "present";
}

const CHANNEL_NAME = "app:presence:v1";

type Listener<T> = (message: T) => void;

export class PresenceBus<TMessage> {
  private channel?: BroadcastChannel;
  private listeners = new Set<Listener<TMessage>>();

  constructor(private readonly name = CHANNEL_NAME) {}

  start() {
    if (!("BroadcastChannel" in globalThis)) {
      throw new Error("BroadcastChannel unavailable");
    }

    this.channel = new BroadcastChannel(this.name);
    this.channel.addEventListener("message", (event) => {
      for (const listener of this.listeners) {
        listener(event.data as TMessage);
      }
    });

    this.channel.addEventListener("messageerror", () => {
      // Increment metric. Do not crash the app.
    });
  }

  subscribe(listener: Listener<TMessage>) {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  publish(message: TMessage) {
    this.channel?.postMessage(message);
  }

  close() {
    this.channel?.close();
    this.channel = undefined;
    this.listeners.clear();
  }
}

type RegistryEvent =
  | { type: "entry-upserted"; entry: TabRegistryEntry }
  | { type: "entry-removed"; tabId: string; connectionId: string; reason: string }
  | { type: "snapshot-changed"; entries: TabRegistryEntry[] };

type RegistryListener = (event: RegistryEvent) => void;

export class TabRegistry {
  private entries = new Map<string, TabRegistryEntry>();
  private seenMessages = new Set<string>();
  private listeners = new Set<RegistryListener>();

  constructor(
    private readonly self: TabRegistryEntry,
    private readonly bus: PresenceBus<PresenceMessage>
  ) {}

  start() {
    this.bus.subscribe((message) => this.onMessage(message));
    this.upsert(this.self);
    this.hello();
    this.query();
  }

  subscribe(listener: RegistryListener) {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  snapshot(now = Date.now()): TabRegistryEntry[] {
    return [...this.entries.values()]
      .filter((entry) => entry.expiresAt > now)
      .sort((a, b) => a.startedAt - b.startedAt);
  }

  hello() {
    this.bus.publish({
      type: "TAB_HELLO",
      messageId: crypto.randomUUID(),
      sender: this.self,
      sentAt: Date.now()
    });
  }

  heartbeat(patch: PresenceMessage extends never ? never : Partial<TabRegistryEntry> = {}) {
    const now = Date.now();

    this.self.lastSeenAt = now;
    this.self.expiresAt = now + PRESENCE_TTL_MS;
    Object.assign(this.self, patch);

    this.upsert(this.self);

    this.bus.publish({
      type: "TAB_HEARTBEAT",
      messageId: crypto.randomUUID(),
      tabId: this.self.tabId,
      connectionId: this.self.connectionId,
      patch: {
        route: this.self.route,
        visibility: this.self.visibility,
        lifecycleState: this.self.lifecycleState,
        role: this.self.role,
        lastSeenAt: this.self.lastSeenAt,
        expiresAt: this.self.expiresAt
      },
      sentAt: now
    });
  }

  bye(reason: "pagehide" | "beforeunload" | "logout" | "manual") {
    this.bus.publish({
      type: "TAB_BYE",
      messageId: crypto.randomUUID(),
      tabId: this.self.tabId,
      connectionId: this.self.connectionId,
      reason,
      sentAt: Date.now()
    });
  }

  query() {
    this.bus.publish({
      type: "TAB_QUERY",
      messageId: crypto.randomUUID(),
      requester: {
        tabId: this.self.tabId,
        connectionId: this.self.connectionId
      },
      sentAt: Date.now()
    });
  }

  sweep(now = Date.now()) {
    for (const [key, entry] of this.entries) {
      if (entry.expiresAt <= now) {
        this.entries.delete(key);
        this.emit({
          type: "entry-removed",
          tabId: entry.tabId,
          connectionId: entry.connectionId,
          reason: "expired"
        });
      }
    }

    this.emit({ type: "snapshot-changed", entries: this.snapshot(now) });
  }

  private onMessage(message: PresenceMessage) {
    if (this.seenMessages.has(message.messageId)) return;
    this.seenMessages.add(message.messageId);

    switch (message.type) {
      case "TAB_HELLO":
        this.upsert(message.sender);
        this.sendSnapshot();
        return;

      case "TAB_HEARTBEAT":
        this.applyHeartbeat(message);
        return;

      case "TAB_BYE":
        this.remove(message.tabId, message.connectionId, message.reason);
        return;

      case "TAB_QUERY":
        if (message.requester.connectionId !== this.self.connectionId) {
          this.sendSnapshot();
        }
        return;

      case "TAB_SNAPSHOT":
        for (const entry of message.entries) {
          this.upsert(entry);
        }
        return;
    }
  }

  private applyHeartbeat(message: Extract<PresenceMessage, { type: "TAB_HEARTBEAT" }>) {
    const key = this.key(message.tabId, message.connectionId);
    const existing = this.entries.get(key);

    if (!existing) {
      this.upsert({
        tabId: message.tabId,
        connectionId: message.connectionId,
        sessionId: undefined,
        appVersion: "unknown",
        protocolVersion: 1,
        route: message.patch.route ?? "unknown",
        visibility: message.patch.visibility ?? "unknown",
        lifecycleState: message.patch.lifecycleState ?? "unknown",
        role: message.patch.role ?? "normal",
        capabilities: {
          broadcastChannel: true,
          webLocks: false,
          sharedWorker: false,
          serviceWorker: false,
          indexedDB: false
        },
        startedAt: message.sentAt,
        lastSeenAt: message.patch.lastSeenAt ?? message.sentAt,
        expiresAt: message.patch.expiresAt ?? message.sentAt + PRESENCE_TTL_MS
      });
      return;
    }

    const next = { ...existing, ...message.patch };
    if ((next.lastSeenAt ?? 0) < existing.lastSeenAt) return;

    this.upsert(next);
  }

  private sendSnapshot() {
    this.bus.publish({
      type: "TAB_SNAPSHOT",
      messageId: crypto.randomUUID(),
      sender: {
        tabId: this.self.tabId,
        connectionId: this.self.connectionId
      },
      entries: this.snapshot(),
      sentAt: Date.now()
    });
  }

  private upsert(entry: TabRegistryEntry) {
    if (entry.protocolVersion !== this.self.protocolVersion) {
      // In production, record version skew metric.
      return;
    }

    const key = this.key(entry.tabId, entry.connectionId);
    const existing = this.entries.get(key);

    if (existing && existing.lastSeenAt > entry.lastSeenAt) {
      return;
    }

    this.entries.set(key, entry);
    this.emit({ type: "entry-upserted", entry });
    this.emit({ type: "snapshot-changed", entries: this.snapshot() });
  }

  private remove(tabId: string, connectionId: string, reason: string) {
    const key = this.key(tabId, connectionId);
    if (!this.entries.delete(key)) return;

    this.emit({ type: "entry-removed", tabId, connectionId, reason });
    this.emit({ type: "snapshot-changed", entries: this.snapshot() });
  }

  private key(tabId: string, connectionId: string) {
    return `${tabId}:${connectionId}`;
  }

  private emit(event: RegistryEvent) {
    for (const listener of this.listeners) listener(event);
  }
}

function readVisibility(): DocumentVisibilityState | "unknown" {
  if (typeof document === "undefined") return "unknown";
  return document.visibilityState;
}

function inferLifecycleState(): TabRegistryEntry["lifecycleState"] {
  if (document.visibilityState === "visible") return "active";
  if (document.visibilityState === "hidden") return "hidden";
  return "unknown";
}

export function attachLifecyclePresence(registry: TabRegistry) {
  document.addEventListener("visibilitychange", () => {
    registry.heartbeat({
      visibility: readVisibility(),
      lifecycleState: inferLifecycleState()
    });
  });

  window.addEventListener("pageshow", () => {
    registry.hello();
    registry.heartbeat({
      visibility: readVisibility(),
      lifecycleState: inferLifecycleState()
    });
    registry.query();
  });

  window.addEventListener("pagehide", () => {
    registry.bye("pagehide");
  });

  window.addEventListener("beforeunload", () => {
    registry.bye("beforeunload");
  });
}

export function startPresenceLoop(registry: TabRegistry) {
  const heartbeatTimer = window.setInterval(() => {
    registry.heartbeat({
      visibility: readVisibility(),
      lifecycleState: inferLifecycleState()
    });
  }, HEARTBEAT_INTERVAL_MS);

  const sweepTimer = window.setInterval(() => {
    registry.sweep();
  }, SWEEP_INTERVAL_MS);

  return () => {
    clearInterval(heartbeatTimer);
    clearInterval(sweepTimer);
    registry.bye("manual");
  };
}

const SNAPSHOT_KEY = "app:tab-registry:snapshot:v1";

type DurableRegistrySnapshot = {
  writtenAt: number;
  writer: { tabId: string; connectionId: string };
  entries: TabRegistryEntry[];
};

export function writeRegistrySnapshot(
  writer: { tabId: string; connectionId: string },
  entries: TabRegistryEntry[]
) {
  const now = Date.now();

  const snapshot: DurableRegistrySnapshot = {
    writtenAt: now,
    writer,
    entries: entries.filter((entry) => entry.expiresAt > now)
  };

  localStorage.setItem(SNAPSHOT_KEY, JSON.stringify(snapshot));
}

export function readRegistrySnapshot(): DurableRegistrySnapshot | undefined {
  const raw = localStorage.getItem(SNAPSHOT_KEY);
  if (!raw) return undefined;

  try {
    const snapshot = JSON.parse(raw) as DurableRegistrySnapshot;
    const now = Date.now();

    return {
      ...snapshot,
      entries: snapshot.entries.filter((entry) => entry.expiresAt > now)
    };
  } catch {
    return undefined;
  }
}

function throttle<TArgs extends unknown[]>(fn: (...args: TArgs) => void, ms: number) {
  let last = 0;
  let timer: number | undefined;

  return (...args: TArgs) => {
    const now = Date.now();
    const remaining = ms - (now - last);

    if (remaining <= 0) {
      last = now;
      fn(...args);
      return;
    }

    window.clearTimeout(timer);
    timer = window.setTimeout(() => {
      last = Date.now();
      fn(...args);
    }, remaining);
  };
}

type LogicalTabView = {
  tabId: string;
  activeConnections: TabRegistryEntry[];
  latest: TabRegistryEntry;
};

function groupByLogicalTab(entries: TabRegistryEntry[]): LogicalTabView[] {
  const groups = new Map<string, TabRegistryEntry[]>();

  for (const entry of entries) {
    const group = groups.get(entry.tabId) ?? [];
    group.push(entry);
    groups.set(entry.tabId, group);
  }

  return [...groups.entries()].map(([tabId, activeConnections]) => {
    const latest = activeConnections.reduce((a, b) =>
      a.lastSeenAt > b.lastSeenAt ? a : b
    );

    return { tabId, activeConnections, latest };
  });
}

{
  type: "TAB_HEARTBEAT",
  route: "/cases/ENF-2026-000123/suspects/999",
  userEmail: "person@example.com"
}

{
  type: "TAB_HEARTBEAT",
  route: "case-detail",
  userIdHash: "u:sha256:..."
}

function chooseNotificationTab(entries: TabRegistryEntry[]) {
  return entries
    .filter((entry) => entry.visibility === "visible")
    .sort((a, b) => a.startedAt - b.startedAt)[0];
}

function scoreLeaderCandidate(entry: TabRegistryEntry) {
  let score = 0;

  if (entry.visibility === "visible") score += 20;
  if (entry.lifecycleState === "active") score += 20;
  if (entry.capabilities.webLocks) score += 30;
  if (entry.capabilities.indexedDB) score += 10;
  if (entry.role === "leader") score -= 5; // avoid sticky leadership if desired

  score -= Math.min(20, Math.floor((Date.now() - entry.lastSeenAt) / 1000));

  return score;
}

registry.heartbeat({
  route: "case-edit",
  lifecycleState: inferLifecycleState()
});

export function debugPresenceSnapshot(registry: TabRegistry) {
  return registry.snapshot().map((entry) => ({
    tabId: entry.tabId.slice(0, 8),
    connectionId: entry.connectionId.slice(0, 8),
    route: entry.route,
    visibility: entry.visibility,
    lifecycleState: entry.lifecycleState,
    role: entry.role,
    ageMs: Date.now() - entry.lastSeenAt,
    expiresInMs: entry.expiresAt - Date.now(),
    appVersion: entry.appVersion,
    protocolVersion: entry.protocolVersion
  }));
}

test("two tabs discover each other", async ({ browser }) => {
  const context = await browser.newContext();
  const a = await context.newPage();
  const b = await context.newPage();

  await a.goto(appUrl);
  await b.goto(appUrl);

  await expect.poll(async () => {
    return await a.evaluate(() => window.__presenceDebug().length);
  }).toBeGreaterThanOrEqual(2);
});