/**
 * LiveMesh (M3b): connection lifecycle for the RoomHub's ONE shared libp2p
 * node. The hub assembles the node with the full browser transport set
 * (websockets + webRTC + circuit relay, modeled on lib/net.ts); this class
 * owns everything that makes it LIVE:
 *
 *   - the relay websocket connection (dial, jittered-backoff redial, ping
 *     liveness against mobile half-open TCP — net.ts's exact shapes);
 *   - WebRTC upgrades to peers surfaced by pubsub-peer-discovery, so
 *     gossipsub (which never runs on limited circuit connections) meshes on
 *     direct member-to-member links and OrbitDB sync replicates live;
 *   - mobile wake kicks (visibilitychange/pageshow/online) and a battery
 *     valve: hidden for >5 min ⇒ hang up every connection; transports resume
 *     on the next wake kick.
 *
 * Trust model differences from net.ts, on purpose: net.ts gates WebRTC
 * upgrades behind a room-membership beacon because ONE Net == ONE room.
 * The hub's node serves ALL rooms at once, and room trust lives entirely in
 * the E2E layer (sealed OrbitDB entries + the hardened access controller +
 * the app-level author allow-lists) — a connected stranger can subscribe to
 * an opaque topic id and receive ciphertext it can never read, exactly the
 * mailbox node's position. Discovery-topic peers are other users of the same
 * relay, bounded by maxConnections.
 *
 * LIVE IS AN ENHANCEMENT, never load-bearing: if the relay multiaddr is
 * unparseable or the relay is down, everything still flows through the
 * mailbox (the ZDR architecture contract). start() is lazy — the hub calls
 * it on the first opened conversation / Conversații tab, never at boot.
 */

import type { GossipsubEvents } from "@chainsafe/libp2p-gossipsub";
import type { PeerId, PubSub } from "@libp2p/interface";
import type { PingService } from "@libp2p/ping";
import { multiaddr, type Multiaddr } from "@multiformats/multiaddr";
import type { Libp2p } from "libp2p";

export type HubNode = Libp2p<{ identify: unknown; ping: PingService; pubsub: PubSub<GossipsubEvents> }>;

const PING_MS = 25_000; // relay liveness probe (mobile TCP half-open)
const DIAL_THROTTLE_MS = 15_000; // per-peer upgrade attempts (discovery re-fires ~5 s)
const REDIAL_BASE_MS = 500;
const REDIAL_CAP_MS = 15_000;
const HIDDEN_STOP_MS = 5 * 60_000; // hidden this long ⇒ drop transports (battery)

export class LiveMesh {
  #node: HubNode;
  #relayAddr: string;
  #relayPeer: string;
  #relayMa: Multiaddr | null = null; // null ⇒ live permanently disabled (bad config)
  #started = false;
  #suspended = false;
  #stopped = false;
  #relayUp = false;
  #redialTimer: ReturnType<typeof setTimeout> | null = null;
  #redialAttempt = 0;
  #hiddenTimer: ReturnType<typeof setTimeout> | null = null;
  #timers: ReturnType<typeof setInterval>[] = [];
  #windowListeners: [string, () => void][] = [];
  #lastDialAt = new Map<string, number>();

  /** Relay connectivity changes (a UI status hook; optional). */
  onStatus: (up: boolean) => void = () => {};

  constructor(node: HubNode, relayMultiaddr: string) {
    this.#node = node;
    this.#relayAddr = relayMultiaddr;
    this.#relayPeer = relayMultiaddr.split("/p2p/").pop() ?? "";
    try {
      // validate ONCE: harness/self-host configs may carry placeholder
      // multiaddrs — live silently stays off instead of a redial storm
      this.#relayMa = this.#relayPeer.length > 0 ? multiaddr(relayMultiaddr) : null;
    } catch {
      this.#relayMa = null;
    }
  }

  get enabled(): boolean {
    return this.#relayMa !== null;
  }

  get started(): boolean {
    return this.#started;
  }

  get relayUp(): boolean {
    return this.#relayUp;
  }

