const RECORD_SCHEMA = 1;
export const OWNED_TAB_STORAGE_KEY = "project_info_dynamic_owned_tab_v1";
export const SLOT_STATE_STORAGE_KEY = "project_info_dynamic_slot_state_v1";
export const FIXED_LIFECYCLE = Object.freeze({
  CLOSED: "OWNED_TAB_CLOSED",
  ALREADY_CLOSED: "OWNED_TAB_ALREADY_CLOSED",
  IDENTITY_DRIFT: "OWNED_TAB_IDENTITY_DRIFT",
  CLOSE_FAILED: "OWNED_TAB_CLOSE_FAILED",
  PEER_CLOSED: "E_NATIVE_PEER_CLOSED",
  TIMEOUT: "E_NATIVE_TIMEOUT"
});

const HEX32 = /^[0-9a-f]{32}$/u;
const HEX64 = /^[0-9a-f]{64}$/u;
const SLOT_MATERIAL = /^dynamic-slot:(0|[1-9][0-9]{0,15})$/u;
const SLOT_STATES = new Set(["STARTED", "COMPLETE", "FAILED"]);
const SLOT_HISTORY_LIMIT = 336;

function plain(value) {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
  const prototype = Object.getPrototypeOf(value);
  return prototype === Object.prototype || prototype === null;
}

function exactKeys(value, keys) {
  return plain(value) && Object.keys(value).sort().join("\0") === [...keys].sort().join("\0");
}

export function canonicalDynamicUrl(value) {
  const parsed = new URL(String(value));
  const parts = parsed.pathname.split("/").filter(Boolean);
  if (parsed.protocol !== "https:" || parsed.hostname !== "space.bilibili.com" ||
      parsed.search !== "" || parsed.hash !== "" || parts.length !== 2 ||
      !/^[1-9][0-9]{0,19}$/u.test(parts[0]) || parts[1] !== "dynamic") {
    throw new Error("E_ACTION");
  }
  return `https://space.bilibili.com/${parts[0]}/dynamic`;
}

function tabLocationMatches(tab, expected) {
  for (const raw of [tab?.url, tab?.pendingUrl]) {
    if (typeof raw !== "string") continue;
    try {
      const parsed = new URL(raw);
      const canonical = canonicalDynamicUrl(`${parsed.origin}${parsed.pathname}`);
      if (canonical === expected && parsed.search === "" && parsed.hash === "") return true;
    } catch {
      // A non-canonical location never proves ownership.
    }
  }
  return false;
}

function exactRecord(value) {
  const keys = ["schema", "slot_id", "lease_id", "tab_id", "window_id", "target_url"];
  if (!exactKeys(value, keys) || value.schema !== RECORD_SCHEMA ||
      !HEX64.test(value.slot_id) || !HEX32.test(value.lease_id) ||
      !Number.isInteger(value.tab_id) || value.tab_id < 0 ||
      !Number.isInteger(value.window_id) || value.window_id < 0) return null;
  let target;
  try { target = canonicalDynamicUrl(value.target_url); } catch { return null; }
  if (target !== value.target_url) return null;
  return Object.freeze({...value});
}

function markerValue(record) {
  return `${record.slot_id}:${record.lease_id}`;
}

function setOwnershipMarker(expected) {
  document.documentElement.dataset.projectInfoDynamicOwner = expected;
  return document.documentElement.dataset.projectInfoDynamicOwner;
}

function readOwnershipMarker() {
  return document.documentElement.dataset.projectInfoDynamicOwner || null;
}

async function sleep(milliseconds) {
  await new Promise((resolve) => setTimeout(resolve, milliseconds));
}

export class OwnedTabLifecycle {
  constructor(chromeApi, {randomHex, delay = sleep, pollMilliseconds = 100, maxPolls = 300} = {}) {
    this.chrome = chromeApi;
    this.randomHex = randomHex || ((bytes) => {
      const value = new Uint8Array(bytes);
      crypto.getRandomValues(value);
      return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join("");
    });
    this.delay = delay;
    this.pollMilliseconds = pollMilliseconds;
    this.maxPolls = maxPolls;
    this.lastDiagnostic = null;
  }

  async load() {
    const container = await this.chrome.storage.session.get(OWNED_TAB_STORAGE_KEY);
    const raw = plain(container) ? container[OWNED_TAB_STORAGE_KEY] : null;
    if (raw === undefined || raw === null) return null;
    const record = exactRecord(raw);
    if (record !== null) return record;
    await this.chrome.storage.session.remove(OWNED_TAB_STORAGE_KEY);
    this.lastDiagnostic = FIXED_LIFECYCLE.IDENTITY_DRIFT;
    return null;
  }

