// @vitest-environment jsdom
import { act } from 'react';
import { createRoot } from 'react-dom/client';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { AppProvider, useApp } from '../../src/app/AppProvider';
import { AssessorApiClient } from '../../src/api/assessor-api-client';
import type { UnifiedResultProjection } from '../../src/domain/unified-result';
import type { CanonicalAssessmentModel } from '../../src/domain/canonical-model';
import type { ImportedDataset } from '../../src/domain/dataset';
import { POLICY_EVALUATION_ENGINE, type PolicyEvaluationResult, type StoredPolicyEvaluation } from '../../src/domain/policy-evaluation';
import { appendPolicyObservationsToDataset } from '../../src/features/project-import/policy-observations-to-dataset';
import { loadCanonicalProjectWorkspace } from '../../src/features/project-import/load-canonical-project-workspace';
import { SearchFilterBar, SearchTextControl, SheetAndSearchControls } from '../../src/features/search-filter/SearchFilterBar';
import { useFilteredRecords } from '../../src/features/search-filter/use-filtered-records';
import { FindingReader } from '../../src/features/finding-reader/FindingReader';
import { inlineResultTableSheets } from '../../src/features/linked-results/inline-result-tables';
import { makeSheet } from '../../src/importers/sheet-factory';

vi.mock('../../src/features/project-import/load-canonical-project-workspace', () => ({ loadCanonicalProjectWorkspace: vi.fn() }));
afterEach(() => { vi.restoreAllMocks(); vi.unstubAllGlobals(); localStorage.clear(); });

const nativeId = (index: number) => `{00000000-0000-0000-0000-${String(index).padStart(12, '0')}}`;
function source(index: number, value: number | 'delete', setting = 'Alpha mode'): UnifiedResultProjection {
  return {
    sourceKind: 'policy-observation', sourceResultId: `observation-${index}`, projectId: 'synthetic', assessmentId: 'slot',
    policyBackupInstanceId: `backup-${index}`, policyGpoId: nativeId(index), policyNativeBackupId: nativeId(index + 100),
    policySourceSequence: index, title: setting, importedAt: '2026-09-17T00:00:00Z',
    policyScope: 'computer', policyDeliveryMechanism: 'registry-policy', policyIdentityStatus: 'resolved',
    policyIdentityKey: setting, policyState: value === 'delete' ? 'instruction' : 'configured',
    sourceLocator: { objectPath: `C:/SyntheticPrivate/${nativeId(index + 100)}/DomainSysvol/GPO/Machine/registry.pol#records=${index}` },
    policyValues: [{ kind: 'registry-policy', operation: value === 'delete' ? 'delete-value' : 'set-value',
      key: 'Software\\Policies\\Synthetic', valueName: setting,
      ...(value === 'delete' ? {} : { typeCode: 4, data: { kind: 'uint32', value } }) }]
  } as unknown as UnifiedResultProjection;
}

