/**
 * Tests for settler specificClass (domain logic).
 *
 * The Settler class is a simple mass-balance separator:
 *  - Splits influent into effluent (clarified), surplus sludge, and return sludge
 *  - Concentrates particulate species (indices 7-12) into sludge stream
 *  - Removes particulates from effluent stream
 *  - registerChild: connects measurements, upstream reactors, machines
 */

const { Settler } = require('../src/specificClass');

// --------------- helpers ---------------

const NUM_SPECIES = 13;

function makeConfig(overrides = {}) {
  return {
    general: {
      name: 'TestSettler',
      id: 'settler-test-1',
      logging: { enabled: false, logLevel: 'error' },
    },
    functionality: {
      softwareType: 'settler',
      role: 'separator',
      positionVsParent: 'downstream',
    },
    ...overrides,
  };
}

// --------------- tests ---------------

describe('Settler specificClass', () => {

  describe('constructor / initialization', () => {
    it('should create an instance with default values', () => {
      const s = new Settler(makeConfig());
      expect(s).toBeDefined();
      expect(s.F_in).toBe(0);
      expect(s.Cs_in).toEqual(new Array(NUM_SPECIES).fill(0));
      expect(s.C_TS).toBe(2500);
    });

    it('should have null upstreamReactor and returnPump initially', () => {
      const s = new Settler(makeConfig());
      expect(s.upstreamReactor).toBeNull();
      expect(s.returnPump).toBeNull();
    });

    it('should initialize an EventEmitter', () => {
      const s = new Settler(makeConfig());
      expect(s.emitter).toBeDefined();
      expect(typeof s.emitter.on).toBe('function');
    });

    it('should initialize a MeasurementContainer', () => {
      const s = new Settler(makeConfig());
      expect(s.measurements).toBeDefined();
    });
  });

  describe('getEffluent', () => {

    describe('with zero inflow', () => {
      it('should return three streams with zero flows', () => {
        const s = new Settler(makeConfig());
        s.F_in = 0;
        s.Cs_in = new Array(NUM_SPECIES).fill(0);
        const result = s.getEffluent;
        expect(result).toHaveLength(3);
        expect(result[0].payload.F).toBe(0); // effluent
        expect(result[1].payload.F).toBe(0); // surplus sludge
        expect(result[2].payload.F).toBe(0); // return sludge
      });
    });

    describe('with normal inflow and particulates', () => {
      let s;
      let result;

      beforeAll(() => {
        s = new Settler(makeConfig());
        s.F_in = 100;
        s.C_TS = 5000;
        // Set concentrations: solubles at indices 0-6, particulates at 7-12
        const C = new Array(NUM_SPECIES).fill(10);
        C[12] = 5000; // X_TS
        s.Cs_in = C;
        result = s.getEffluent;
      });

      it('should return 3 output streams', () => {
        expect(result).toHaveLength(3);
      });

      it('should have effluent topic "Fluent"', () => {
        expect(result[0].topic).toBe('Fluent');
      });

      it('should calculate sludge flow F_s = min(F_in * X_TS_in / C_TS, F_in)', () => {
        // F_s = min(100 * 5000 / 5000, 100) = min(100, 100) = 100
        const F_eff = result[0].payload.F;
        const F_so = result[1].payload.F;
        const F_sr = result[2].payload.F;
        // Total out should equal F_in (mass balance)
        expect(F_eff + F_so + F_sr).toBeCloseTo(100, 5);
      });

      it('should set effluent particulate indices to zero when F_s > 0', () => {
        const Cs_eff = result[0].payload.C;
        for (let i = 7; i <= 12; i++) {
          expect(Cs_eff[i]).toBe(0);
        }
      });

      it('should keep effluent soluble indices unchanged', () => {
        const Cs_eff = result[0].payload.C;
        for (let i = 0; i < 7; i++) {
          expect(Cs_eff[i]).toBe(10);
        }
      });

      it('should concentrate particulates in sludge stream', () => {
        const Cs_s = result[1].payload.C;
        const F_s = Math.min((s.F_in * s.Cs_in[12]) / s.C_TS, s.F_in);
        // Cs_s[i] = F_in * Cs_in[i] / F_s for particulate indices
        for (let i = 7; i <= 12; i++) {
          const expected = s.F_in * s.Cs_in[i] / F_s;
          expect(Cs_s[i]).toBeCloseTo(expected, 5);
        }
      });
    });

    describe('with low X_TS and high C_TS (dilute sludge)', () => {
      it('should produce mostly effluent flow', () => {
        const s = new Settler(makeConfig());
        s.F_in = 100;
        s.C_TS = 10000; // high target concentration
        const C = new Array(NUM_SPECIES).fill(10);
        C[12] = 100; // low X_TS in
        s.Cs_in = C;
        const result = s.getEffluent;
        // F_s = min(100 * 100 / 10000, 100) = min(1, 100) = 1
        expect(result[0].payload.F).toBeCloseTo(99, 5); // most flow is effluent
      });
    });

    describe('mass balance', () => {
      it('should conserve total flow (F_eff + F_so + F_sr = F_in)', () => {
        const s = new Settler(makeConfig());
        s.F_in = 200;
        s.C_TS = 3000;
        const C = new Array(NUM_SPECIES).fill(5);
        C[12] = 2000;
        s.Cs_in = C;
        const result = s.getEffluent;
        const totalOut = result[0].payload.F + result[1].payload.F + result[2].payload.F;
        expect(totalOut).toBeCloseTo(200, 5);
      });

      it('should not produce negative flows', () => {
        const s = new Settler(makeConfig());
        s.F_in = 50;
        s.C_TS = 1000;
        const C = new Array(NUM_SPECIES).fill(0);
        C[12] = 500;
        s.Cs_in = C;
        const result = s.getEffluent;
        result.forEach(stream => {
          expect(stream.payload.F).toBeGreaterThanOrEqual(0);
        });
      });
    });

    describe('no return pump', () => {
      it('should have F_sr = 0 when there is no return pump', () => {
        const s = new Settler(makeConfig());
        s.F_in = 100;
        s.C_TS = 5000;
        s.Cs_in = new Array(NUM_SPECIES).fill(10);
        s.Cs_in[12] = 3000;
        const result = s.getEffluent;
        expect(result[2].payload.F).toBe(0);
      });
    });

    describe('edge case: X_TS > C_TS (F_s clamped to F_in)', () => {
      it('should clamp F_s to F_in when X_TS/C_TS ratio exceeds 1', () => {
        const s = new Settler(makeConfig());
        s.F_in = 100;
        s.C_TS = 1000;
        s.Cs_in = new Array(NUM_SPECIES).fill(10);
        s.Cs_in[12] = 5000; // X_TS_in > C_TS => F_s = min(500, 100) = 100
        const result = s.getEffluent;
        expect(result[0].payload.F).toBe(0); // all flow goes to sludge
      });
    });
  });

  describe('registerChild()', () => {
    it('should not throw for null child', () => {
      const s = new Settler(makeConfig());
      // null child should trigger the error log but not crash
      expect(() => s.registerChild(null, 'measurement')).not.toThrow();
    });

    it('should not throw for unknown software type with valid child', () => {
      const s = new Settler(makeConfig());
      const fakeChild = {
        config: {
          general: { name: 'fake', id: 'fake-1' },
          functionality: { positionVsParent: 'upstream' },
          asset: { type: 'pressure' },
        },
        measurements: { emitter: { on: jest.fn() } },
      };
      expect(() => s.registerChild(fakeChild, 'unknownType')).not.toThrow();
    });
  });

  describe('_connectMachine()', () => {
    it('should set returnPump for downstream machine', () => {
      const s = new Settler(makeConfig());
      const fakeMachine = {
        config: {
          general: { name: 'pump', id: 'pump-1' },
          functionality: { positionVsParent: 'downstream' },
        },
      };
      s._connectMachine(fakeMachine);
      expect(s.returnPump).toBe(fakeMachine);
      expect(fakeMachine.upstreamSource).toBe(s);
    });

    it('should not set returnPump for non-downstream machine', () => {
      const s = new Settler(makeConfig());
      const fakeMachine = {
        config: {
          general: { name: 'pump', id: 'pump-2' },
          functionality: { positionVsParent: 'upstream' },
        },
      };
      s._connectMachine(fakeMachine);
      expect(s.returnPump).toBeNull();
    });
  });

  describe('_updateMeasurement()', () => {
    it('should update C_TS when measurement type is "quantity (tss)"', () => {
      const s = new Settler(makeConfig());
      s._updateMeasurement('quantity (tss)', 7000, 'atEquipment', {});
      expect(s.C_TS).toBe(7000);
    });

    it('should not change C_TS for unrecognized measurement type', () => {
      const s = new Settler(makeConfig());
      s._updateMeasurement('temperature', 25, 'atEquipment', {});
      expect(s.C_TS).toBe(2500); // unchanged
    });
  });
});