  async cleanupFresh(record, tab) {
    // This capability never escapes create(). The tab id comes directly from
    // tabs.create, so a pre-existing user tab is never an eligible target.
    try { await this.chrome.storage.session.remove(OWNED_TAB_STORAGE_KEY); } catch { /* best effort */ }
    const tabId = record?.tab_id ?? tab?.id;
    const windowId = record?.window_id ?? tab?.windowId;
    if (!Number.isInteger(tabId) || !Number.isInteger(windowId) ||
        tab?.id !== tabId || tab?.windowId !== windowId) return;
    try {
      await this.chrome.tabs.remove(tabId);
      this.lastDiagnostic = FIXED_LIFECYCLE.CLOSED;
    } catch {
      this.lastDiagnostic = FIXED_LIFECYCLE.CLOSE_FAILED;
    }
  }

  async create(slotId, targetUrl, leaseId = null) {
    if (!HEX64.test(slotId)) throw new Error("E_SLOT_ID");
    const target = canonicalDynamicUrl(targetUrl);
    const tab = await this.chrome.tabs.create({url: target, active: false});
    if (!Number.isInteger(tab?.id) || !Number.isInteger(tab?.windowId)) {
      await this.cleanupFresh(null, tab);
      throw new Error("E_TAB_CREATE");
    }
    const record = exactRecord({
      schema: RECORD_SCHEMA,
      slot_id: slotId,
      lease_id: leaseId === null ? this.randomHex(16) : leaseId,
      tab_id: tab.id,
      window_id: tab.windowId,
      target_url: target
    });
    if (record === null) {
      await this.cleanupFresh(null, tab);
      throw new Error("E_TAB_IDENTITY");
    }
    try {
      await this.chrome.storage.session.set({[OWNED_TAB_STORAGE_KEY]: record});
      const ready = await this.waitUntilComplete(record);
      const injected = await this.chrome.scripting.executeScript({
        target: {tabId: ready.id},
        func: setOwnershipMarker,
        args: [markerValue(record)]
      });
      if (!Array.isArray(injected) || injected.length !== 1 || injected[0]?.result !== markerValue(record)) {
        throw new Error("E_TAB_MARKER");
      }
      return {record, tab: ready};
    } catch (error) {
      await this.cleanupFresh(record, tab);
      throw error;
    }
  }

  async waitUntilComplete(record) {
    for (let index = 0; index < this.maxPolls; index += 1) {
      const tab = await this.chrome.tabs.get(record.tab_id);
      if (tab?.id !== record.tab_id || tab?.windowId !== record.window_id || !tabLocationMatches(tab, record.target_url)) {
        throw new Error("E_TAB_IDENTITY");
      }
      if (tab.status === "complete") return tab;
      await this.delay(this.pollMilliseconds);
    }
    throw new Error("E_TAB_TIMEOUT");
  }

  async cleanup(recordValue = null) {
    const record = exactRecord(recordValue) || await this.load();
    if (record === null) return FIXED_LIFECYCLE.ALREADY_CLOSED;
    let tab;
    try {
      tab = await this.chrome.tabs.get(record.tab_id);
    } catch {
      await this.chrome.storage.session.remove(OWNED_TAB_STORAGE_KEY);
      this.lastDiagnostic = FIXED_LIFECYCLE.ALREADY_CLOSED;
      return this.lastDiagnostic;
    }
    let marker = null;
    try {
      const observed = await this.chrome.scripting.executeScript({
        target: {tabId: record.tab_id},
        func: readOwnershipMarker
      });
      if (Array.isArray(observed) && observed.length === 1) marker = observed[0]?.result ?? null;
    } catch {
      marker = null;
    }
    if (tab?.id !== record.tab_id || tab?.windowId !== record.window_id ||
        !tabLocationMatches(tab, record.target_url) || marker !== markerValue(record)) {
      await this.chrome.storage.session.remove(OWNED_TAB_STORAGE_KEY);
      this.lastDiagnostic = FIXED_LIFECYCLE.IDENTITY_DRIFT;
      return this.lastDiagnostic;
    }
    // Retire the durable capability before the sole non-atomic tab mutation.
    // A failed removal is terminal: never retry or navigate the numeric tab id.
    await this.chrome.storage.session.remove(OWNED_TAB_STORAGE_KEY);
    try {
      await this.chrome.tabs.remove(record.tab_id);
      this.lastDiagnostic = FIXED_LIFECYCLE.CLOSED;
    } catch {
      this.lastDiagnostic = FIXED_LIFECYCLE.CLOSE_FAILED;
    }
    return this.lastDiagnostic;
  }
}

