import type { PlacedPart } from '../types';
import type { Finding, RuleContext, ValidationRule } from './types';
import { approxAABB, isExitPart, isPumpOff, partName } from './graph';
import { computeReservoirWaterStats } from '../simulation/flowSimulator';
import { useBuilder } from '../store/builderStore';
import { dist3 } from '../utils/connectors';

/**
 * Design-check rules. Each rule is a pure function over a RuleContext and is
 * registered in `ALL_RULES` at the bottom — add new rules there.
 *
 * Defensive style: sibling agents may evolve the simulator/part shapes, so
 * everything reads via optional chaining and tolerates missing data.
 */

const fmt = (n: number, digits = 1) => Number(n.toFixed(digits)).toString();

/** Fraction of max head above which a pump is "near its limit". */
export const HEAD_MARGIN_RATIO = 0.8;
/** A flow path that descends this many feet after a climb risks siphoning. */
export const SIPHON_DROP_FT = 2;
/** Horizontal pipes above this height (ft) need support. */
export const SPAN_MIN_HEIGHT_FT = 1.5;
/** Horizontal pipes longer than this (ft) need support. */
export const SPAN_MIN_LENGTH_FT = 4;
/** A support must reach within this distance (ft) beneath a pipe end. */
export const SUPPORT_REACH_FT = 0.6;

// ---------- a. pump head margin ----------

function getPumpStaticHead(ctx: RuleContext, pumpId: string): number {
  const pump = ctx.partsMap[pumpId];
  if (!pump) return 0;
  const conns = ctx.graph.connectorsByPart.get(pumpId) ?? [];
  const outlet = conns.find((c) => c.connectorId === 'out') ?? conns[conns.length - 1];
  if (!outlet) return 0;

  let maxY = pump.position[1];
  const queue = [outlet.partId];
  const visited = new Set<string>([pumpId]);

  while (queue.length > 0) {
    const currId = queue.shift()!;
    if (visited.has(currId)) continue;
    visited.add(currId);

    const part = ctx.partsMap[currId];
    if (part) {
      maxY = Math.max(maxY, part.position[1]);
    }

    const nbs = ctx.graph.neighbors.get(currId);
    if (nbs) {
      for (const nb of nbs) {
        if (!visited.has(nb)) {
          queue.push(nb);
        }
      }
    }
  }

  return Math.max(0, maxY - pump.position[1]);
}

function pumpHeadMargin(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const pr of ctx.sim?.pumps ?? []) {
    const pump = ctx.partsMap[pr?.pumpId ?? ''];
    if (!pump || isPumpOff(pump)) continue;
    const maxHead = pr.maxHeadFt ?? 0;
    const head = getPumpStaticHead(ctx, pump.id);
    if (maxHead <= 0) continue;
    const ratio = head / maxHead;
    if (ratio <= HEAD_MARGIN_RATIO) continue;

    const name = partName(pump);
    // Lowering the high point by this much restores a 20% margin.
    const lowerBy = Math.max(0.1, head - HEAD_MARGIN_RATIO * maxHead);
    const fix = `Choose a higher-head pump or lower the highest point by ${fmt(lowerBy)} ft`;
    if (ratio >= 1) {
      findings.push({
        id: `pump-head:${pump.id}`,
        severity: 'error',
        title: 'Pump cannot reach the highest point',
        detail: `${name} must lift water ${fmt(head)} ft but its max head is ${fmt(maxHead)} ft — it delivers no flow.`,
        partIds: [pump.id],
        fix,
      });
    } else {
      findings.push({
        id: `pump-head:${pump.id}`,
        severity: 'warning',
        title: `Pump near its limit (${Math.round(ratio * 100)}%), keep \u226520% margin`,
        detail: `${name} is lifting ${fmt(head)} ft of ${fmt(maxHead)} ft max head, so flow is heavily reduced and the pump will wear quickly.`,
        partIds: [pump.id],
        fix,
      });
    }
  }
  return findings;
}


// ---------- b. pump starved / off ----------

/** BFS the part graph from the pump inlet (never through the pump) for a reservoir. */
function inletReachesReservoir(ctx: RuleContext, pumpId: string, inletKey: string): boolean {
  const start: string[] = [];
  for (const { a, b } of ctx.graph.joints) {
    if (a.key === inletKey) start.push(b.partId);
    if (b.key === inletKey) start.push(a.partId);
  }
  const seen = new Set<string>([pumpId, ...start]);
  const queue = [...start];
  while (queue.length) {
    const id = queue.shift()!;
    if (ctx.partsMap[id]?.type === 'reservoir') return true;
    for (const nb of ctx.graph.neighbors.get(id) ?? []) {
      if (!seen.has(nb)) {
        seen.add(nb);
        queue.push(nb);
      }
    }
  }
  return false;
}

