// Simplified plasma toroid physics model (pure ESM, no three.js).
// All equations and constants follow .agents/tasks/plan.md.
// Educational approximation only — not engineering guidance.

export const clamp = (x, lo, hi) => Math.min(hi, Math.max(lo, x));

export function smoothstep(e0, e1, x) {
  const t = clamp((x - e0) / (e1 - e0), 0, 1);
  return t * t * (3 - 2 * t);
}

// Soft window: 1 inside [a, b], fading to 0 over ~15 % outside each edge.
export function windowFn(x, a, b) {
  return smoothstep(a * 0.85, a, x) * (1 - smoothstep(b, b * 1.15, x));
}

// Townsend/Paschen coefficients A (1/cm/Torr), B (V/cm/Torr), first ionization energy,
// glow color and empirical mode thresholds (pressures in Torr, powers in W).
export const GASES = {
  He: { name: 'Helium',  A: 3,  B: 34,  ionization_eV: 24.59, color: '#ffb08a', pRingMin: 1.0,  pRingPower: 60, pBean: null, n0: null },
  Ne: { name: 'Neon',    A: 4,  B: 100, ionization_eV: 21.56, color: '#ff4d6d', pRingMin: 0.5,  pRingPower: 45, pBean: 2.5,  n0: 14 },
  Ar: { name: 'Argon',   A: 12, B: 180, ionization_eV: 15.76, color: '#b46cff', pRingMin: 0.2,  pRingPower: 25, pBean: 3.0,  n0: 12 },
  Kr: { name: 'Krypton', A: 17, B: 240, ionization_eV: 14.0,  color: '#d9d4ff', pRingMin: 0.1,  pRingPower: 18, pBean: 1.8,  n0: 12 },
  Xe: { name: 'Xenon',   A: 26, B: 350, ionization_eV: 12.13, color: '#8f7bff', pRingMin: 0.08, pRingPower: 15, pBean: 1.2,  n0: 13 },
};

// Bead-count limits for the plasma-bean ring.
export const BEAD_MIN = 6;
export const BEAD_MAX = 32;

// dFactor: characteristic discharge length / vessel diameter (torus = tube bore).
export const SHAPES = {
  sphere:   { name: 'Sphere',         dFactor: 1.0,  coupling: 0.7,  beanShift: 1.0 },
  cylinder: { name: 'Cylinder',       dFactor: 1.0,  coupling: 0.65, beanShift: 1.1 },
  torus:    { name: 'Torus (donut)',  dFactor: 0.38, coupling: 0.8,  beanShift: 0.9 },
};

export const COOLING_OPTIONS = {
  none: 'None',
  heatsink: 'Heatsink',
  fan: 'Heatsink + fan',
};

export const PARAM_RANGES = {
  shape:             { options: Object.keys(SHAPES), default: 'sphere', unit: '' },
  vesselDiameter_mm: { min: 60, max: 130, step: 5, default: 80, unit: 'mm' },
  gas:               { options: Object.keys(GASES), default: 'Xe', unit: '' },
  pressure_torr:     { min: 0.01, max: 10, step: null, log: true, default: 0.5, unit: 'Torr' },
  supplyVoltage_V:   { min: 6, max: 36, step: 0.5, default: 24, unit: 'V' },
  frequency_MHz:     { min: 5, max: 20, step: 0.1, default: 12, unit: 'MHz' },
  coilTurns:         { min: 2, max: 8, step: 1, default: 4, unit: 'turns' },
  drive_pct:         { min: 0, max: 100, step: 1, default: 70, unit: '%' },
  currentLimit_A:    { min: 1, max: 5, step: 0.1, default: 3.5, unit: 'A' },
  ambient_C:         { min: 0, max: 40, step: 1, default: 25, unit: '°C' },
  cooling:           { options: Object.keys(COOLING_OPTIONS), default: 'fan', unit: '' },
  mosfetLimit_C:     { min: 80, max: 175, step: 1, default: 125, unit: '°C' },
  autoShutdown:      { type: 'boolean', default: true },
  autoIgnite:        { type: 'boolean', default: true },
  timeSpeed:         { options: [1, 2, 5, 10, 30, 60], default: 1, unit: '×' },
};