function exactSlotEntry(value) {
  const keys = ["schema", "slot_material", "slot_number", "slot_id", "lease_id", "state", "result_code"];
  if (!exactKeys(value, keys) || value.schema !== 1 || !SLOT_MATERIAL.test(value.slot_material) ||
      !Number.isSafeInteger(value.slot_number) || value.slot_number < 0 ||
      value.slot_material !== `dynamic-slot:${value.slot_number}` || !HEX64.test(value.slot_id) ||
      !HEX32.test(value.lease_id) || !SLOT_STATES.has(value.state)) return null;
  if (value.state === "STARTED" && value.result_code !== null) return null;
  if (value.state === "COMPLETE" && value.result_code !== "SLOT_COMPLETE") return null;
  if (value.state === "FAILED" &&
      (typeof value.result_code !== "string" || !/^E_[A-Z0-9_]+$/u.test(value.result_code))) return null;
  return Object.freeze({...value});
}

function exactSlotRoot(value) {
  if (!exactKeys(value, ["schema", "entries"]) || value.schema !== 1 || !Array.isArray(value.entries) ||
      value.entries.length > SLOT_HISTORY_LIMIT) return null;
  const entries = [];
  const seen = new Set();
  for (const raw of value.entries) {
    const entry = exactSlotEntry(raw);
    if (entry === null || seen.has(entry.slot_material)) return null;
    seen.add(entry.slot_material);
    entries.push(entry);
  }
  if (entries.filter((entry) => entry.state === "STARTED").length > 1) return null;
  return Object.freeze({schema: 1, entries: Object.freeze(entries)});
}

export class SlotStateStore {
  constructor(chromeApi, {randomHex, historyLimit = SLOT_HISTORY_LIMIT} = {}) {
    this.chrome = chromeApi;
    this.historyLimit = historyLimit;
    this.randomHex = randomHex || ((bytes) => {
      const value = new Uint8Array(bytes);
      crypto.getRandomValues(value);
      return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join("");
    });
    if (!Number.isSafeInteger(historyLimit) || historyLimit < 2 || historyLimit > SLOT_HISTORY_LIMIT) {
      throw new Error("E_SLOT_STATE");
    }
  }

  async read() {
    const container = await this.chrome.storage.local.get(SLOT_STATE_STORAGE_KEY);
    const raw = plain(container) ? container[SLOT_STATE_STORAGE_KEY] : undefined;
    if (raw === undefined) return Object.freeze({schema: 1, entries: Object.freeze([])});
    const root = exactSlotRoot(raw);
    if (root === null) throw new Error("E_SLOT_STATE");
    return root;
  }

  async claim(slotMaterial, slotId) {
    if (!SLOT_MATERIAL.test(slotMaterial) || !HEX64.test(slotId)) throw new Error("E_SLOT_STATE");
    const slotNumber = Number(slotMaterial.slice("dynamic-slot:".length));
    if (!Number.isSafeInteger(slotNumber) || slotMaterial !== `dynamic-slot:${slotNumber}`) {
      throw new Error("E_SLOT_STATE");
    }
    const root = await this.read();
    const existing = root.entries.find((entry) => entry.slot_material === slotMaterial);
    if (existing !== undefined) {
      if (existing.slot_id !== slotId) throw new Error("E_SLOT_STATE");
      return {disposition: existing.state === "STARTED" ? "RESUME" : "TERMINAL", entry: existing};
    }
    if (root.entries.some((entry) => entry.state === "STARTED")) return {disposition: "BUSY", entry: null};
    const entry = exactSlotEntry({
      schema: 1,
      slot_material: slotMaterial,
      slot_number: slotNumber,
      slot_id: slotId,
      lease_id: this.randomHex(16),
      state: "STARTED",
      result_code: null
    });
    if (entry === null) throw new Error("E_SLOT_STATE");
    const terminal = root.entries.filter((item) => item.state !== "STARTED");
    const kept = terminal.slice(Math.max(0, terminal.length - (this.historyLimit - 1)));
    const next = {schema: 1, entries: [...kept, entry]};
    await this.chrome.storage.local.set({[SLOT_STATE_STORAGE_KEY]: next});
    const rebound = await this.read();
    const stored = rebound.entries.find((item) => item.slot_material === slotMaterial);
    if (stored === undefined || JSON.stringify(stored) !== JSON.stringify(entry)) throw new Error("E_SLOT_STATE");
    return {disposition: "CLAIMED", entry: stored};
  }