function fixture(mixed: boolean) {
  const sources = [source(1, 1), source(2, 'delete'), source(3, 1), source(4, 1), source(5, 0, 'Beta switch')];
  const comparison = (observations: UnifiedResultProjection[], conflicted: boolean): PolicyEvaluationResult => ({
    id: `comparison-${observations[0].policyIdentityKey}`, observationIds: observations.map(item => item.sourceResultId),
    backupInstanceIds: observations.map(item => item.policyBackupInstanceId), baselineId: 'baseline', baselineLabel: 'Synthetic baseline',
    identity: { id: observations[0].policyIdentityKey, scope: 'computer', target: { kind: 'registry-value',
      hive: 'HKEY_LOCAL_MACHINE', key: 'Software\\Policies\\Synthetic', valueName: observations[0].title } },
    baselineState: 'explicit-recommendation', customerState: conflicted ? 'conflicted' : 'configured',
    classification: 'confirmed_configured_deviation', diagnosticCodes: conflicted ? ['policy-evaluation-customer-conflict'] : [],
    comparator: { version: 1, comparator: { kind: 'equality' }, relation: 'different', baseline: { kind: 'integer', value: '1' }, diagnosticCodes: [] },
    baselineVariantAssessment: { version: 1, scope: 'backup-configuration', decision: 'all-fail',
      actualValues: observations.flatMap(item => item.policyValues!), variants: [{
        settingId: 'baseline-setting', baselineValues: [{ kind: 'registry-policy', operation: 'set-value',
          key: 'Software\\Policies\\Synthetic', valueName: observations[0].title, typeCode: 4,
          data: { kind: 'uint32', value: 1 } }],
        comparator: { version: 1, comparator: { kind: 'equality' }, relation: 'different',
          baseline: { kind: 'integer', value: '1' }, diagnosticCodes: [] }
      }], diagnosticCodes: [] }
  } as unknown as PolicyEvaluationResult);
  const evaluation = { run: { id: 'evaluation', projectId: 'synthetic', aggregationRunId: 'aggregation',
    completedAt: '2026-09-17T00:01:00Z', evaluator: POLICY_EVALUATION_ENGINE },
    results: [comparison(sources.slice(0, 4), true), comparison(sources.slice(4), false)] } as StoredPolicyEvaluation;
  const scanner = mixed ? { sheets: [makeSheet('All Records', [['Title', 'Status', 'Source: Scan'],
    ['Synthetic scanner', 'Fail', 'Maester']], '', 'Synthetic', { isProjectSheet: true })],
    profileId: 'generic', scanTool: 'Multiple Tools' } as ImportedDataset : null;
  return { dataset: appendPolicyObservationsToDataset(scanner, 'Synthetic', sources, [evaluation])!, sources, evaluation };
}

function Harness({ onResults }: { onResults(): void }) {
  const app = useApp();
  const records = useFilteredRecords();
  const selected = records.find(record => record.id === app.selectedRecordId) ?? records[0];
  const position = selected ? records.indexOf(selected) : 0;
  return <>
    <button data-testid="open" onClick={() => void app.openProject('synthetic', [], ['slot'])}>Open synthetic</button>
    <SheetAndSearchControls/><SearchTextControl/><SearchFilterBar/>
    <ul data-testid="findings">{records.map(record => <li key={record.id}>
      <button onClick={() => app.setSelectedRecord(record.id)}>{record.title}</button>
    </li>)}</ul>
    {selected && <FindingReader record={selected} title={selected.title} linkedSheets={inlineResultTableSheets(selected)}
      resultReferences={[]} search={app.search} position={position} recordCount={records.length}
      toolId={app.activeSheet?.toolId ?? app.activeProfile.id}
      onPrevious={() => app.setSelectedRecord(records[Math.max(0, position - 1)].id)}
      onNext={() => app.setSelectedRecord(records[Math.min(records.length - 1, position + 1)].id)}
      onReview={() => {}} onResults={onResults}/>} 
  </>;
}

