import { describe, expect, it } from 'vitest';
import * as XLSX from 'xlsx';
import type { ImportedDataset } from '../../src/domain/dataset';
import { defaultReview, type Review } from '../../src/domain/review';
import { buildWorkViewExport } from '../../src/exports/work-view-export';
import { renderWorkViewXlsx } from '../../src/exports/work-view-xlsx';
import { makeSheet } from '../../src/importers/sheet-factory';

/** Synthetic mixed Work sheet; `Source: Scan` assigns each record to its tool as in the project sheet. */
function mixed(rows: Array<Record<string, string>>, extraSheets: ImportedDataset['sheets'] = []) {
  const labels = [...new Set(rows.flatMap(row => Object.keys(row)))];
  const sheet = makeSheet('All Records', [labels, ...rows.map(row => labels.map(label => row[label] ?? ''))], '', 'synthetic.html', { isProjectSheet: true, toolId: 'generic' });
  const dataset = { fileName: 'Synthetic', profileId: 'generic', sheets: [sheet, ...extraSheets] } as ImportedDataset;
  return { dataset, sheet, records: sheet.analysis.records };
}
function workbook(input: ReturnType<typeof mixed>, options: { isDeviation?: (title: string) => boolean; reviews?: Record<string, Review> } = {}) {
  const report = buildWorkViewExport({ ...input, generatedAt: '2026-09-24T12:00:00.000Z', reviews: options.reviews,
    isDeviation: options.isDeviation && (record => options.isDeviation!(record.title)) });
  const bytes = renderWorkViewXlsx(report);
  const book = XLSX.read(bytes, { type: 'array', cellFormula: true });
  const rows = (name: string) => XLSX.utils.sheet_to_json<string[]>(book.Sheets[name], { header: 1, raw: true, defval: '' });
  /** Finding rows of a tool sheet as header → value objects. */
  const findings = (name: string) => { const [header, ...body] = rows(name); return body.map(row => Object.fromEntries(header.map((key, index) => [key, row[index]]))); };
  const zip = XLSX.CFB.read(bytes, { type: 'array' });
  const part = (path: string) => new TextDecoder().decode(XLSX.CFB.find(zip, path).content);
  return { report, book, rows, findings, part };
}

