import { describe, it, expect } from 'vitest';
import { runNetlist } from '../src/spice/SpiceEngine.js';

/**
 * SPICE behavior tests for each circuit example shipped in
 * frontend/src/data/examples-circuits.ts.
 *
 * Each test builds the netlist for the example's analog topology and verifies
 * voltages/currents match expectations. These tests guard against regressions
 * when component models change (e.g., LED Vf, BJT beta, op-amp Vsat).
 */

const NTC_R0 = 10000, NTC_T0 = 298.15, NTC_BETA = 3950;
function ntcR(Tc) {
  const T = Tc + 273.15;
  return NTC_R0 * Math.exp(NTC_BETA * (1 / T - 1 / NTC_T0));
}

// ════════════════════════════════════════════════════════════════════════════
// PASSIVE / ANALOG
// ════════════════════════════════════════════════════════════════════════════

describe('Example: voltage-divider', () => {
  it('R1=R2=10k → V_out = 2.5V (half of 5V)', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Voltage divider
V1 vcc 0 DC 5
R1 vcc out 10k
R2 out 0 10k
.op
.end`);
    expect(dcValue('v(out)')).toBeCloseTo(2.5, 2);
  });
});

describe('Example: rc-low-pass-filter', () => {
  it('PWM 50% duty avg = 2.5V, RC=100ms filters to ~2.5V DC', { timeout: 30_000 }, async () => {
    // Simulate steady-state DC equivalent: PWM avg = 2.5V → R → output (open in DC)
    const { dcValue } = await runNetlist(`RC low-pass DC equivalent
V1 in 0 DC 2.5
R1 in out 10k
Rload out 0 10Meg
.op
.end`);
    expect(dcValue('v(out)')).toBeCloseTo(2.5, 1);
  });
});

describe('Example: wheatstone-bridge', () => {
  it('Unbalanced bridge (R3=11k vs R4=10k) gives ~119mV diff', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Wheatstone unbalanced
V1 vcc 0 DC 5
R1 vcc a 10k
R2 vcc b 10k
R3 a 0 11k
R4 b 0 10k
.op
.end`);
    const diff = dcValue('v(a)') - dcValue('v(b)');
    expect(diff).toBeGreaterThan(0.10);
    expect(diff).toBeLessThan(0.14);
  });
});

describe('Example: ntc-temperature', () => {
  for (const T of [0, 25, 50]) {
    it(`T=${T}°C → V depends on NTC R(T)`, { timeout: 30_000 }, async () => {
      const r = ntcR(T);
      const { dcValue } = await runNetlist(`NTC at ${T}C
V1 vcc 0 DC 5
Rpull vcc out 10k
Rntc out 0 ${r}
.op
.end`);
      const v = dcValue('v(out)');
      const expected = 5 * r / (10000 + r);
      expect(v).toBeCloseTo(expected, 2);
    });
  }
});

describe('Example: led-current-limiting', () => {
  it('5V through 330Ω + LED → V_anode in typical Vf range', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`LED with 330R
V1 vcc 0 DC 5
R1 vcc anode 330
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=1.8 Rs=1)
.op
.end`);
    const va = dcValue('v(anode)');
    // Generic-diode model gives Vf ≈ 0.7–1.5V depending on current. The
    // current is well-defined: I ≈ (5 − Vf)/330 ≈ 10–13 mA.
    expect(va).toBeGreaterThan(0.7);
    expect(va).toBeLessThan(2.5);
  });
});

describe('Example: parallel-resistors', () => {
  it('3× 10k in parallel = 3.33k → V_out = 5·3.33/(10+3.33) = 1.25V', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Parallel R
V1 vcc 0 DC 5
Rs vcc mid 10k
R1 mid 0 10k
R2 mid 0 10k
R3 mid 0 10k
.op
.end`);
    expect(dcValue('v(mid)')).toBeCloseTo(1.25, 2);
  });
});

describe('Example: pot-adc-reader', () => {
  it('Potentiometer at 50% = 2.5V', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Pot at 50%
V1 vcc 0 DC 5
Rtop vcc wiper 5k
Rbot wiper 0 5k
.op
.end`);
    expect(dcValue('v(wiper)')).toBeCloseTo(2.5, 2);
  });
});