  async started() {
    const root = await this.read();
    return root.entries.find((entry) => entry.state === "STARTED") ?? null;
  }

  async finish(entryValue, state, resultCode) {
    const expected = exactSlotEntry(entryValue);
    if (expected === null || expected.state !== "STARTED" || !["COMPLETE", "FAILED"].includes(state)) {
      throw new Error("E_SLOT_STATE");
    }
    const candidate = exactSlotEntry({...expected, state, result_code: resultCode});
    if (candidate === null) throw new Error("E_SLOT_STATE");
    const root = await this.read();
    const index = root.entries.findIndex((item) => item.slot_material === expected.slot_material);
    if (index < 0 || JSON.stringify(root.entries[index]) !== JSON.stringify(expected)) throw new Error("E_SLOT_STATE");
    const entries = root.entries.map((item, itemIndex) => itemIndex === index ? candidate : item);
    await this.chrome.storage.local.set({[SLOT_STATE_STORAGE_KEY]: {schema: 1, entries}});
    const rebound = await this.read();
    const stored = rebound.entries.find((item) => item.slot_material === expected.slot_material);
    if (stored === undefined || JSON.stringify(stored) !== JSON.stringify(candidate)) throw new Error("E_SLOT_STATE");
    return stored;
  }
}

export class NativePortTransport {
  constructor(port, {timeoutMilliseconds = 120000} = {}) {
    this.port = port;
    this.timeoutMilliseconds = timeoutMilliseconds;
    this.closed = false;
    this.writeChain = Promise.resolve();
    this.listeners = new Set();
    this.disconnectListeners = new Set();
    // Install handlers before the caller can perform its first write.
    port.onMessage.addListener((message) => {
      for (const listener of [...this.listeners]) listener(message);
    });
    port.onDisconnect.addListener(() => {
      this.closed = true;
      for (const listener of [...this.disconnectListeners]) listener(FIXED_LIFECYCLE.PEER_CLOSED);
    });
  }

  onMessage(listener) { this.listeners.add(listener); }
  onDisconnect(listener) { this.disconnectListeners.add(listener); }

  send(message) {
    const operation = this.writeChain.then(() => {
      if (this.closed) throw new Error(FIXED_LIFECYCLE.PEER_CLOSED);
      try {
        this.port.postMessage(message);
      } catch {
        this.closed = true;
        throw new Error(FIXED_LIFECYCLE.PEER_CLOSED);
      }
      if (this.closed) throw new Error(FIXED_LIFECYCLE.PEER_CLOSED);
    });
    this.writeChain = operation.catch(() => undefined);
    return operation;
  }

  disconnect() {
    if (this.closed) return;
    this.closed = true;
    try { this.port.disconnect(); } catch { /* peer already closed */ }
  }
}

export async function runNativeSession({transport, session}) {
  return await new Promise((resolve, reject) => {
    let settled = false;
    const timer = setTimeout(() => finish(new Error(FIXED_LIFECYCLE.TIMEOUT)), transport.timeoutMilliseconds);
    const finish = (error, value) => {
      if (settled) return;
      settled = true;
      clearTimeout(timer);
      transport.disconnect();
      if (error) reject(error); else resolve(value);
    };
    transport.onDisconnect((code) => finish(new Error(code)));
    transport.onMessage((message) => {
      Promise.resolve(session.accept(message)).then(async (reply) => {
        if (reply !== null) await transport.send(reply);
        if (message?.type === "HOST_COMMIT_RESULT") finish(null, message.result ?? null);
      }).catch((error) => finish(error));
    });
    transport.send(session.helloFrame()).catch((error) => finish(error));
  });
}

export class SlotCoordinator {
  constructor({lifecycle, slotStore, connect, createSession, hashSlot, collectPage}) {
    this.lifecycle = lifecycle;
    this.slotStore = slotStore;
    this.connect = connect;
    this.createSession = createSession;
    this.hashSlot = hashSlot;
    this.collectPage = collectPage;
    this.active = false;
    this.operationTail = Promise.resolve();
  }

  async serialize(operation) {
    const prior = this.operationTail;
    let release;
    this.operationTail = new Promise((resolve) => { release = resolve; });
    await prior.catch(() => undefined);
    try {
      return await operation();
    } finally {
      release();
    }
  }