describe('Work shows GPO source attribution immediately', () => {
  it.each([false, true])('preserves source attribution through Deviation, search, Conflicts and record navigation (mixed=%s)', async mixed => {
    vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
    vi.spyOn(AssessorApiClient.prototype, 'health').mockResolvedValue({ status: 'ok' } as never);
    const { dataset, sources, evaluation } = fixture(mixed);
    const unchanged = JSON.stringify([sources, evaluation]);
    vi.mocked(loadCanonicalProjectWorkspace).mockResolvedValue({ dataset, assessmentIds: ['slot'], models: [{
      project: { id: 'synthetic', name: 'Synthetic' }, assessment: { id: 'slot' }, reviews: []
    } as unknown as CanonicalAssessmentModel] });
    const container = document.createElement('div');
    const root = createRoot(container);
    const onResults = vi.fn();
    const select = async (label: string, value: string) => act(async () => {
      const control = container.querySelector<HTMLSelectElement>(`select[aria-label="${label}"]`)!;
      control.value = value;
      control.dispatchEvent(new Event('change', { bubbles: true }));
    });
    const click = async (selector: string) => act(async () => container.querySelector<HTMLButtonElement>(selector)!.click());
    const titles = () => [...container.querySelectorAll('[data-testid="findings"] li')].map(item => item.textContent);
    const groups = () => [...container.querySelectorAll<HTMLElement>('.policy-source-group')];
    const attribution = () => groups().map(group => ({
      label: group.dataset.sourceLabel,
      relation: group.dataset.sourceRelation,
      operation: group.textContent?.includes('Operation: delete-value') ? 'delete-value' : 'set-value',
      data: group.textContent?.includes('Data: 0') ? '0' : group.textContent?.includes('Data: 1') ? '1' : '—'
    }));
    const expectedAttribution = [1, 2, 3, 4].map(index => ({ label: `GPO ${nativeId(index)}`,
      relation: index === 2 ? 'conflicting' : 'aligned', operation: index === 2 ? 'delete-value' : 'set-value',
      data: index === 2 ? '—' : '1' }));
    try {
      await act(async () => root.render(<AppProvider><Harness onResults={onResults}/></AppProvider>));
      await click('[data-testid="open"]');
      if (mixed) await select('Source: Scan', 'gpos · 2026-09-17t00:00:00z');
      expect(container.querySelector<HTMLSelectElement>('select[aria-label="Result Status"]')?.value).toBe('deviation');
      expect(titles()).toEqual(['Alpha mode', 'Beta switch']);
      await act(async () => [...container.querySelectorAll<HTMLButtonElement>('[data-testid="findings"] button')]
        .find(button => button.textContent === 'Alpha mode')!.click());
      expect(attribution()).toEqual(expectedAttribution);
      expect(container.querySelector('.policy-source-evidence > h4')?.textContent).toBe('4 GPO backup sources');
      expect(container.querySelector('.finding-reader .outcome-mark')?.textContent).toBe('Fail');
      expect(container.querySelector('[data-policy-diagnostic="conflict"]')).not.toBeNull();
      expect(container.querySelector('[data-policy-diagnostic="duplicate"]')).toBeNull();
      expect(container.querySelector('.policy-source-notice')?.textContent).toContain('not an execution order between GPOs');
      expect(container.querySelector('.policy-source-notice')?.textContent).toContain('does not establish the effective endpoint value');
      expect(container.querySelector('.policy-source-table')).toBeNull();
      expect(container.querySelectorAll('.policy-source-group__badge')).toHaveLength(0);
      expect(groups()[1].classList.contains('is-conflicting')).toBe(true);
      expect(container.querySelectorAll('.policy-source-deviation-value')).toHaveLength(1);
      expect(container.querySelector('.policy-source-deviation-value')?.textContent).toBe('Operation: delete-value');
      expect(groups()[1].textContent).toContain('Source sequence: 2');
      expect(groups()[1].textContent).toContain('Key: Software\\Policies\\Synthetic');
      expect(container.querySelector('.policy-value-block[data-value="configured"]')).toBeNull();
      expect(container.querySelector('.finding-reader')?.textContent).not.toContain('C:/SyntheticPrivate');
      expect(onResults).not.toHaveBeenCalled();

      await act(async () => {
        const input = container.querySelector<HTMLInputElement>('input[placeholder="Search"]')!;
        Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!.call(input, 'Alpha mode');
        input.dispatchEvent(new Event('input', { bubbles: true }));
      });
      expect(titles()).toEqual(['Alpha mode']);
      expect(attribution()).toEqual(expectedAttribution);
      expect(container.querySelector('.finding-reader mark')).not.toBeNull();
      await select('Result Status', 'conflicts');
      expect(titles()).toEqual(['Alpha mode']);
      expect(attribution()).toEqual(expectedAttribution);
      await click('[aria-label="Clear search"]');
      await select('Result Status', 'deviation');
      await click('[aria-label="Next record"]');
      expect(container.querySelector('.reader-heading h2')?.textContent).toBe('Beta switch');
      expect(attribution()).toEqual([{ label: `GPO ${nativeId(5)}`, relation: 'conflicting', operation: 'set-value', data: '0' }]);
      expect(container.querySelectorAll('.policy-source-deviation-value')).toHaveLength(1);
      expect(container.querySelector('.policy-source-deviation-value')?.textContent).toBe('Data: 0');
      expect(container.querySelector('[data-policy-diagnostic="conflict"]')).toBeNull();
      await click('[aria-label="Previous record"]');
      expect(attribution()).toEqual(expectedAttribution);
      expect(onResults).not.toHaveBeenCalled();
      expect(JSON.stringify([sources, evaluation])).toBe(unchanged);
    } finally { await act(async () => root.unmount()); }
  });
});