describe('Example: photoresistor-light', () => {
  it('LDR at 500 lux + 10k pull-down', { timeout: 30_000 }, async () => {
    // LDR: R(lux) = 1M / (1 + 5*500/1000) = 1M/3.5 ≈ 286k
    const Rldr = 1e6 / (1 + 5 * 500 / 1000);
    const { dcValue } = await runNetlist(`LDR
V1 vcc 0 DC 5
Rldr vcc sig ${Rldr}
Rpull sig 0 10k
.op
.end`);
    const expected = 5 * 10000 / (Rldr + 10000);
    expect(dcValue('v(sig)')).toBeCloseTo(expected, 2);
  });
});

describe('Example: capacitor-charge-curve', () => {
  it('RC charging: V(τ) ≈ 63% of V_supply', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`RC charge
V1 vcc 0 PULSE(0 5 0 1n 1n 10 20)
R1 vcc out 10k
C1 out 0 100u IC=0
.tran 10m 3
.ic v(out)=0
.end`);
    const t = vec('time');
    const v = vec('v(out)');
    const tau = 10000 * 100e-6; // 1s
    let bestI = 0, dist = Infinity;
    for (let i = 0; i < t.length; i++) {
      if (Math.abs(t[i] - tau) < dist) { dist = Math.abs(t[i] - tau); bestI = i; }
    }
    expect(v[bestI]).toBeGreaterThan(5 * (1 - 1/Math.E) * 0.95);
    expect(v[bestI]).toBeLessThan(5 * (1 - 1/Math.E) * 1.05);
  });
});

describe('Example: multi-led-bar', () => {
  it('LED + 220Ω at 5V conducts ~14 mA', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`LED 220R
V1 vcc 0 DC 5
R1 vcc anode 220
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=1.8 Rs=1)
.op
.end`);
    const i = Math.abs(vec('i(v1)')[0]);
    expect(i).toBeGreaterThan(0.005);
    expect(i).toBeLessThan(0.020);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// TRANSISTOR / SEMICONDUCTOR
// ════════════════════════════════════════════════════════════════════════════

describe('Example: npn-led-switch', () => {
  it('2N2222 ON: collector pulled to ~0V', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`NPN switch
V1 vcc 0 DC 5
Vdrv drv 0 DC 5
RB drv b 1k
RC vcc c 220
Q1 c b 0 Q2N2222
.model Q2N2222 NPN(Is=14.34f Bf=200 Vaf=74)
.op
.end`);
    expect(dcValue('v(c)')).toBeLessThan(0.5);
  });
});

describe('Example: pnp-high-side-switch', () => {
  it('2N3906 ON when base LOW: load voltage near Vcc', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`PNP high-side
V1 vcc 0 DC 5
Vdrv drv 0 DC 0
RB drv b 1k
Q1 c b vcc Q2N3906
RL c 0 220
.model Q2N3906 PNP(Is=1.41f Bf=180 Vaf=18.7)
.op
.end`);
    expect(dcValue('v(c)')).toBeGreaterThan(4.0);
  });
});

describe('Example: mosfet-pwm-led', () => {
  it('2N7000 with Vgs=5V drives load, drain low', { timeout: 30_000 }, async () => {
    // 220Ω load + low W/L → drain ≈ 1.2V (still well below 5V → fully ON)
    const { dcValue } = await runNetlist(`NMOS switch
V1 vcc 0 DC 5
Vg gate 0 DC 5
RL vcc drain 220
M1 drain gate 0 0 NMOS L=2u W=200u
.model NMOS NMOS(Level=1 Vto=1.6 Kp=50u)
.op
.end`);
    expect(dcValue('v(drain)')).toBeLessThan(2.0);
  });
});

describe('Example: diode-rectifier', () => {
  it('Half-wave: positive cycle passes, negative blocked', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`Half-wave rectifier
V1 in 0 SIN(0 5 50)
D1 in out DRECT
RL out 0 1k
.model DRECT D(Is=1e-14 N=1)
.tran 0.1m 40m
.end`);
    const t = vec('time');
    const vout = vec('v(out)');
    let posMax = -Infinity, negMin = Infinity;
    for (let i = 0; i < t.length; i++) {
      if (t[i] < 20e-3) continue;
      if (vout[i] > posMax) posMax = vout[i];
      if (vout[i] < negMin) negMin = vout[i];
    }
    expect(posMax).toBeGreaterThan(3.5);
    expect(negMin).toBeGreaterThan(-0.2); // negative blocked
  });
});