function pumpStarvedOrOff(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const pump of ctx.parts) {
    if (pump.type !== 'pump') continue;
    const name = partName(pump);

    if (isPumpOff(pump)) {
      findings.push({
        id: `pump-dead:${pump.id}`,
        severity: 'error',
        title: 'Pump is switched off',
        detail: `${name} is powered off, so it delivers no flow.`,
        partIds: [pump.id],
        fix: 'Turn the pump on (power toggle in the inspector).',
      });
      continue;
    }

    const conns = ctx.graph.connectorsByPart.get(pump.id) ?? [];
    const inlet = conns.find((c) => c.connectorId === 'in') ?? conns[0];
    const outlet = conns.find((c) => c.connectorId === 'out') ?? conns[conns.length - 1];

    const hasOutlet = outlet && ctx.graph.joinedKeys.has(outlet.key);
    const hasInlet = inlet && ctx.graph.joinedKeys.has(inlet.key);

    const pr = ctx.sim?.pumps?.find((p) => p?.pumpId === pump.id);
    if (pr && (pr.gph ?? 0) > 0 && hasOutlet && hasInlet) continue;
    // Over-head pumps are owned by the head-margin rule — don't double report.
    const staticHead = getPumpStaticHead(ctx, pump.id);
    if (pr && (pr.maxHeadFt ?? 0) > 0 && staticHead >= (pr.maxHeadFt ?? 0)) continue;

    let detail: string;
    let fix: string;
    if (inlet && !ctx.graph.joinedKeys.has(inlet.key)) {
      detail = `${name}'s inlet is not connected to anything — there is no water source.`;
      fix = 'Connect the pump inlet to a reservoir.';
    } else if (inlet && !inletReachesReservoir(ctx, pump.id, inlet.key)) {
      detail = `${name}'s inlet line never reaches a reservoir — there is no water source.`;
      fix = 'Route the inlet line back to a reservoir.';
    } else if (outlet && !ctx.graph.joinedKeys.has(outlet.key)) {
      detail = `${name}'s outlet is not connected to anything — water has nowhere to go.`;
      fix = 'Connect the pump outlet to your plumbing.';
    } else {
      const simMsg = ctx.sim?.warnings?.find(
        (w) => w?.partId === pump.id && w?.level !== 'info',
      )?.message;
      detail = simMsg ?? `${name} delivers no flow.`;
      fix = 'Check for closed valves and verify the line reaches an outlet.';
    }

    findings.push({
      id: `pump-dead:${pump.id}`,
      severity: 'error',
      title: 'Pump delivers no flow',
      detail,
      partIds: [pump.id],
      fix,
    });
  }
  return findings;
}

// ---------- c. mismatched diameters ----------

function getConnectorDiameter(part: PlacedPart, connId: string): number {
  if (part.type === 'reducer' || part.type === 'reducingElbow') {
    return connId === 'a' ? (part.params.diameterA ?? 1.5) : (part.params.diameterB ?? 1.0);
  }
  if (part.type === 'reducingTee') {
    return connId === 'c' || connId === 'branch' ? (part.params.diameterB ?? 1.0) : (part.params.diameterA ?? 1.5);
  }
  return part.params.diameter ?? 1.0;
}

function mismatchedDiameters(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  const seen = new Set<string>();
  for (const { a, b } of ctx.graph.joints) {
    const pa = ctx.partsMap[a.partId];
    const pb = ctx.partsMap[b.partId];
    if (!pa || !pb) continue;
    const da = getConnectorDiameter(pa, a.connectorId);
    const db = getConnectorDiameter(pb, b.connectorId);
    if (Math.abs(da - db) < 0.01) continue;

    const pairKey = [a.partId, b.partId].sort().join(':');
    if (seen.has(pairKey)) continue;
    seen.add(pairKey);

    const nameA = partName(pa);
    const nameB = partName(pb);
    findings.push({
      id: `diameter-mismatch:${pairKey}`,
      severity: 'warning',
      title: 'Mismatched pipe diameters at a joint',
      detail: `${nameA} (${fmt(da, 2)} in) is joined to ${nameB} (${fmt(db, 2)} in) — the abrupt size change causes turbulence and pressure loss.`,
      partIds: [a.partId, b.partId],
      fix: `Add a reducer or match diameters (${nameA} is ${fmt(da, 2)} in, ${nameB} is ${fmt(db, 2)} in)`,
    });
  }
  return findings;
}