  async recoverUnlocked() {
    const started = await this.slotStore.started();
    if (started === null) {
      await this.lifecycle.cleanup();
      return null;
    }
    const prior = await this.lifecycle.load();
    if (prior !== null && (prior.slot_id !== started.slot_id || prior.lease_id !== started.lease_id)) {
      throw new Error("E_SLOT_STATE");
    }
    const lifecycle_code = prior === null
      ? FIXED_LIFECYCLE.ALREADY_CLOSED
      : await this.lifecycle.cleanup(prior);
    await this.slotStore.finish(started, "FAILED", "E_SLOT_INTERRUPTED");
    return Object.freeze({
      slot_material: started.slot_material,
      lease_id: started.lease_id,
      result_code: "E_SLOT_INTERRUPTED",
      lifecycle_code
    });
  }

  async recover() {
    return await this.serialize(() => this.recoverUnlocked());
  }

  async runUnlocked(slotMaterial) {
    let owned = null;
    let claim = null;
    let outcome = null;
    try {
      const recovered = await this.recoverUnlocked();
      if (recovered?.slot_material === slotMaterial) {
        return {status: "FAILED", error_code: recovered.result_code};
      }
      const slotId = await this.hashSlot(slotMaterial);
      if (!HEX64.test(slotId)) throw new Error("E_SLOT_STATE");
      claim = await this.slotStore.claim(slotMaterial, slotId);
      if (claim.disposition === "BUSY") return {status: "SKIPPED_OVERLAP"};
      if (claim.disposition === "TERMINAL") {
        return {status: "SKIPPED_TERMINAL", terminal_state: claim.entry.state, result_code: claim.entry.result_code};
      }
      if (claim.disposition === "RESUME") {
        const prior = await this.lifecycle.load();
        if (prior !== null && (prior.slot_id !== claim.entry.slot_id || prior.lease_id !== claim.entry.lease_id)) {
          throw new Error("E_SLOT_STATE");
        }
        if (prior !== null) await this.lifecycle.cleanup(prior);
        await this.slotStore.finish(claim.entry, "FAILED", "E_SLOT_INTERRUPTED");
        return {status: "FAILED", error_code: "E_SLOT_INTERRUPTED"};
      }
      await this.lifecycle.cleanup();
      const lifecycle = this.lifecycle;
      const collectPage = this.collectPage;
      const api = {
        async prepare(action) {
          if (!plain(action) || !["reload", "goto"].includes(action.kind)) throw new Error("E_ACTION");
          return {action_id: action.action_id, kind: "goto", url: canonicalDynamicUrl(action.url)};
        },
        async dispatch(prepared) {
          owned = await lifecycle.create(slotId, prepared.url, claim.entry.lease_id);
          return {action_id: prepared.action_id, tab_id: owned.record.tab_id, url: prepared.url};
        },
        async observe(result) {
          return await lifecycle.chrome.scripting.executeScript({
            target: {tabId: result.tab_id},
            func: collectPage,
            args: [result.url]
          }).then((items) => {
            if (!Array.isArray(items) || items.length !== 1) throw new Error("E_OBSERVATION_COUNT");
            return items[0].result;
          });
        }
      };
      const transport = this.connect();
      const result = await runNativeSession({transport, session: this.createSession(api)});
      outcome = {status: "COMPLETE", result};
    } catch (error) {
      const code = typeof error?.message === "string" && /^E_[A-Z0-9_]+$/u.test(error.message)
        ? error.message : "E_SLOT_FAILED";
      outcome = {status: "FAILED", error_code: code};
    } finally {
      if (owned !== null) await this.lifecycle.cleanup(owned.record);
    }
    if (claim?.disposition === "CLAIMED") {
      try {
        await this.slotStore.finish(
          claim.entry,
          outcome?.status === "COMPLETE" ? "COMPLETE" : "FAILED",
          outcome?.status === "COMPLETE" ? "SLOT_COMPLETE" : (outcome?.error_code || "E_SLOT_FAILED")
        );
      } catch {
        return {status: "FAILED", error_code: "E_SLOT_STATE"};
      }
    }
    return outcome || {status: "FAILED", error_code: "E_SLOT_FAILED"};
  }

  async run(slotMaterial) {
    if (this.active) return {status: "SKIPPED_OVERLAP"};
    this.active = true;
    try {
      return await this.serialize(() => this.runUnlocked(slotMaterial));
    } finally {
      // The serialized operation includes terminal append and readback.
      this.active = false;
    }
  }
}