describe('Example: zener-regulator', () => {
  it('5.1V Zener clamps output regardless of input variation', { timeout: 30_000 }, async () => {
    for (const vin of [7, 9, 12]) {
      const { dcValue } = await runNetlist(`Zener V_in=${vin}
V1 vin 0 DC ${vin}
Rs vin out 220
Dz 0 out DZ
.model DZ D(Is=1n N=1 Rs=5 Bv=5.1 Ibv=50m)
.op
.end`);
      const v = dcValue('v(out)');
      expect(v).toBeGreaterThan(4.8);
      expect(v).toBeLessThan(5.4);
    }
  });
});

describe('Example: schottky-reverse-protection', () => {
  it('1N5817 forward Vf < 0.5V at 100mA', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Schottky forward
V1 in 0 DC 5
Rs in d 47
D1 d 0 D1N5817
.model D1N5817 D(Is=3.3u N=1 Rs=0.025)
.op
.end`);
    const vf = dcValue('v(d)');
    expect(vf).toBeLessThan(0.5);
  });
});

describe('Example: bjt-common-emitter', () => {
  it('Common-emitter biased at Vcc/2, gain × small AC input', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`CE amp DC bias
V1 vcc 0 DC 5
RB1 vcc b 47k
RB2 b 0 10k
RC vcc c 4.7k
RE e 0 1k
Q1 c b e Q2N2222
.model Q2N2222 NPN(Is=14.34f Bf=200 Vaf=74)
.op
.end`);
    const vc = dcValue('v(c)');
    // Should be biased somewhere in mid-range (not saturated, not cutoff)
    expect(vc).toBeGreaterThan(1.0);
    expect(vc).toBeLessThan(4.5);
  });
});

describe('Example: darlington-high-current', () => {
  it('Darlington saturates with very small base current', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Darlington
V1 vcc 0 DC 5
Vdrv drv 0 DC 5
RB drv b 100k
RC vcc c 100
Q1 c b e1 Q2N2222
Q2 c e1 0 Q2N2222
.model Q2N2222 NPN(Is=14.34f Bf=200 Vaf=74)
.op
.end`);
    expect(dcValue('v(c)')).toBeLessThan(2.0);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// OP-AMP
// ════════════════════════════════════════════════════════════════════════════

describe('Example: opamp-inverting', () => {
  it('LM358 inverter gain=-10: Vin=0.2V → Vout=2.5−2*(0.2−2.5)=2.5+0.5×... approx', { timeout: 30_000 }, async () => {
    // Using ideal op-amp for clean test
    const { dcValue } = await runNetlist(`Inverter
V1 vin 0 DC 0.2
Rin vin n 1k
Rf n out 10k
E1 out 0 0 n 1e6
.op
.end`);
    expect(dcValue('v(out)')).toBeCloseTo(-2.0, 1);
  });
});

describe('Example: opamp-voltage-follower', () => {
  it('Follower: Vout tracks Vin exactly', { timeout: 30_000 }, async () => {
    for (const vin of [1.0, 2.5, 4.0]) {
      const { dcValue } = await runNetlist(`Follower vin=${vin}
V1 vin 0 DC ${vin}
E1 out 0 vin out 1e6
.op
.end`);
      expect(dcValue('v(out)')).toBeCloseTo(vin, 2);
    }
  });
});

describe('Example: opamp-comparator', () => {
  it('Comparator: V+ > V- → output HIGH; V+ < V- → output LOW', { timeout: 30_000 }, async () => {
    const Vcc = 5;
    const A = 1e5;
    const vHi = Vcc - 1.5;
    const vLo = 0.05;
    // Test 1: input above threshold
    const r1 = await runNetlist(`Comparator HIGH
V_pos vp 0 DC 3
V_ref vr 0 DC 2.5
B1 out 0 V = max(${vLo}, min(${vHi}, ${A}*(V(vp)-V(vr))))
Rload out 0 1Meg
.op
.end`);
    expect(r1.dcValue('v(out)')).toBeGreaterThan(3);
    // Test 2: input below threshold
    const r2 = await runNetlist(`Comparator LOW
V_pos vp 0 DC 2
V_ref vr 0 DC 2.5
B1 out 0 V = max(${vLo}, min(${vHi}, ${A}*(V(vp)-V(vr))))
Rload out 0 1Meg
.op
.end`);
    expect(r2.dcValue('v(out)')).toBeLessThan(0.2);
  });
});

describe('Example: opamp-difference', () => {
  it('Diff amp gain=10: V_out = 10·(V2−V1)', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Diff amp
V1 v1 0 DC 0.5
V2 v2 0 DC 0.3
R1 v1 n 10k
R2 n out 100k
R3 v2 p 10k
R4 p 0 100k
E1 out 0 p n 1e6
.op
.end`);
    expect(dcValue('v(out)')).toBeCloseTo(-2.0, 1);
  });
});

describe('Example: opamp-schmitt-trigger', () => {
  it('Non-inverting Schmitt with Rin=10k Rfb=100k flips at ±1V', { timeout: 30_000 }, async () => {
    // Test: input above hi threshold → output HIGH
    const { dcValue } = await runNetlist(`Schmitt HIGH input
Vin in 0 DC 3
Rin in p 10k
Rfb p out 100k
B1 out 0 V = 20 * u(V(p)) - 10
Rload out 0 1Meg
.op
.end`);
    expect(dcValue('v(out)')).toBeGreaterThan(5);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// LOGIC GATES
// ════════════════════════════════════════════════════════════════════════════

describe('Example: and-gate-alarm', () => {
  it('AND truth table: HIGH only when both inputs HIGH', { timeout: 30_000 }, async () => {
    for (const [a, b, exp] of [[0,0,0],[0,5,0],[5,0,0],[5,5,5]]) {
      const { dcValue } = await runNetlist(`AND
Va a 0 DC ${a}
Vb b 0 DC ${b}
B1 y 0 V = 5 * u(V(a)-2.5) * u(V(b)-2.5)
Rload y 0 1Meg
.op
.end`);
      expect(dcValue('v(y)')).toBeCloseTo(exp, 0);
    }
  });
});

describe('Example: xor-toggle-detector', () => {
  it('XOR truth table', { timeout: 30_000 }, async () => {
    for (const [a, b, exp] of [[0,0,0],[5,0,5],[0,5,5],[5,5,0]]) {
      const { dcValue } = await runNetlist(`XOR
Va a 0 DC ${a}
Vb b 0 DC ${b}
B1 y 0 V = 5 * (u(V(a)-2.5) + u(V(b)-2.5) - 2*u(V(a)-2.5)*u(V(b)-2.5))
Rload y 0 1Meg
.op
.end`);
      expect(dcValue('v(y)')).toBeCloseTo(exp, 0);
    }
  });
});

describe('Example: nand-sr-latch', () => {
  it('NAND truth table', { timeout: 30_000 }, async () => {
    for (const [a, b, exp] of [[0,0,5],[0,5,5],[5,0,5],[5,5,0]]) {
      const { dcValue } = await runNetlist(`NAND
Va a 0 DC ${a}
Vb b 0 DC ${b}
B1 y 0 V = 5 * (1 - u(V(a)-2.5) * u(V(b)-2.5))
Rload y 0 1Meg
.op
.end`);
      expect(dcValue('v(y)')).toBeCloseTo(exp, 0);
    }
  });
});

describe('Example: full-adder', () => {
  it('Sum = A XOR B XOR Cin, Cout = AB + Cin(A XOR B)', { timeout: 90_000 }, async () => {
    const cases = [
      { a: 0, b: 0, cin: 0, sum: 0, cout: 0 },
      { a: 0, b: 0, cin: 5, sum: 5, cout: 0 },
      { a: 5, b: 5, cin: 0, sum: 0, cout: 5 },
      { a: 5, b: 5, cin: 5, sum: 5, cout: 5 },
    ];
    const G = `
.subckt XOR_G a b y
B y 0 V = 5 * (u(V(a)-2.5) + u(V(b)-2.5) - 2*u(V(a)-2.5)*u(V(b)-2.5))
Rl y 0 1Meg
.ends
.subckt AND_G a b y
B y 0 V = 5 * u(V(a)-2.5) * u(V(b)-2.5)
Rl y 0 1Meg
.ends
.subckt OR_G a b y
B y 0 V = 5 * (1 - (1-u(V(a)-2.5)) * (1-u(V(b)-2.5)))
Rl y 0 1Meg
.ends`;
    for (const c of cases) {
      const { dcValue } = await runNetlist(`Full adder
Va a 0 DC ${c.a}
Vb b 0 DC ${c.b}
Vcin cin 0 DC ${c.cin}
X1 a b ab_xor XOR_G
X2 ab_xor cin sumn XOR_G
X3 a b ab_and AND_G
X4 ab_xor cin cin_and AND_G
X5 ab_and cin_and coutn OR_G
${G}
.op
.end`);
      expect(dcValue('v(sumn)')).toBeCloseTo(c.sum, 0);
      expect(dcValue('v(coutn)')).toBeCloseTo(c.cout, 0);
    }
  });
});

describe('Example: binary-counter-leds', () => {
  it('LED + 220Ω driven HIGH conducts', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`Counter LED
V1 pin 0 DC 5
R1 pin anode 220
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=1.8 Rs=1)
.op
.end`);
    const i = Math.abs(vec('i(v1)')[0]);
    expect(i).toBeGreaterThan(0.005);
  });
});

describe('Example: logic-probe', () => {
  it('Green LED conducts when pin12 HIGH', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Green LED
V1 pin12 0 DC 5
R1 pin12 anode 220
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=2.0 Rs=1)
.op
.end`);
    const va = dcValue('v(anode)');
    expect(va).toBeGreaterThan(1.0);
    expect(va).toBeLessThan(3.0);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// ELECTROMECHANICAL
// ════════════════════════════════════════════════════════════════════════════

describe('Example: relay-led-switch', () => {
  it('Relay coil energised at 5V draws ~71mA through 70Ω', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`Relay coil
V1 cp 0 DC 5
R_coil cp 0 70
.op
.end`);
    const i = Math.abs(vec('i(v1)')[0]);
    expect(i).toBeGreaterThan(0.06);
    expect(i).toBeLessThan(0.08);
  });
});

describe('Example: optocoupler-signal', () => {
  it('Optocoupler 4N25 with LED ON: phototransistor conducts (CTR=0.5)', { timeout: 30_000 }, async () => {
    const { dcValue, vec } = await runNetlist(`4N25 ON
Vin vin 0 DC 5
Rled vin an 270
Vcat cat 0 DC 0
Vcc vcc 0 DC 5
Rload vcc col 470
Vemit emit 0 DC 0
Dled an mid DLED
Vsense mid cat DC 0
F_pt col emit Vsense 0.5
Rleak col emit 100Meg
.model DLED D(Is=1e-14 N=2 Rs=5)
.op
.end`);
    const iLed = Math.abs(vec('i(vsense)')[0]);
    const vcol = dcValue('v(col)');
    expect(iLed).toBeGreaterThan(0.005);
    expect(vcol).toBeLessThan(3.5);
  });
});

describe('Example: l293d-motor-control', () => {
  it('L293D forward: OUT1=Vmotor, OUT2=0', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`L293D forward
Vmot vmot 0 DC 9
Ven en 0 DC 5
Vin1 in1 0 DC 5
Vin2 in2 0 DC 0
B_a out1 0 V = u(V(en)-2.5) * u(V(in1)-2.5) * V(vmot)
B_b out2 0 V = u(V(en)-2.5) * u(V(in2)-2.5) * V(vmot)
R_a out1 0 10Meg
R_b out2 0 10Meg
Rmotor out1 out2 10
.op
.end`);
    expect(dcValue('v(out1)')).toBeGreaterThan(7);
    expect(dcValue('v(out2)')).toBeLessThan(2);
  });
});