  /**
   * Go live (idempotent). Wires discovery/connection listeners, wake kicks
   * and the hidden-suspend valve, then dials the relay.
   */
  start(): void {
    if (this.#started || this.#stopped || !this.enabled) return;
    this.#started = true;
    const node = this.#node;

    node.addEventListener("peer:discovery", (e) => {
      const id = e.detail.id;
      const idStr = id.toString();
      if (idStr === this.#relayPeer || idStr === node.peerId.toString()) return;
      void this.#dialPeer(id);
    });
    node.addEventListener("connection:open", (e) => this.#onConnChange(e.detail.remotePeer));
    node.addEventListener("connection:close", (e) => this.#onConnChange(e.detail.remotePeer));

    // relay liveness: ping; two consecutive failures force a hang-up, which
    // lands in #onConnChange and schedules the redial (net.ts shape)
    let pingFails = 0;
    this.#timers.push(
      setInterval(() => {
        if (!this.#relayUp || this.#suspended || this.#stopped) return;
        const relay = this.#relayPeerId();
        if (!relay) return;
        this.#node.services.ping
          .ping(relay, { signal: AbortSignal.timeout(10_000) })
          .then(() => (pingFails = 0))
          .catch(async () => {
            if (++pingFails >= 2) {
              pingFails = 0;
              await this.#node.hangUp(relay).catch(() => {});
            }
          });
      }, PING_MS),
    );

    const kick = (): void => {
      if (this.#stopped) return;
      this.#clearHiddenTimer();
      this.#suspended = false;
      this.#redialAttempt = 0;
      this.#ensureRelay();
    };
    const onVisibility = (): void => {
      if (document.visibilityState === "visible") kick();
      else this.#armHiddenTimer();
    };
    this.#windowListeners = [
      ["visibilitychange", onVisibility],
      ["pageshow", kick],
      ["online", kick],
    ];
    for (const [evt, fn] of this.#windowListeners) window.addEventListener(evt, fn);
    if (document.visibilityState === "hidden") this.#armHiddenTimer();

    this.#ensureRelay();
  }

  // ---- relay connection management -----------------------------------------

  #relayPeerId(): PeerId | null {
    for (const c of this.#node.getConnections()) {
      if (c.remotePeer.toString() === this.#relayPeer) return c.remotePeer;
    }
    return null;
  }

  #ensureRelay(): void {
    if (!this.#started || this.#suspended || this.#stopped || !this.#relayMa) return;
    const connected = this.#node
      .getConnections()
      .some((c) => c.remotePeer.toString() === this.#relayPeer && c.status === "open");
    if (connected) {
      this.#setRelayUp(true);
      return;
    }
    this.#setRelayUp(false);
    void this.#node
      .dial(this.#relayMa, { signal: AbortSignal.timeout(15_000) })
      .then(() => {
        this.#redialAttempt = 0;
        this.#setRelayUp(true);
      })
      .catch(() => this.#scheduleRedial());
  }

  #scheduleRedial(): void {
    if (this.#redialTimer || this.#suspended || this.#stopped) return;
    // jittered exponential backoff — net.ts / v1 signaling shape
    const base = Math.min(REDIAL_CAP_MS, REDIAL_BASE_MS * 2 ** this.#redialAttempt++);
    const delay = base * (0.5 + Math.random());
    this.#redialTimer = setTimeout(() => {
      this.#redialTimer = null;
      this.#ensureRelay();
    }, delay);
  }

  #setRelayUp(up: boolean): void {
    if (this.#relayUp !== up) {
      this.#relayUp = up;
      try {
        this.onStatus(up);
      } catch {}
    }
  }

  #onConnChange(remotePeer: PeerId): void {
    if (!this.#started || this.#stopped) return;
    if (remotePeer.toString() !== this.#relayPeer) return;
    const stillUp = this.#node
      .getConnections()
      .some((c) => c.remotePeer.toString() === this.#relayPeer && c.status === "open");
    this.#setRelayUp(stillUp);
    if (!stillUp) this.#scheduleRedial();
  }

  // ---- peer upgrades -------------------------------------------------------

  /**
   * Dial a discovered peer's WebRTC upgrade through the relay circuit. The
   * connection carries only what the peer is entitled to anyway (gossipsub
   * ciphertext for shared topics, bitswap for ciphertext blocks); peers with
   * no shared room converge to zero traffic and age out of the connection
   * manager. Throttled — discovery re-announces every ~5 s.
   */
  async #dialPeer(id: PeerId): Promise<void> {
    if (!this.#started || this.#suspended || this.#stopped || !this.#relayUp) return;
    const idStr = id.toString();
    const conns = this.#node.getConnections().filter((c) => c.remotePeer.toString() === idStr && c.status === "open");
    if (conns.some((c) => c.remoteAddr.toString().includes("/webrtc"))) return; // upgraded already
    const last = this.#lastDialAt.get(idStr) ?? 0;
    if (Date.now() - last < DIAL_THROTTLE_MS) return;
    this.#lastDialAt.set(idStr, Date.now());
    if (this.#lastDialAt.size > 256) {
      // bounded book-keeping: drop the stalest half
      const entries = [...this.#lastDialAt.entries()].sort((a, b) => a[1] - b[1]);
      for (const [k] of entries.slice(0, 128)) this.#lastDialAt.delete(k);
    }
    const ma = multiaddr(`${this.#relayAddr}/p2p-circuit/webrtc/p2p/${idStr}`);
    await this.#node.dial(ma, { signal: AbortSignal.timeout(30_000) }).catch(() => {
      /* the other side may dial us instead */
    });
  }

  // ---- battery valve -------------------------------------------------------

  #armHiddenTimer(): void {
    if (this.#hiddenTimer || !this.#started || this.#stopped) return;
    this.#hiddenTimer = setTimeout(() => {
      this.#hiddenTimer = null;
      this.#suspend();
    }, HIDDEN_STOP_MS);
  }

  #clearHiddenTimer(): void {
    if (this.#hiddenTimer) {
      clearTimeout(this.#hiddenTimer);
      this.#hiddenTimer = null;
    }
  }

  /** Hidden too long: drop every connection; the next wake kick resumes. */
  #suspend(): void {
    if (this.#suspended || this.#stopped) return;
    this.#suspended = true;
    if (this.#redialTimer) {
      clearTimeout(this.#redialTimer);
      this.#redialTimer = null;
    }
    this.#setRelayUp(false);
    for (const c of this.#node.getConnections()) {
      void this.#node.hangUp(c.remotePeer).catch(() => {});
    }
  }

  // ---- app-plane gossipsub topics (M5 feed announce valve) -----------------

  #topicHandlers = new Map<string, (data: Uint8Array) => void>();
  #msgListenerOn = false;

  /**
   * Subscribe to a raw gossipsub topic and route its messages to `onMessage`.
   * Purely an ENHANCEMENT (feed head announcements): failures are swallowed,
   * nothing load-bearing may ever depend on a topic delivery.
   */
  joinTopic(topic: string, onMessage: (data: Uint8Array) => void): void {
    if (this.#stopped) return;
    this.#topicHandlers.set(topic, onMessage);
    if (!this.#msgListenerOn) {
      this.#msgListenerOn = true;
      this.#node.services.pubsub.addEventListener("message", (e) => {
        const handler = this.#topicHandlers.get(e.detail.topic);
        if (!handler) return;
        try {
          handler(e.detail.data);
        } catch {}
      });
    }
    try {
      this.#node.services.pubsub.subscribe(topic);
    } catch {}
  }

  leaveTopic(topic: string): void {
    this.#topicHandlers.delete(topic);
    try {
      this.#node.services.pubsub.unsubscribe(topic);
    } catch {}
  }

  /** Best-effort publish on an app topic (zero-peer publishes are allowed). */
  async publishTopic(topic: string, data: Uint8Array): Promise<void> {
    try {
      await this.#node.services.pubsub.publish(topic, data);
    } catch {}
  }

  // ---- presence ------------------------------------------------------------

  /**
   * How many OTHER devices are gossiping on `topic` (a room's OrbitDB address)
   * right now. Subscriptions only propagate over direct gossipsub links, so a
   * non-zero count means a same-room device is connected and live-replicating.
   * Honest limit: one of MY other devices in the room counts too (peer ids are
   * session-ephemeral by design — nothing maps them to identities).
   */
  subscribersOf(topic: string): number {
    try {
      return this.#node.services.pubsub.getSubscribers(topic).length;
    } catch {
      return 0;
    }
  }

  /** Debug/e2e visibility — no room ids, just transport state. */
  get debug(): { enabled: boolean; started: boolean; suspended: boolean; relayUp: boolean; conns: string[] } {
    return {
      enabled: this.enabled,
      started: this.#started,
      suspended: this.#suspended,
      relayUp: this.#relayUp,
      conns: this.#node.getConnections().map((c) => c.remoteAddr.toString()),
    };
  }

  /** Session teardown (the hub stops the node itself right after). */
  stop(): void {
    this.#stopped = true;
    for (const [evt, fn] of this.#windowListeners) window.removeEventListener(evt, fn);
    this.#windowListeners = [];
    for (const t of this.#timers) clearInterval(t);
    this.#timers = [];
    if (this.#redialTimer) clearTimeout(this.#redialTimer);
    this.#clearHiddenTimer();
  }
}