// Circuit constants.
export const Q_TANK = 4;
export const R_EQ = 6; // Ω, equivalent load seen by the supply
export const GAMMA = 0.01; // secondary emission coefficient
const LN_LN_GAMMA = Math.log(Math.log(1 + 1 / GAMMA)); // ≈ 1.529
export const SPARK_FACTOR = 0.6; // spark-assisted ignition threshold (× V_b)
export const SUSTAIN_FACTOR = 0.55; // sustain threshold once lit (× V_b)
export const RDS_TEMPCO = 0.004; // MOSFET loss rise per °C of junction temperature above 25 °C (R_ds(on) derating)

/** Resonant frequency of the tank in MHz (L = 0.125 µH·N², 4 turns → 12 MHz). */
export const resonanceMHz = (N) => 12 * (4 / N);

/** Raizer-form Paschen breakdown voltage (V). Infinity left of the Paschen curve. */
export function breakdownVoltage(gas, p_torr, d_cm) {
  const g = typeof gas === 'string' ? GASES[gas] : gas;
  const pd = p_torr * d_cm;
  if (!(pd > 0)) return Infinity;
  const den = Math.log(g.A * pd) - LN_LN_GAMMA;
  if (den <= 0.05) return Infinity;
  return (g.B * pd) / den;
}

/** Ignition / sustain state machine step. Returns the new lit state. */
export function ignitionCheck({ lit, sparkActive, driverOn, V_coil, V_b }) {
  if (!driverOn || !Number.isFinite(V_b)) return false;
  if (lit) return V_coil >= SUSTAIN_FACTOR * V_b;
  return V_coil >= V_b || (!!sparkActive && V_coil >= SPARK_FACTOR * V_b);
}

/**
 * Compute the electrical operating point, losses, plasma state and visual targets.
 * @param {object} params  simulation parameters (see PARAM_RANGES keys)
 * @param {{lit?:boolean, driverOn?:boolean, tempJ?:number, mosfetFailed?:boolean}} st
 */