describe('Example: l293d-speed-pwm', () => {
  it('L293D with EN=PWM (avg 50%): output averages V_motor/2', { timeout: 30_000 }, async () => {
    // DC equivalent of PWM 50%: EN sees 2.5V (average) → at threshold
    // Use EN=5V (representing PWM HIGH duty 100%) to verify full-on case
    const { dcValue } = await runNetlist(`L293D speed
Vmot vmot 0 DC 9
Ven en 0 DC 5
Vin in 0 DC 5
B_o out 0 V = u(V(en)-2.5) * u(V(in)-2.5) * V(vmot)
R_o out 0 10Meg
.op
.end`);
    expect(dcValue('v(out)')).toBeCloseTo(9, 1);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// POWER / REGULATOR
// ════════════════════════════════════════════════════════════════════════════

describe('Example: power-supply-7805', () => {
  it('7805 with V_in=9V → V_out=5V', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`7805
Vin vin 0 DC 9
B_u1 vout 0 V = min(V(vin)-V(0)-2, 5)
R_load vout 0 1k
.op
.end`);
    expect(dcValue('v(vout)')).toBeCloseTo(5, 1);
  });

  it('7805 dropout when V_in too low', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`7805 dropout
Vin vin 0 DC 4
B_u1 vout 0 V = min(V(vin)-V(0)-2, 5)
R_load vout 0 1k
.op
.end`);
    expect(dcValue('v(vout)')).toBeLessThan(3);
  });
});