// ---------- d. dead legs ----------

function deadLegs(ctx: RuleContext): Finding[] {
  const flows = ctx.sim?.flows ?? {};
  const flowing = new Set(Object.keys(flows).filter((id) => (flows[id] ?? 0) > 0));
  if (!flowing.size) return []; // nothing is flowing — orphan/pump rules apply instead
  const findings: Finding[] = [];

  for (const part of ctx.parts) {
    const conns = ctx.graph.connectorsByPart.get(part.id) ?? [];
    if (!conns.length) continue;
    if (part.type === 'pump' || isExitPart(part)) continue;
    const joinedCount = conns.filter((c) => ctx.graph.joinedKeys.has(c.key)).length;
    // Terminal = attached on one side but with an open (capped/dangling) end.
    if (joinedCount === 0 || joinedCount === conns.length) continue;

    // Walk back through the plain-conduit chain to where the branch attaches.
    const chain = [part.id];
    let prev: string | null = null;
    let cur = part.id;
    let attached: string | null = null;
    for (let guard = 0; guard < ctx.parts.length; guard++) {
      const nbrs = [...(ctx.graph.neighbors.get(cur) ?? [])].filter(
        (n) => n !== prev && !chain.includes(n),
      );
      if (nbrs.length !== 1) break;
      const next = nbrs[0];
      const nextPart = ctx.partsMap[next];
      const isJunction = (ctx.graph.neighbors.get(next)?.size ?? 0) >= 3;
      if (!nextPart || nextPart.type === 'pump' || isExitPart(nextPart) || isJunction) {
        attached = next;
        break;
      }
      chain.push(next);
      prev = cur;
      cur = next;
    }

    const branchFlows =
      (attached !== null && flowing.has(attached)) || chain.some((id) => flowing.has(id));
    if (!branchFlows) continue;
    if (chain.some((id) => isExitPart(ctx.partsMap[id]))) continue;

    findings.push({
      id: `dead-leg:${part.id}`,
      severity: 'warning',
      title: 'Dead leg — stagnant water',
      detail: `${partName(part)} ends a flowing branch with no reservoir, emitter, drain or grow part — water will sit stagnant (or leak) here.`,
      partIds: chain,
      fix: 'Cap with an emitter/drain or remove',
    });
  }
  return findings;
}

// ---------- e. unsupported spans ----------

function unsupportedSpans(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const pipe of ctx.parts) {
    if (pipe.type !== 'pipe') continue;
    const ends = ctx.graph.connectorsByPart.get(pipe.id) ?? [];
    if (ends.length < 2) continue;
    const [ea, eb] = [ends[0].pos, ends[ends.length - 1].pos];
    if (Math.abs(ea[1] - eb[1]) > 0.3) continue; // not horizontal
    const centerY = (ea[1] + eb[1]) / 2;
    if (centerY <= SPAN_MIN_HEIGHT_FT) continue;
    const length = pipe.params?.length ?? Math.hypot(eb[0] - ea[0], eb[2] - ea[2]);
    if (length <= SPAN_MIN_LENGTH_FT) continue;

    const supported = (end: [number, number, number]) =>
      ctx.parts.some((q) => {
        if (q.id === pipe.id) return false;
        const box = approxAABB(q, ctx.graph.connectorsByPart.get(q.id) ?? []);
        const margin = 0.3;
        const horizontallyUnder =
          end[0] >= box.min[0] - margin &&
          end[0] <= box.max[0] + margin &&
          end[2] >= box.min[2] - margin &&
          end[2] <= box.max[2] + margin;
        // The support must occupy the space just beneath the end: reach up to
        // within SUPPORT_REACH_FT of the pipe while extending from below it.
        return (
          horizontallyUnder &&
          box.max[1] >= end[1] - SUPPORT_REACH_FT &&
          box.min[1] <= end[1] - SUPPORT_REACH_FT
        );
      });

    if (supported(ea) || supported(eb)) continue;

    findings.push({
      id: `unsupported-span:${pipe.id}`,
      severity: 'info',
      title: `Unsupported span ${fmt(length)} ft`,
      detail: `${partName(pipe)} runs ${fmt(length)} ft at ${fmt(centerY)} ft height with nothing beneath either end — it will sag over time.`,
      partIds: [pipe.id],
      fix: 'Add a lattice/structure support',
    });
  }
  return findings;
}

// ---------- f. siphon risk ----------