describe('Work Excel finding list', () => {
  it('writes an overview and one sheet per tool whose columns follow the finding reader', () => {
    const input = mixed([
      { Title: 'Synthetic PC finding', Status: 'Matched', Severity: 'High', Category: 'Anomalies', Description: 'Synthetic description',
        'Technical explanation': 'Synthetic explanation', 'Advised solution': 'Synthetic fix', 'Source Rule ID': 'A-Synthetic', 'Source: Scan': 'PingCastle · 2026-09-01' },
      { Title: 'Synthetic Maester test', Status: 'Failed', Severity: 'Medium', Description: 'Synthetic Maester description', 'Source: Scan': 'Maester · 2026-09-01' },
      { Title: 'Synthetic PC second', Status: 'Matched', Severity: 'Low', Description: 'Second description', 'Source: Scan': 'PingCastle · 2026-09-01' }
    ]);
    const { book, rows, findings } = workbook(input, { isDeviation: title => title !== 'Synthetic PC second' });
    expect(book.SheetNames).toEqual(['Übersicht', 'PingCastle', 'Maester']);
    const header = rows('PingCastle')[0];
    expect(header.slice(0, 6)).toEqual(['Nr', 'Finding', 'Status', 'Severity', 'Badges', 'Source Rule ID']);
    // Reader order for PingCastle: Description, Technical explanation, Advised solution.
    expect(header.indexOf('Description')).toBeLessThan(header.indexOf('Technical explanation'));
    expect(header.indexOf('Technical explanation')).toBeLessThan(header.indexOf('Advised solution'));
    expect(header.slice(-3)).toEqual(['Results', 'Additional Information', 'Record ID']);
    expect(header).not.toContain('Soll-Zustand');
    expect(header).not.toContain('Ist-Zustand / Abweichung');
    const [first, second] = findings('PingCastle');
    expect(first).toMatchObject({ Nr: '1', Finding: 'Synthetic PC finding', Status: 'Matched', Severity: 'High', Badges: 'Category: Anomalies',
      'Source Rule ID': 'A-Synthetic', Description: 'Synthetic description', 'Technical explanation': 'Synthetic explanation', 'Advised solution': 'Synthetic fix' });
    expect(second).toMatchObject({ Nr: '2', Finding: 'Synthetic PC second', Description: 'Second description', 'Advised solution': '' });
    expect(findings('Maester').map(row => row.Finding)).toEqual(['Synthetic Maester test']);
    const overview = rows('Übersicht').map(row => row.join('|')).join('\n');
    expect(overview).toContain('Treffer|3');
    expect(overview).toContain('PingCastle|2|1');
    expect(overview).toContain('Maester|1|1');
  });

  it('puts the Results window content and the review into their own columns', () => {
    const evidence = makeSheet('Synthetic evidence', [['Host', 'State'], ['Synthetic host A', '0'], ['Synthetic host B', 'false']], '', 'synthetic.html',
      { sourceFile: 'synthetic.html', sourceTableIndex: 42, toolId: 'cis-cat' });
    const input = mixed([{ Title: 'Synthetic rule', Status: 'Fail', Description: 'Synthetic CIS description', Results: 'source-table:42 "Synthetic evidence"', 'Source: Scan': 'CIS-CAT Pro · 2026-09-01' }], [evidence]);
    input.records[0].sourceFile = 'synthetic.html';
    const { findings } = workbook(input, { reviews: { [input.records[0].id]: { ...defaultReview(), status: 'Done', owner: 'Synthetic team', markerQuickwin: true } } });
    const [finding] = findings('CIS-CAT Pro');
    expect(finding.Results).toContain('Synthetic evidence');
    expect(finding.Results).toContain('Host: Synthetic host A\nState: 0');
    expect(finding.Results).toContain('State: false');
    expect(finding.Review).toBe('Status: Done\nPriority: Medium\nOwner / Team: Synthetic team\nMarkers: Quick Win');
    expect(finding.Status).toBe('Fail'); // a done review never changes the result status
  });

  it('shows GPO findings like the reader: customer and baseline values, sources, neutral note and scope boundary', () => {
    const input = mixed([
      { Title: 'Synthetic policy', Status: 'Deviation', Category: 'GPOs', 'Configured Value': '1', 'Baseline value': '0', Description: 'Synthetic policy description', 'Source: Scan': 'GPOs · 2026-09-01' },
      { Title: 'Synthetic absent policy', Status: 'Not configured', Category: 'GPOs', 'Baseline value': '1', 'Source: Scan': 'GPOs · 2026-09-01' }
    ]);
    input.records[0].policySourceEvidence = [{ id: 'synthetic-observation', backupKey: 'synthetic-backup', sourceReference: 'Synthetic/registry.pol', sequence: 1,
      values: [{ kind: 'registry-policy', operation: 'set-value', key: 'Software\\Synthetic', valueName: 'Value', data: 1, typeCode: 4 }] }];
    const { book, findings, rows } = workbook(input);
    expect(book.SheetNames).toEqual(['Übersicht', 'GPOs']);
    const [configured, absent] = findings('GPOs');
    expect(configured['GPO sources']).toContain('Synthetic/registry.pol');
    expect(configured['Expected baseline value']).toBeTruthy();
    expect(configured.Description).toBe('Synthetic policy description');
    expect(configured.Hinweise).toBe('');
    expect(absent.Hinweise).toContain('Score-neutral');
    expect(rows('Übersicht').flat().join('\n')).toContain('kein Nachweis der wirksamen Endpoint-Konfiguration');
  });

  it('formats headers, deviations, wrapping, filters and frozen identity columns', () => {
    const { part, rows } = workbook(mixed([
      { Title: 'Synthetic deviation', Status: 'Matched', Description: 'x', 'Source: Scan': 'PingCastle · 2026-09-01' },
      { Title: 'Synthetic passed', Status: 'Not matched', Description: 'y', 'Source: Scan': 'PingCastle · 2026-09-01' }
    ]), { isDeviation: title => title === 'Synthetic deviation' });
    const last = String.fromCharCode(64 + rows('PingCastle')[0].length);
    const sheet = part('/xl/worksheets/sheet2.xml');
    expect(part('/xl/styles.xml')).toContain('<alignment vertical="top" wrapText="1"/>');
    expect(sheet).toContain('<pane xSplit="2" ySplit="1" topLeftCell="C2" activePane="bottomRight" state="frozen"/>');
    expect(sheet).toContain(`<autoFilter ref="A1:${last}3"/>`);
    expect(sheet).toMatch(/<c r="A1" s="1"/); // header style
    expect(sheet).toMatch(/<c r="C2" s="2"/); // deviation status highlighted
    expect(sheet).toMatch(/<c r="C3" s="0"/); // non-deviation status neutral
    expect(part('/xl/workbook.xml')).toContain(`<definedName name="_xlnm._FilterDatabase" localSheetId="1" hidden="1">'PingCastle'!$A$1:$${last}$3</definedName>`);
  });

  it('keeps formula-like and control-character source text literal and exact', () => {
    const input = mixed([{ Title: '=HYPERLINK("https://example.invalid","x")', Status: 'Fail', Description: '=1+1', Target: 'a_x0041_b' }]);
    input.records[0].fields.find(field => field.label === 'Target')!.value = 'a_x0041_b\u0001c';
    const { book, findings, part } = workbook(input);
    const sheet = book.Sheets[book.SheetNames[1]];
    const cells = Object.keys(sheet).filter(key => !key.startsWith('!')).map(key => sheet[key] as XLSX.CellObject);
    expect(cells.every(cell => cell.t === 's' && cell.f === undefined)).toBe(true);
    const [finding] = findings(book.SheetNames[1]);
    expect(finding.Finding).toBe('=HYPERLINK("https://example.invalid","x")');
    expect(finding.Description).toBe('=1+1');
    expect(finding['Additional Information']).toContain('Target: a_x0041_b\u0001c'); // exact source identifier
    expect(part('/xl/worksheets/sheet2.xml')).not.toContain('<f>');
  });

  it('continues oversized cells in marked rows of the same finding without losing data', () => {
    const long = 'Synthetic target =1; "value" | \\path 😀\n'.repeat(2300);
    const input = mixed([{ Title: 'Synthetic long', Status: 'Fail', Target: 'x', 'Source: Scan': 'PingCastle · 2026-09-01' }]);
    input.records[0].fields.find(field => field.label === 'Target')!.value = long;
    const { findings } = workbook(input);
    const list = findings('PingCastle');
    expect(list.length).toBeGreaterThan(2);
    expect(list.every(row => row.Nr === '1' && row.Status === 'Fail' && row['Record ID'] === list[0]['Record ID'])).toBe(true);
    expect(list.every((row, index) => row.Finding === `Synthetic long\nTeil ${index + 1}/${list.length} · Fortsetzungszeile desselben Findings`)).toBe(true);
    expect(list.flatMap(row => Object.values(row)).every(cell => cell.length < 32767)).toBe(true);
    expect(list.map(row => row['Additional Information']).join('')).toContain(long); // exact, no Markdown rendering
  });

  it('names the sheet of an unrecognized tool after its profile', () => {
    const { book } = workbook(mixed([{ Title: 'Synthetic', Status: 'Fail' }]));
    expect(book.SheetNames).toEqual(['Übersicht', 'Tabular Data']);
  });

  it('names Purple Knight runs of the mixed project sheet after their tool, not the generic profile', () => {
    const { book } = workbook(mixed([
      { Title: 'Synthetic AD indicator', Status: 'IOE Found', 'Source: Scan': 'Purple Knight for Active Directory · 2026-09-01' },
      { Title: 'Synthetic Entra indicator', Status: 'IOE Found', 'Source: Scan': 'Purple Knight for Entra ID · 2026-09-01' }
    ]));
    expect(book.SheetNames).toEqual(['Übersicht', 'PurpleKnight']);
  });

  it('keeps a source field named like a fixed column in its own column', () => {
    const { findings } = workbook(mixed([{ Title: 'Synthetic', Status: 'Fail', Nr: '17', Review: 'Synthetic source review', 'Source: Scan': 'PingCastle · 2026-09-01' }]));
    const [finding] = findings('PingCastle');
    expect(finding).toMatchObject({ Nr: '1', 'Nr (Source field)': '17', 'Review (Source field)': 'Synthetic source review' });
    expect(finding.Review ?? '').not.toContain('Synthetic source review');
  });

  it('exports a large single-tool sheet', () => {
    const rows = Array.from({ length: 250_000 }, (_, index) => ({ Title: `Synthetic ${index}`, Status: 'Matched', 'Source: Scan': 'PingCastle · 2026-09-01' }));
    const input = mixed(rows);
    const report = buildWorkViewExport({ ...input, generatedAt: '2026-09-24T12:00:00.000Z' });
    expect(() => renderWorkViewXlsx(report)).not.toThrow();
  }, 120_000);
});