import { describe, expect, it } from 'vitest';

import type { GraphDocument2d, GraphDocument3d, SliderSettings } from './types';
import { toTransferableDocument } from './worker-document';
import { toTransferableDocument3d } from './worker-document-3d';

describe('toTransferableDocument', () => {
	it('omits undefined optional fields from worker documents in both dimensions', () => {
		const expressions: GraphDocument2d['expressions'] = [{
			id: 'expr-1',
			input_mode: 'text',
			source: 'a := 0',
			enabled: true,
			color: null,
			slider: { min: undefined, max: undefined, step: undefined }
		}];

		const document2d: GraphDocument2d = {
			name: undefined,
			complex_mode: undefined,
			grid_cell_size: undefined,
			variable_overrides: undefined,
			viewport: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, width: 400, height: 300 },
			expressions
		};

		const document3d: GraphDocument3d = {
			name: undefined,
			complex_mode: undefined,
			variable_overrides: undefined,
			bounds: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, z_min: -1, z_max: 1 },
			expressions: [{ ...expressions[0], slider: undefined }]
		};

		const transferable2d = toTransferableDocument(document2d);
		const transferable3d = toTransferableDocument3d(document3d);

		for (const transferable of [transferable2d, transferable3d]) {
			expect(transferable).not.toHaveProperty('name');
			expect(transferable).not.toHaveProperty('complex_mode');
			expect(transferable).not.toHaveProperty('variable_overrides');
			expect(transferable.expressions[0]).not.toHaveProperty('editor_mode');
		}

		expect(transferable2d).not.toHaveProperty('grid_cell_size');
		expect(transferable2d.expressions[0].slider).toStrictEqual({});
		expect(transferable3d.expressions[0]).not.toHaveProperty('slider');
	});

	it('preserves present falsy optional values across worker transfer', () => {
		const document: GraphDocument2d = {
			name: '',
			complex_mode: false,
			grid_cell_size: 0,
			variable_overrides: { a: 0 },
			viewport: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, width: 400, height: 300 },
			expressions: [{
				id: 'expr-1',
				input_mode: 'text',
				source: 'a := 0',
				enabled: true,
				color: null,
				slider: { min: '', max: '0', step: '0' }
			}]
		};

		expect(toTransferableDocument(document)).toStrictEqual(document);

		const document3d: GraphDocument3d = {
			name: document.name,
			complex_mode: document.complex_mode,
			variable_overrides: document.variable_overrides,
			bounds: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, z_min: -1, z_max: 1 },
			expressions: document.expressions
		};

		expect(toTransferableDocument3d(document3d)).toStrictEqual(document3d);
	});

	it('removes nested reactive proxies before posting slider documents to a worker', () => {
		const slider = new Proxy<SliderSettings>(
			{ min: '1', max: '10', step: '1' },
			{}
		);

		const document: GraphDocument2d = {
			name: 'Adjustable Lissajous',
			complex_mode: true,
			variable_overrides: { a: 4.5 },
			grid_cell_size: 4,
			viewport: { x_min: -1.5, x_max: 1.5, y_min: -1.5, y_max: 1.5, width: 800, height: 600 },
			expressions: [
				{
					id: 'expr-1',
					input_mode: 'text',
					source: 'a := 3',
					enabled: true,
					color: '#2563eb',
					slider
				}
			]
		};

		expect(() => structuredClone(document)).toThrow();

		const transferable = toTransferableDocument(document);
		expect(transferable).toEqual(document);
		expect(transferable.expressions[0].slider).not.toBe(slider);
		expect(transferable.variable_overrides).not.toBe(document.variable_overrides);
		expect(() => structuredClone(transferable)).not.toThrow();
	});
});

it('preserves the 3D complex-mode semantic input across worker transfer', () => {
	const document = {
		complex_mode: true,
		bounds: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, z_min: -1, z_max: 1 },
		expressions: []
	};

	expect(toTransferableDocument3d(document)).toEqual(document);
});

it('transfers unfinished visual drafts without reviving their last good source in either dimension', () => {
	const visualDraft = {
		latex: String.raw`\frac{1}{`,
		last_good_source: 'y=x',
		diagnostic: 'Expected right brace.'
	};

	const document2d: GraphDocument2d = {
		viewport: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, width: 400, height: 300 },
		expressions: [{
			id: 'draft', input_mode: 'text', source: '', editor_mode: 'visual', visual_draft: visualDraft,
			enabled: true, color: null
		}]
	};

	const document3d: GraphDocument3d = {
		bounds: { x_min: -1, x_max: 1, y_min: -1, y_max: 1, z_min: -1, z_max: 1 },
		expressions: [{
			id: 'draft', input_mode: 'text', source: '', editor_mode: 'visual', visual_draft: visualDraft,
			enabled: true, color: null
		}]
	};

	for (const transferable of [toTransferableDocument(document2d), toTransferableDocument3d(document3d)]) {
		expect(transferable.expressions[0]).toMatchObject({
			source: '',
			editor_mode: 'visual',
			visual_draft: visualDraft
		});
		expect(() => structuredClone(transferable)).not.toThrow();
	}
});