function siphonRisk(ctx: RuleContext): Finding[] {
  const flows = ctx.sim?.flows ?? {};
  const findings: Finding[] = [];

  for (const pr of ctx.sim?.pumps ?? []) {
    if ((pr?.gph ?? 0) <= 0) continue;
    const pumpId = pr.pumpId;
    const startId = ctx.graph.nodeOfConnector.get(`${pumpId}:out`);
    const startNode = startId ? ctx.graph.nodes.get(startId) : undefined;
    if (!startNode) continue;

    const startY = startNode.pos[1];
    let bestDrop = 0;
    let bestHighPart = pumpId;
    let bestHighY = startY;

    const visited = new Set<string>([`P:${pumpId}`, startNode.id]);
    const stack: { id: string; pathMax: number; highPart: string }[] = [
      { id: startNode.id, pathMax: startY, highPart: pumpId },
    ];
    while (stack.length) {
      const { id, pathMax, highPart } = stack.pop()!;
      const node = ctx.graph.nodes.get(id);
      if (!node) continue;
      for (const e of node.edges) {
        if (visited.has(e.to)) continue;
        if ((flows[e.partId] ?? 0) <= 0 && e.partId !== pumpId) continue;
        visited.add(e.to);
        const to = ctx.graph.nodes.get(e.to);
        if (!to) continue;
        let max = pathMax;
        let nextHigh = highPart;
        if (to.pos[1] > max) {
          max = to.pos[1];
          nextHigh = e.partId;
        }
        const drop = max - to.pos[1];
        if (max > startY + 0.5 && drop > bestDrop) {
          bestDrop = drop;
          bestHighPart = nextHigh;
          bestHighY = max;
        }
        stack.push({ id: e.to, pathMax: max, highPart: nextHigh });
      }
    }

    if (bestDrop >= SIPHON_DROP_FT) {
      findings.push({
        id: `siphon:${pumpId}`,
        severity: 'info',
        title: 'Possible siphon on shutdown',
        detail: `Flow from ${partName(ctx.partsMap[pumpId])} climbs to ${fmt(bestHighY)} ft and then descends ${fmt(bestDrop)} ft — when the pump stops, gravity can keep siphoning water through the line.`,
        partIds: [bestHighPart],
        fix: 'Add an air gap or check valve at the high point',
      });
    }
  }
  return findings;
}

// ---------- g. undersized drains ----------

function undersizedDrains(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const part of ctx.parts) {
    const isDrain = part.type === 'drain' || typeof part.params?.capacityGph === 'number';
    if (!isDrain) continue;
    const capacity = part.params?.capacityGph ?? 250;
    // Prefer the sim's pre-clamp inflow report; fall back to the flow map.
    const reported = ctx.sim?.drains?.find?.((d) => d?.partId === part.id)?.inflowGph;
    const inflow = reported ?? ctx.sim?.flows?.[part.id] ?? 0;
    if (inflow <= capacity + 0.5) continue;

    const needed = Math.ceil(inflow / 25) * 25;
    findings.push({
      id: `drain-capacity:${part.id}`,
      severity: 'error',
      title: 'Undersized drain — will overflow',
      detail: `${partName(part)} receives ${Math.round(inflow)} GPH but is rated for ${Math.round(capacity)} GPH — the excess will back up and flood.`,
      partIds: [part.id],
      fix: `Upsize drain to \u2265 ${needed} GPH capacity`,
    });
  }
  return findings;
}

// ---------- h. net-pot spill risk ----------

function netPotSpills(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const pot of ctx.sim?.netPots ?? []) {
    if (!pot?.overflowing) continue;
    const part = ctx.partsMap[pot.partId];
    if (!part) continue;
    const source = ctx.partsMap[pot.sourcePartId];
    findings.push({
      id: `net-pot-spill:${pot.partId}`,
      severity: 'error',
      title: 'Net pot will overflow from backed-up plumbing',
      detail: `${partName(part)} sits above ${partName(source)}. Water is rising to ${fmt(pot.waterHeightFt)} ft while the pot rim is ${fmt(pot.rimHeightFt)} ft, so nutrient solution will spill out of the top.`,
      partIds: source ? [pot.partId, source.id] : [pot.partId],
      fix: 'Add a drain/outlet, lower water level, or move the net pot off the flooded line.',
    });
  }
  return findings;
}

// ---------- i. orphans ----------