export function computeOperatingPoint(params, { lit = false, driverOn = true, tempJ = 25, mosfetFailed = false } = {}) {
  const gas = GASES[params.gas];
  const shape = SHAPES[params.shape];
  const Vs = params.supplyVoltage_V;
  const f = params.frequency_MHz;
  const N = params.coilTurns;
  const p = params.pressure_torr;
  const D = params.vesselDiameter_mm;
  const u = clamp(params.drive_pct / 100, 0, 1);
  const on = driverOn && !mosfetFailed;
  const isLit = on && lit;

  const f0 = resonanceMHz(N);
  const g = 1 / Math.sqrt(1 + (Q_TANK * (f / f0 - f0 / f)) ** 2);

  const V_coil = on ? 36 * Vs * u * g * Math.sqrt(N / 4) : 0;
  const L = 0.125e-6 * N * N;
  const I_coil = V_coil / (2 * Math.PI * f * 1e6 * L);

  const d_cm = (D / 10) * shape.dFactor;
  const V_b = breakdownVoltage(gas, p, d_cm);

  const P_lim = Vs * params.currentLimit_A;
  const P_demand = on ? ((Vs * u) ** 2 / R_EQ) * (0.3 + 0.7 * g) * (isLit ? 1.3 : 1.0) : 0;
  const P_in = Math.min(P_demand, P_lim);
  const currentLimited = on && P_demand > P_lim;
  const I_in = Vs > 0 ? P_in / Vs : 0;

  const eta = clamp(0.8 - 0.025 * (f - 8), 0.55, 0.85);
  const P_mos0 = P_in * (1 - eta); // MOSFET loss at T_j = 25 °C
  const P_mos = P_mos0 * (1 + RDS_TEMPCO * (tempJ - 25));
  const P_plasma = isLit ? P_in * eta * shape.coupling : 0;
  const R_ac = 0.05 * (N / 4) * Math.sqrt(f / 10);
  const P_coil = I_coil * I_coil * R_ac + 0.04 * P_plasma;
  const P_glass = 0.6 * P_plasma;

  const B = clamp(P_plasma / 60, 0, 1.5);
  const m_s = Number.isFinite(V_b) ? V_coil / (SUSTAIN_FACTOR * V_b) : 0;
  const inst = isLit
    ? clamp(Math.max((1.15 - m_s) / 0.15, (0.6 - g) / 0.3, currentLimited && P_demand > 1.25 * P_lim ? 0.6 : 0), 0, 1)
    : 0;

  const pb = gas.pBean != null ? gas.pBean * shape.beanShift : null;

  // Plasma state (priority order).
  let state;
  let reason = '';
  if (!isLit) {
    state = 'off';
    if (mosfetFailed) reason = 'MOSFET failed';
    else if (!driverOn) reason = 'driver off';
    else if (!Number.isFinite(V_b)) reason = 'pressure too low to break down (left of Paschen minimum)';
    else if (V_coil < V_b) reason = `below breakdown: need ${Math.round(V_b)} V, have ${Math.round(V_coil)} V`;
    else reason = 'not ignited';
  } else if (inst >= 0.5) {
    state = 'unstable';
    reason = g < 0.6 ? 'detuned from resonance' : m_s < 1.15 ? 'barely sustained' : 'overdriven / current limited';
  } else if (p < gas.pRingMin || P_plasma < gas.pRingPower) {
    state = 'diffuse';
    reason = p < gas.pRingMin ? 'pressure below ring threshold' : 'plasma power below ring threshold';
  } else if (pb != null && p >= pb && P_plasma >= 20 && P_plasma <= 80) {
    state = 'bean';
  } else {
    state = 'ring';
  }

  // Beads only show in the 'bean' state (keeps the visuals consistent with the HUD): half-formed at p_bean,
  // fully formed by 1.1 × p_bean.
  const beanMix = state === 'bean' ? 0.5 + 0.5 * smoothstep(pb, 1.1 * pb, p) : 0;
  // Azimuthal mode number m ∝ √(p·D) (striation length shrinks with p·R), weak power term.
  const beadCount = pb != null
    ? clamp(Math.round(gas.n0 * Math.sqrt((p / pb) * (D / 80)) * (P_plasma / 40) ** 0.3), BEAD_MIN, BEAD_MAX)
    : BEAD_MIN; // no bean mode for this gas; minimum keeps shader math finite

  const Bc = Math.min(B, 1);
  let ringRadiusFrac, ringHeightFrac;
  if (params.shape === 'sphere') {
    ringRadiusFrac = 0.62 - 0.08 * B;
    ringHeightFrac = -0.35 + 0.25 * Bc;
  } else if (params.shape === 'cylinder') {
    ringRadiusFrac = 0.6;
    ringHeightFrac = -0.6 + 0.2 * Bc;
  } else {
    ringRadiusFrac = 1.0; // torus: fraction of the major radius
    ringHeightFrac = 0;
  }

  // minorFrac in vessel-radius units; torus capped at 0.8 × tube radius (tube = 0.3 R).
  let minorFrac = clamp(0.12 * (0.5 / p) ** 0.35, 0.03, 0.35);
  if (params.shape === 'torus') minorFrac = Math.min(minorFrac, 0.8 * 0.3);

  const rotSpeed = 0.4 + 2.5 * B * Math.sqrt(f / 10);
  const beadSpeed = 0.6 * rotSpeed;
  const wobble = 0.02 + 0.15 * inst;
  const flicker = inst;
  const columnStretch = params.shape === 'cylinder' && (state === 'diffuse' || p > 2) ? 1 + 1.5 * Bc : 1;
  const diffuseAmount = { diffuse: 1.0, unstable: 0.5, ring: 0.15, bean: 0.1, off: 0 }[state];

  return {
    g, f0, V_coil, I_coil, V_b, P_demand, P_in, I_in, currentLimited, eta, P_mos, P_mos0, P_coil, P_glass, P_plasma,
    B, inst, state, reason, beanMix, beadCount, ringRadiusFrac, ringHeightFrac, minorFrac, rotSpeed, beadSpeed,
    wobble, flicker, columnStretch, diffuseAmount, color: gas.color,
  };
}