describe('Example: lm317-adjustable-psu', () => {
  it('LM317 with R1=240, R2=720: V_out ≈ 5V', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`LM317
Vin vin 0 DC 12
B_u1 vout 0 V = V(adj) + min(V(vin)-V(adj)-2, 1.25)
R1 vout adj 240
R2 adj 0 720
Rload vout 0 10k
.op
.end`);
    expect(dcValue('v(vout)')).toBeCloseTo(5, 1);
  });
});

describe('Example: battery-voltage-monitor', () => {
  it('20k+10k divider scales 9V → 3V into ADC', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`Battery monitor
Vbat vbat 0 DC 9
R1 vbat mid 20k
R2 mid 0 10k
.op
.end`);
    expect(dcValue('v(mid)')).toBeCloseTo(3.0, 2);
  });
});

// ════════════════════════════════════════════════════════════════════════════
// ESP32 / MEGA / NANO board-specific
// ════════════════════════════════════════════════════════════════════════════

describe('Example: esp32-dual-adc', () => {
  it('Two pots at 3.3V supply: each leg is independent', { timeout: 30_000 }, async () => {
    const { dcValue } = await runNetlist(`ESP32 dual pot
V1 vcc 0 DC 3.3
Rt1 vcc s1 5k
Rb1 s1 0 5k
Rt2 vcc s2 3k
Rb2 s2 0 7k
.op
.end`);
    expect(dcValue('v(s1)')).toBeCloseTo(1.65, 2);
    expect(dcValue('v(s2)')).toBeCloseTo(2.31, 2);
  });
});