function orphans(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const part of ctx.parts) {
    const conns = ctx.graph.connectorsByPart.get(part.id) ?? [];
    if (!conns.length) continue; // decorative/structural parts can't be orphans
    if (conns.some((c) => ctx.graph.joinedKeys.has(c.key))) continue;
    findings.push({
      id: `orphan:${part.id}`,
      severity: 'info',
      title: 'Not connected to anything',
      detail: `${partName(part)} has no connections — it is not part of any water circuit.`,
      partIds: [part.id],
      fix: 'Drag it onto a matching connector, or delete it if unused.',
    });
  }
  return findings;
}

// ---------- j. closed valves ----------

function closedValves(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const valve of ctx.parts) {
    if (valve.type !== 'valve' || valve.params?.open !== 0) continue;
    const compIdx = ctx.graph.componentOf.get(valve.id);
    if (compIdx === undefined) continue;
    const comp = ctx.graph.components[compIdx];
    const hasLivePump = [...comp].some((id) => {
      const p: PlacedPart | undefined = ctx.partsMap[id];
      return p?.type === 'pump' && !isPumpOff(p);
    });
    if (!hasLivePump) continue;
    findings.push({
      id: `closed-valve:${valve.id}`,
      severity: 'info',
      title: 'Closed valve blocking a flowing line',
      detail: `${partName(valve)} is fully closed — everything beyond it gets no water.`,
      partIds: [valve.id],
      fix: 'Open the valve, or remove it if the branch is unused.',
    });
  }
  return findings;
}

// ---------- k. environment / room planning ----------

