import { describe, expect, it } from 'vitest';
import { validateProject } from '@/domain/validation/engine';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { createEmptyProject, createStandardIntersectionProject } from '@/domain/model/factory';
import type { Project } from '@/domain/model/project';

const FIXED_DATE = new Date('2026-01-01T00:00:00Z');

function complete(): Project {
  const base = createStandardIntersectionProject('Prueffall', FIXED_DATE);
  return {
    ...base,
    meta: {
      ...base.meta,
      projectNumber: 'VP-2026-001',
      client: 'Stadt Musterhausen',
      planner: 'O. Willerding',
      location: 'Hauptstrasse / Bahnhofstrasse',
    },
  };
}

describe('Pruefung des Projekts', () => {
  it('meldet bei einem vollstaendigen Regelknotenpunkt keinen Fehler', () => {
    const report = validateProject(complete(), undefined, FIXED_DATE);
    const errors = report.findings.filter((f) => f.severity === 'fehler');
    expect(errors, errors.map((e) => `${e.rule}: ${e.message}`).join('\n')).toHaveLength(0);
    expect(report.exportBlocked).toBe(false);
  });

  it('sperrt den Export, sobald ein Fehler vorliegt', () => {
    const report = validateProject(createEmptyProject('Leer', FIXED_DATE), undefined, FIXED_DATE);
    expect(report.errorCount).toBeGreaterThan(0);
    expect(report.exportBlocked).toBe(true);
  });

  it('meldet fehlende Projektangaben', () => {
    const base = createStandardIntersectionProject('X', FIXED_DATE);
    const report = validateProject(base, undefined, FIXED_DATE);
    expect(report.findings.some((f) => f.rule === 'projektdaten.client')).toBe(true);
    expect(report.findings.some((f) => f.rule === 'projektdaten.planner')).toBe(true);
  });

  /*
   * Die fehlende Bezeichnung (Befund B3 zur Zwischenzeitenmatrix). Vor der
   * Regel `signalgruppen.name-leer` fiel eine EINZELNE Signalgruppe ohne
   * Bezeichnung durch die Pruefung: Gemeldet wurde sie erst, wenn eine zweite
   * ebenfalls keine trug - und auch dann nur als Doppelung, weil beide auf den
   * Schluessel '' abgebildet wurden.
   */
  describe('Signalgruppe ohne Bezeichnung', () => {
    /** Der Standardknotenpunkt, dessen i-te Signalgruppe `name` traegt. */
    function mitNamen(i: number, name: string): Project {
      const base = complete();
      return {
        ...base,
        signalGroups: base.signalGroups.map((g, index) => (index === i ? { ...g, name } : g)),
      };
    }

    it('meldet eine einzelne Signalgruppe ohne Bezeichnung als Fehler', () => {
      const report = validateProject(mitNamen(2, ''), undefined, FIXED_DATE);
      const leer = report.findings.filter((f) => f.rule === 'signalgruppen.name-leer');
      expect(leer).toHaveLength(1);
      expect(leer[0]!.severity).toBe('fehler');
      // Die Stellung ist das einzige Merkmal, ueber das sie ansprechbar ist.
      expect(leer[0]!.title).toContain('Signalgruppe 3');
      expect(report.exportBlocked).toBe(true);
    });

    it('behandelt eine Bezeichnung aus lauter Leerzeichen wie eine fehlende', () => {
      const report = validateProject(mitNamen(0, '   '), undefined, FIXED_DATE);
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-leer')).toHaveLength(1);
    });

    it('meldet zwei unbenannte Gruppen zweimal als fehlend und nicht als Doppelung', () => {
      const base = complete();
      const project: Project = {
        ...base,
        signalGroups: base.signalGroups.map((g, index) =>
          index === 1 || index === 3 ? { ...g, name: '' } : g,
        ),
      };
      const report = validateProject(project, undefined, FIXED_DATE);
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-leer')).toHaveLength(2);
      /*
       * Und KEINE Doppelung: Zwei Signalgruppen ohne Bezeichnung sind nicht
       * doppelt benannt, sondern zweimal unbenannt. Der frueher gemeldete
       * Befund trug den Titel 'Bezeichnung "" mehrfach vergeben'.
       */
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-doppelt')).toHaveLength(
        0,
      );
    });

    it('laesst die Doppelungsregel fuer benannte Gruppen unberuehrt', () => {
      const base = complete();
      const project: Project = {
        ...base,
        signalGroups: base.signalGroups.map((g, index) =>
          index === 1 ? { ...g, name: base.signalGroups[0]!.name } : g,
        ),
      };
      const report = validateProject(project, undefined, FIXED_DATE);
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-doppelt')).toHaveLength(
        1,
      );
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-leer')).toHaveLength(0);
    });

    it('meldet nichts, solange jede Signalgruppe eine Bezeichnung traegt', () => {
      const report = validateProject(complete(), undefined, FIXED_DATE);
      expect(report.findings.filter((f) => f.rule === 'signalgruppen.name-leer')).toHaveLength(0);
    });
  });

  it('erkennt doppelte Signalgruppenbezeichnungen', () => {
    const base = complete();
    const project: Project = {
      ...base,
      signalGroups: base.signalGroups.map((g, i) =>
        i === 1 ? { ...g, name: base.signalGroups[0]!.name } : g,
      ),
    };
    const report = validateProject(project, undefined, FIXED_DATE);
    expect(report.findings.some((f) => f.rule === 'signalgruppen.name-doppelt')).toBe(true);
  });

  it('erkennt feindliche Signalgruppen in derselben Phase', () => {
    const base = complete();
    // K1 und K3 stehen in Konflikt - hier bewusst in dieselbe Phase gelegt.
    const k1 = base.signalGroups.find((g) => g.name === 'K1')!;
    const k3 = base.signalGroups.find((g) => g.name === 'K3')!;
    const project: Project = {
      ...base,
      phases: base.phases.map((p, i) => (i === 0 ? { ...p, signalGroupIds: [k1.id, k3.id] } : p)),
    };

    const report = validateProject(project, undefined, FIXED_DATE);
    expect(report.findings.some((f) => f.rule === 'phasen.feindlich-in-phase')).toBe(true);
    expect(report.exportBlocked).toBe(true);
  });

  it('meldet einen fehlenden Raeumweg', () => {
    const base = complete();
    const project: Project = {
      ...base,
      conflicts: base.conflicts.map((c, i) => (i === 0 ? { ...c, clearingDistance: 0 } : c)),
    };
    const report = validateProject(project, undefined, FIXED_DATE);
    expect(report.findings.some((f) => f.rule === 'konflikte.raeumweg-fehlt')).toBe(true);
  });

  it('meldet eine fehlende Gegenrichtung der Konfliktbeziehung', () => {
    const base = complete();
    const project: Project = { ...base, conflicts: base.conflicts.slice(0, 1) };
    const report = validateProject(project, undefined, FIXED_DATE);
    expect(report.findings.some((f) => f.rule === 'konflikte.gegenrichtung-fehlt')).toBe(true);
  });

  it('meldet Ueberlastung, wenn die Nachfrage die Kapazitaet uebersteigt', () => {
    const base = complete();
    const project: Project = {
      ...base,
      demands: base.demands.map((d) => ({ ...d, volume: 2500 })),
    };
    const report = validateProject(project, undefined, FIXED_DATE);
    expect(
      report.findings.some(
        (f) =>
          f.rule === 'leistungsfaehigkeit.ueberlastet' || f.rule === 'signalplan.uebersaettigt',
      ),
    ).toBe(true);
  });

  it('weist eine unzulaessige Vorgabe als Fehler aus', () => {
    const base = complete();
    const project: Project = {
      ...base,
      settings: { ...base.settings, rilsa: { redYellow: 0, clearingSpeedKfzStraight: 20 } },
    };
    const report = validateProject(project, undefined, FIXED_DATE);
    const settingErrors = report.findings.filter(
      (f) => f.category === 'vorgaben' && f.severity === 'fehler',
    );
    expect(settingErrors.length).toBeGreaterThan(0);
  });

  it('gibt zu jeder Meldung eine Fundstelle und einen Korrekturvorschlag an', () => {
    const report = validateProject(createEmptyProject('Leer', FIXED_DATE), undefined, FIXED_DATE);
    for (const finding of report.findings) {
      expect(finding.reference).not.toBe('');
      expect(finding.suggestion).not.toBe('');
      expect(finding.title).not.toBe('');
    }
  });

  it('sortiert Fehler vor Warnungen vor Hinweisen', () => {
    const report = validateProject(createEmptyProject('Leer', FIXED_DATE), undefined, FIXED_DATE);
    const order = { fehler: 0, warnung: 1, hinweis: 2 } as const;
    for (let i = 1; i < report.findings.length; i += 1) {
      expect(order[report.findings[i]!.severity]).toBeGreaterThanOrEqual(
        order[report.findings[i - 1]!.severity],
      );
    }
  });

  it('nimmt einen bereits berechneten Plan entgegen, statt ihn erneut aufzubauen', () => {
    const project = complete();
    const plan = buildSignalPlan(project);
    const a = validateProject(project, plan, FIXED_DATE);
    const b = validateProject(project, undefined, FIXED_DATE);
    expect(a.findings.map((f) => f.rule)).toEqual(b.findings.map((f) => f.rule));
  });
});