describe('Example: mega-multi-led', () => {
  it('Mega 5V LED with 220Ω limit', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`Mega LED
V1 pin 0 DC 5
R1 pin anode 220
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=1.8 Rs=1)
.op
.end`);
    expect(Math.abs(vec('i(v1)')[0])).toBeGreaterThan(0.005);
  });
});

describe('Example: nano-sensor-station', () => {
  for (const T of [10, 25, 40]) {
    it(`Nano NTC at ${T}°C: V_out depends on R_ntc`, { timeout: 30_000 }, async () => {
      const r = ntcR(T);
      const { dcValue } = await runNetlist(`Nano NTC
V1 vcc 0 DC 5
Rntc vcc out ${r}
Rpull out 0 10k
.op
.end`);
      const expected = 5 * 10000 / (r + 10000);
      expect(dcValue('v(out)')).toBeCloseTo(expected, 2);
    });
  }
});

describe('Example: esp32-pwm-led-rgb', () => {
  it('RGB LED full red @3.3V through 220Ω: red anode conducts', { timeout: 30_000 }, async () => {
    const { vec } = await runNetlist(`RGB red full
V1 pin 0 DC 3.3
R1 pin anode 220
D1 anode 0 DLED
.model DLED D(Is=1e-14 N=1.8 Rs=1)
.op
.end`);
    const i = Math.abs(vec('i(v1)')[0]);
    expect(i).toBeGreaterThan(0.001);
    expect(i).toBeLessThan(0.012);
  });
});