function roomEnvironment(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  for (const room of ctx.roomMetrics) {
    const roomPart = ctx.partsMap[room.roomId];
    const width = roomPart?.params.width ?? 0;
    const depth = roomPart?.params.depth ?? 0;
    const canopyArea = width * depth;

    if (!room.sealed && room.co2TankCount > 0) {
      findings.push({
        id: `room-co2-open:${room.roomId}`,
        severity: 'warning',
        title: 'CO2 enrichment wasted in open-air room',
        detail: `${room.label} is marked open air but has ${room.co2TankCount} CO2 tank${room.co2TankCount === 1 ? '' : 's'} — outside air exchange will purge enrichment before plants can use it.`,
        partIds: [room.roomId],
        fix: 'Seal the room or remove CO2 hardware.',
      });
    }

    if (room.sealed && room.airChangesPerMinute > 1) {
      findings.push({
        id: `room-sealed-exhaust:${room.roomId}`,
        severity: 'warning',
        title: 'Sealed room exhausting too aggressively',
        detail: `${room.label} is marked sealed but exhausts ${room.airChangesPerMinute.toFixed(2)} room volumes per minute — that behaves more like an open-air room and dumps conditioned CO2-rich air.`,
        partIds: [room.roomId],
        fix: 'Reduce exhaust CFM or switch the room to open air.',
      });
    }

    if (!room.sealed && room.airChangesPerMinute < 0.5) {
      findings.push({
        id: `room-vent-low:${room.roomId}`,
        severity: 'info',
        title: 'Low air exchange for open-air room',
        detail: `${room.label} exchanges only ${room.airChangesPerMinute.toFixed(2)} room volumes per minute — heat and humidity can linger unless intake/exhaust is stronger.`,
        partIds: [room.roomId],
        fix: 'Increase exhaust capacity or reduce room volume.',
      });
    }

    if (room.sealed && room.co2TankCount === 0 && room.lightWatts >= 600) {
      findings.push({
        id: `room-co2-missing:${room.roomId}`,
        severity: 'info',
        title: 'High-light sealed room without CO2',
        detail: `${room.label} is sealed and carries ${Math.round(room.lightWatts)} W of lighting but no CO2 source — the room can be enriched, but currently cannot take advantage of the sealed configuration.`,
        partIds: [room.roomId],
        fix: 'Add a CO2 tank or switch to open-air ventilation.',
      });
    }

    if (canopyArea > 0 && room.lightWatts > 0) {
      const wattsPerFt2 = room.lightWatts / canopyArea;
      if (wattsPerFt2 < 25) {
        findings.push({
          id: `room-light-low:${room.roomId}`,
          severity: 'info',
          title: 'Low lighting density',
          detail: `${room.label} provides ${wattsPerFt2.toFixed(1)} W/ft2 across ${canopyArea.toFixed(1)} ft2 — useful for propagation or low-light crops, but light-hungry plants will underperform.`,
          partIds: [room.roomId],
          fix: 'Add more fixture wattage or reduce active canopy area.',
        });
      } else if (wattsPerFt2 > 55) {
        findings.push({
          id: `room-light-high:${room.roomId}`,
          severity: 'warning',
          title: 'Very high lighting density',
          detail: `${room.label} is carrying ${wattsPerFt2.toFixed(1)} W/ft2 — that is intense enough to demand strong cooling, CO2 strategy, and careful canopy distance management.`,
          partIds: [room.roomId],
          fix: 'Raise fixtures, reduce wattage, or tighten environmental control.',
        });
      }
    }

    // New environment/lighting findings
    if (room.lightWatts > 0) {
      if (room.roomDLI < 10) {
        findings.push({
          id: `room-dli-low:${room.roomId}`,
          severity: 'warning',
          title: 'Daily Light Integral (DLI) is too low',
          detail: `${room.label} active DLI is ${room.roomDLI.toFixed(1)} — DLI < 10 is insufficient for healthy growth and will cause the crop to stretch.`,
          partIds: [room.roomId],
          fix: 'Increase grow lights wattage, increase photoperiod (hours on), or decrease room/canopy area.',
        });
      } else if (room.roomDLI > 45) {
        findings.push({
          id: `room-dli-high:${room.roomId}`,
          severity: 'warning',
          title: 'Daily Light Integral (DLI) is too high',
          detail: `${room.label} active DLI is ${room.roomDLI.toFixed(1)} — DLI > 45 risks phototoxic bleaching and leaf tissue damage.`,
          partIds: [room.roomId],
          fix: 'Reduce grow lights wattage, decrease photoperiod (hours on), or raise the fixtures.',
        });
      }
    }

    if (room.sealed && room.lightWatts > 400 && room.roomCo2 === 150) {
      findings.push({
        id: `room-co2-starved:${room.roomId}`,
        severity: 'warning',
        title: 'Sealed room CO₂ starvation risk',
        detail: `${room.label} is sealed and runs high-wattage lighting (${room.lightWatts.toFixed(0)} W > 400 W), but CO₂ levels drop to 150 PPM due to lack of a CO₂ tank.`,
        partIds: [room.roomId],
        fix: 'Add a CO₂ tank or switch to open-air ventilation.',
      });
    }

    const growthStage = useBuilder.getState().growthStage ?? 'vegetative';
    let minVpd = 0.8;
    let maxVpd = 1.6;
    if (growthStage === 'seedling') {
      minVpd = 0.4;
      maxVpd = 0.8;
    } else if (growthStage === 'vegetative') {
      minVpd = 0.8;
      maxVpd = 1.2;
    } else if (growthStage === 'flowering') {
      minVpd = 1.2;
      maxVpd = 1.6;
    }

    if (room.roomVPD < minVpd) {
      findings.push({
        id: `room-vpd-low:${room.roomId}`,
        severity: 'warning',
        title: 'Vapor Pressure Deficit (VPD) is too low',
        detail: `${room.label} VPD is ${room.roomVPD.toFixed(2)} kPa, which is below the optimal range of ${minVpd}-${maxVpd} kPa for the ${growthStage} stage. Low VPD slows transpiration and can cause nutrient deficiencies.`,
        partIds: [room.roomId],
        fix: 'Raise the temperature, lower relative humidity, or increase exhaust ventilation.',
      });
    } else if (room.roomVPD > maxVpd) {
      findings.push({
        id: `room-vpd-high:${room.roomId}`,
        severity: 'warning',
        title: 'Vapor Pressure Deficit (VPD) is too high',
        detail: `${room.label} VPD is ${room.roomVPD.toFixed(2)} kPa, which is above the optimal range of ${minVpd}-${maxVpd} kPa for the ${growthStage} stage. High VPD causes excessive transpiration, leading to plant stress and wilting.`,
        partIds: [room.roomId],
        fix: 'Lower the temperature, increase relative humidity, or reduce lighting intensity.',
      });
    }
  }
  return findings;
}

// ---------- registry ----------

