/**
 * A MODEL DOM — enough of one for `replicant.dom` to reconcile into, and no
 * more. It exists to answer one question that a string renderer structurally
 * cannot: does a keyed node keep its ELEMENT across a re-render and a re-order?
 *
 * WHY THIS AND NOT jsdom. The spike asked exactly this of jsdom, and jsdom is
 * the obvious answer. It is also ~40 transitive packages added to a repo whose
 * every dependency is exact-pinned and whose lockfile carries three git deps
 * that must not be re-resolved by accident (dev/docs/CLJS.md, house rule 2) —
 * for a test that only needs tree semantics. The surface `replicant.dom`
 * actually touches is the twenty-odd operations below, and every one of them is
 * unambiguous: appendChild moves a node out of its old parent, insertBefore
 * puts it at an index, removeChild detaches it. So this is a faithful model
 * rather than a stub, in the sense harness/dom.mjs's header means: it behaves
 * like the real thing for the operations under test, or it throws.
 *
 * AND IT IS PROBED. test/tiles-view.test.mjs runs the identity questions
 * against an UNKEYED render of the same list as well as a keyed one, and
 * requires the unkeyed one to FAIL them. A model DOM lenient enough to pass
 * both would be a model DOM that proves nothing, and that is the failure mode
 * this whole file is exposed to.
 *
 * What it deliberately does NOT model: layout, CSS, event dispatch (handlers
 * are recorded, never fired), selectors, namespaces beyond storing them,
 * `getComputedStyle` (replicant reaches for it only for :replicant/mounting and
 * :replicant/unmounting transitions, which nothing in this repo uses — if a
 * screen ever grows one, this harness must grow with it or say so loudly).
 */

class ClassList {
  constructor(el) {
    this._el = el;
  }
  add(cn) {
    if (!this._el._classes.includes(cn)) this._el._classes.push(cn);
  }
  remove(cn) {
    this._el._classes = this._el._classes.filter((c) => c !== cn);
  }
  contains(cn) {
    return this._el._classes.includes(cn);
  }
}

class Style {
  constructor() {
    this._props = new Map();
  }
  setProperty(k, v) {
    this._props.set(k, v);
  }
  removeProperty(k) {
    this._props.delete(k);
  }
  toString() {
    return [...this._props].map(([k, v]) => `${k}: ${v}`).join("; ");
  }
}

let uid = 0;

class Node {
  constructor(kind) {
    this.__id = ++uid;
    this.__kind = kind;
    this.parentNode = null;
    this.childNodes = [];
  }

  get isConnected() {
    let n = this;
    while (n.parentNode) n = n.parentNode;
    return n.__isRoot === true;
  }

  _detach(child) {
    const i = this.childNodes.indexOf(child);
    if (i >= 0) this.childNodes.splice(i, 1);
  }

  appendChild(child) {
    if (child.parentNode) child.parentNode._detach(child);
    child.parentNode = this;
    this.childNodes.push(child);
    return child;
  }

  insertBefore(child, ref) {
    if (child.parentNode) child.parentNode._detach(child);
    child.parentNode = this;
    const i = ref == null ? -1 : this.childNodes.indexOf(ref);
    if (i < 0) this.childNodes.push(child);
    else this.childNodes.splice(i, 0, child);
    return child;
  }

  removeChild(child) {
    if (child.parentNode !== this) throw new Error("removeChild: not a child");
    this._detach(child);
    child.parentNode = null;
    return child;
  }

  replaceChild(insert, replace) {
    const i = this.childNodes.indexOf(replace);
    if (i < 0) throw new Error("replaceChild: not a child");
    if (insert.parentNode) insert.parentNode._detach(insert);
    this.childNodes[i] = insert;
    insert.parentNode = this;
    replace.parentNode = null;
    return replace;
  }

  /** The one property replicant sets to clear a subtree. */
  set textContent(v) {
    if (v !== "") throw new Error(`minidom: textContent may only be cleared, got ${JSON.stringify(v)}`);
    for (const c of this.childNodes) c.parentNode = null;
    this.childNodes = [];
  }
  get textContent() {
    if (this.__kind === "text") return this._text;
    return this.childNodes.map((c) => c.textContent).join("");
  }
}

class Text extends Node {
  constructor(text) {
    super("text");
    this._text = String(text);
  }
  get textContent() {
    return this._text;
  }
  set textContent(v) {
    this._text = String(v);
  }
}

class Element extends Node {
  constructor(tagName, ns) {
    super("element");
    this.tagName = tagName;
    this.namespaceURI = ns ?? null;
    this._attrs = new Map();
    this._classes = [];
    this._listeners = new Map();
    this.style = new Style();
    this.classList = new ClassList(this);
  }

  setAttribute(a, v) {
    this._attrs.set(String(a), String(v));
  }
  setAttributeNS(_ns, a, v) {
    this._attrs.set(String(a), String(v));
  }
  getAttribute(a) {
    return this._attrs.has(String(a)) ? this._attrs.get(String(a)) : null;
  }
  removeAttribute(a) {
    this._attrs.delete(String(a));
  }
  addEventListener(ev, fn) {
    this._listeners.set(ev, fn);
  }
  removeEventListener(ev) {
    this._listeners.delete(ev);
  }

  set innerHTML(v) {
    if (v !== "") throw new Error("minidom: innerHTML may only be cleared");
    for (const c of this.childNodes) c.parentNode = null;
    this.childNodes = [];
  }
  get innerHTML() {
    return "";
  }

  get className() {
    return this._classes.join(" ");
  }
}

/** A detached tree root: everything under it reports isConnected. */
export function makeRoot(tagName = "div") {
  const el = new Element(tagName, null);
  el.__isRoot = true;
  return el;
}

/**
 * Point `globalThis.document`'s three factory methods at this model, leaving
 * harness/dom.mjs's stub in place for everything modules touch at import time.
 * Returns a restore function.
 */
export function installMiniDom() {
  const d = globalThis.document;
  const saved = {
    createElement: d.createElement,
    createTextNode: d.createTextNode,
    createElementNS: d.createElementNS,
  };
  d.createElement = (tag) => new Element(tag, null);
  d.createTextNode = (text) => new Text(text);
  d.createElementNS = (ns, tag) => new Element(tag, ns);
  return () => Object.assign(d, saved);
}

/** Flatten a node's element children (text nodes skipped). */
export const kids = (el) => el.childNodes.filter((n) => n.__kind === "element");

/**
 * Depth-first find of the first element carrying `id`. Not a selector engine —
 * replicant writes the id with setAttribute, so this reads exactly what it
 * wrote, and nothing here parses a query string.
 */
export function byId(el, id) {
  for (const c of el.childNodes) {
    if (c.__kind !== "element") continue;
    if (c.getAttribute("id") === id) return c;
    const found = byId(c, id);
    if (found) return found;
  }
  return null;
}

/** Depth-first find of the first element whose tagName matches. */
export function firstTag(el, tagName) {
  for (const c of el.childNodes) {
    if (c.__kind !== "element") continue;
    if (c.tagName === tagName) return c;
    const found = firstTag(c, tagName);
    if (found) return found;
  }
  return null;
}