/** All design-check rules, in execution order. Add new rules here. */
export const ALL_RULES: ValidationRule[] = [
  {
    id: 'pump-head',
    description: 'Pumps should keep ≥20% head margin below their max head.',
    run: pumpHeadMargin,
  },
  {
    id: 'pump-dead',
    description: 'Pumps that are off, starved of source water, or dead-ended.',
    run: pumpStarvedOrOff,
  },
  {
    id: 'diameter-mismatch',
    description: 'Joined connectors whose parts have different pipe diameters.',
    run: mismatchedDiameters,
  },
  {
    id: 'dead-leg',
    description: 'Flowing branches that terminate with no exit part (stagnation).',
    run: deadLegs,
  },
  {
    id: 'unsupported-span',
    description: 'Long elevated horizontal pipes with nothing beneath their ends.',
    run: unsupportedSpans,
  },
  {
    id: 'siphon',
    description: 'Flow paths that climb then descend ≥2 ft (siphon on shutdown).',
    run: siphonRisk,
  },
  {
    id: 'drain-capacity',
    description: 'Drains receiving more flow than their rated capacity.',
    run: undersizedDrains,
  },
  {
    id: 'net-pot-spill',
    description: 'Net pots positioned over backed-up wet lines that will spill from the rim.',
    run: netPotSpills,
  },
  {
    id: 'orphan',
    description: 'Flow-capable parts with no connections at all.',
    run: orphans,
  },
  {
    id: 'closed-valve',
    description: 'Fully closed valves on an otherwise powered circuit.',
    run: closedValves,
  },
  {
    id: 'room-environment',
    description: 'Grow-room ventilation, sealed/open-air behavior, CO2 use, and light density.',
    run: roomEnvironment,
  },
  {
    id: 'reservoir-chemistry',
    description: 'Reservoir temperature, pH, and EC/nutrient concentration values.',
    run: reservoirWaterChemistry,
  },
  {
    id: 'part-overlap',
    description: 'Parts that are overlapping or morphing into one another.',
    run: partOverlaps,
  },
];

function reservoirWaterChemistry(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  const reservoirs = ctx.parts.filter((p) => p.type === 'reservoir');

  for (const res of reservoirs) {
    const stats = computeReservoirWaterStats(res, ctx.partsMap);
    const runtime = ctx.sim?.reservoirRuntime?.[res.id];

    if (runtime?.empty) {
      findings.push({
        id: `res-empty:${res.id}`,
        severity: 'error',
        title: 'Reservoir runs dry under current load',
        detail: `${res.label || `Reservoir #${res.id}`} is fully depleted by the current pump/drain demand, so downstream flow stops entirely.`,
        partIds: [res.id],
        fix: 'Increase reservoir volume, reduce draw rate, or close the loop with return flow.',
      });
    } else if (runtime && runtime.minutesRemaining !== null && runtime.minutesRemaining < 30) {
      findings.push({
        id: `res-runtime-low:${res.id}`,
        severity: 'warning',
        title: 'Reservoir runtime is too short',
        detail: `${res.label || `Reservoir #${res.id}`} has only ${runtime.minutesRemaining.toFixed(1)} minutes of water left at the current net draw of ${runtime.netOutflowGph.toFixed(1)} GPH.`,
        partIds: [res.id],
        fix: 'Increase source volume, reduce pump flow, or return more water to this reservoir.',
      });
    }

    // 1. Water Temperature check
    if (stats.tempF > 73.0) {
      findings.push({
        id: `res-temp-high:${res.id}`,
        severity: 'warning',
        title: 'Reservoir water temperature too high',
        detail: `${res.label || `Reservoir #${res.id}`} water temperature is ${stats.tempF.toFixed(1)}°F — water above 73°F holds significantly less dissolved oxygen and increases Pythium (root rot) risks.`,
        partIds: [res.id],
        fix: 'Add a water chiller, reduce room ambient temperature, or turn off unneeded inline pumps.',
      });
    }

    // 2. pH check
    if (stats.ph < 5.5) {
      findings.push({
        id: `res-ph-low:${res.id}`,
        severity: 'warning',
        title: 'Water pH is too low (acidic)',
        detail: `${res.label || `Reservoir #${res.id}`} pH is ${stats.ph.toFixed(1)} — pH below 5.5 locks out Calcium, Magnesium, and Phosphorus, starving the plant.`,
        partIds: [res.id],
        fix: 'Add pH Up (potassium hydroxide) or dilute with fresh water to raise pH to 5.8 - 6.2.',
      });
    } else if (stats.ph > 6.5) {
      findings.push({
        id: `res-ph-high:${res.id}`,
        severity: 'warning',
        title: 'Water pH is too high (alkaline)',
        detail: `${res.label || `Reservoir #${res.id}`} pH is ${stats.ph.toFixed(1)} — pH above 6.5 locks out Iron, Manganese, Boron, and Zinc, causing leaf chlorosis.`,
        partIds: [res.id],
        fix: 'Add pH Down (phosphoric/citric acid) to lower pH to 5.8 - 6.2.',
      });
    }

    // 3. EC check
    const growthStage = useBuilder.getState().growthStage;
    let ecLow = 1.0;
    let ecHigh = 1.6;
    let fixLow = 'Add more concentrated nutrient solution (part A/B) to raise EC to 1.0 - 1.6 mS/cm.';
    let fixHigh = 'Dilute the reservoir with fresh water to reduce nutrient concentration (EC).';

    if (growthStage === 'seedling') {
      ecLow = 0.4;
      ecHigh = 0.8;
      fixLow = 'Add dilute nutrient solution to raise EC to 0.4 - 0.8 mS/cm for seedlings.';
      fixHigh = 'Dilute the reservoir with fresh water to lower EC to 0.4 - 0.8 mS/cm for seedlings.';
    } else if (growthStage === 'flowering') {
      ecLow = 1.5;
      ecHigh = 2.2;
      fixLow = 'Add bloom nutrients to raise EC to 1.5 - 2.2 mS/cm for flowering.';
      fixHigh = 'Dilute the reservoir with fresh water to lower EC to 1.5 - 2.2 mS/cm for flowering.';
    }

    if (stats.ec < ecLow) {
      findings.push({
        id: `res-ec-low:${res.id}`,
        severity: 'info',
        title: 'Low nutrient concentration (EC)',
        detail: `${res.label || `Reservoir #${res.id}`} EC is ${stats.ec.toFixed(1)} mS/cm — very low nutrient levels will limit growth rate and lead to deficiencies in the ${growthStage} stage.`,
        partIds: [res.id],
        fix: fixLow,
      });
    } else if (stats.ec > ecHigh) {
      findings.push({
        id: `res-ec-high:${res.id}`,
        severity: 'warning',
        title: 'High nutrient concentration (EC)',
        detail: `${res.label || `Reservoir #${res.id}`} EC is ${stats.ec.toFixed(1)} mS/cm — EC above ${ecHigh.toFixed(1)} risks nutrient burn or root dehydration in the ${growthStage} stage.`,
        partIds: [res.id],
        fix: fixHigh,
      });
    }
  }

  return findings;
}

function partOverlaps(ctx: RuleContext): Finding[] {
  const findings: Finding[] = [];
  const seen = new Set<string>();

  for (let i = 0; i < ctx.parts.length; i++) {
    const p1 = ctx.parts[i];

    for (let j = i + 1; j < ctx.parts.length; j++) {
      const p2 = ctx.parts[j];

      // Calculate distance between centers
      const dist = dist3(p1.position, p2.position);

      // If centers are extremely close (e.g. < 0.15 ft) and they occupy the same space
      if (dist < 0.15) {
        const key = [p1.id, p2.id].sort().join(':');
        if (seen.has(key)) continue;
        seen.add(key);

        findings.push({
          id: `part-overlap:${key}`,
          severity: 'warning',
          title: 'Overlapping parts (clipping)',
          detail: `${partName(p1)} and ${partName(p2)} are occupying the same space and morphing into each other.`,
          partIds: [p1.id, p2.id],
          fix: 'Delete the duplicate part or move them apart',
        });
      } else if (p1.type === 'pipe' && p2.type === 'pipe') {
        // Check for partial collinear overlap of two parallel pipes
        const yaw1 = p1.rotation[1];
        const yaw2 = p2.rotation[1];
        const angleDiff = Math.abs(Math.atan2(Math.sin(yaw1 - yaw2), Math.cos(yaw1 - yaw2)));
        const isParallel = angleDiff < 0.05 || Math.abs(angleDiff - Math.PI) < 0.05;

        if (isParallel) {
          const dirX = Math.cos(yaw1);
          const dirZ = -Math.sin(yaw1);

          const dx = p2.position[0] - p1.position[0];
          const dy = p2.position[1] - p1.position[1];
          const dz = p2.position[2] - p1.position[2];

          // Project distance along pipe vector and find lateral offset
          const proj = dx * dirX + dz * dirZ;
          const latX = dx - proj * dirX;
          const latZ = dz - proj * dirZ;
          const latDist = Math.hypot(latX, dy, latZ);

          if (latDist < 0.12) {
            const len1 = p1.params.length ?? 2;
            const len2 = p2.params.length ?? 2;
            const maxAllowedDist = (len1 + len2) / 2 - 0.05;

            if (dist < maxAllowedDist - 0.2) {
              const key = [p1.id, p2.id].sort().join(':');
              if (seen.has(key)) continue;
              seen.add(key);

              findings.push({
                id: `part-overlap:${key}`,
                severity: 'warning',
                title: 'Collinear pipes overlapping',
                detail: `${partName(p1)} and ${partName(p2)} are collinear but overlapping by ${(maxAllowedDist - dist).toFixed(1)} ft, causing them to morph together.`,
                partIds: [p1.id, p2.id],
                fix: 'Adjust their positions or delete one',
              });
            }
          }
        }
      }
    }
  }
  return findings;
}