// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';
import * as Calculator from './calculator';
import * as copyHelper from './copyHelper';
import * as kanbanHelper from './kanbanHelper';
import * as markdownHelper from './markdownHelper';
import * as settingsHelper from './settingsHelper';
import * as promiseLinesHelper from './promiseLinesHelper';
import * as replaceLinesHelper from './replaceLinesHelper';
import * as readOnlyLinesHelper from './readOnlyLinesHelper';
import * as WebviewPanelExample from './WebviewPanelExample';
import * as WebviewPanelCostOfDelay from './WebviewPanelCostOfDelay';
import { ViewCommandPalleteWebviewViewProvider } from "./ViewCommandPalleteWebviewViewProvider";

// This method is called when your extension is activated
// Your extension is activated the very first time the command is executed
export async function activate(extensionContext: vscode.ExtensionContext) {

	const viewCommandPalleteWebviewViewProvider = new ViewCommandPalleteWebviewViewProvider(extensionContext);
	extensionContext.subscriptions.push(vscode.window.registerWebviewViewProvider("view-command-pallete-webview-view-provider", viewCommandPalleteWebviewViewProvider));

	const config = vscode.workspace.getConfiguration('calc');
	const outputChannel = vscode.window.createOutputChannel('calc');

	const onError = (error: unknown) => {
		if (error instanceof Error) {
			outputChannel.appendLine(error.message);
			if (error.stack) outputChannel.appendLine(error.stack);
		} else {
			outputChannel.appendLine((error as any).toString().message);
		}
	};

	const calcProvider = new Calculator.CalcProvider(config, onError);

	extensionContext.subscriptions.push(
		vscode.languages.registerCompletionItemProvider('*', calcProvider, '=', ' '),
		vscode.workspace.onDidOpenTextDocument(() => {
			calcProvider.clearHighlight().catch(onError);
		}),
		vscode.window.onDidChangeTextEditorSelection(() => {
			calcProvider.clearHighlight().catch(onError);
		}),
	);

	function getWebviewView(title: string) {
		const column = vscode.window.activeTextEditor
			? vscode.window.activeTextEditor.viewColumn
			: undefined;

		// Otherwise, create a new panel.
		const webviewView = vscode.window.createWebviewPanel(
			"web-view-panel",
			title,
			column || vscode.ViewColumn.One,
			{
				// Enable javascript in the webview
				enableScripts: true,

				// And restrict the webview to only loading content from our extension's `media` directory.
				localResourceRoots: [
					vscode.Uri.joinPath(extensionContext.extensionUri, "media"),
					vscode.Uri.joinPath(extensionContext.extensionUri, "out/compiled"),
				],
			}
		);
		return webviewView;
	}

	async function replaceResultsWithPositions(
		editor: vscode.TextEditor,
		positionsAndExpressions: [vscode.Position, string][],
		mode: 'append' | 'replace',
	) {
		await editor.edit((editBuilder) => {
			for (const [position, expression] of positionsAndExpressions) {
				const lineCalcResult = calcProvider.calculateLine(position, expression);
				if (lineCalcResult == null) {
					continue;
				}
				const { insertText, expressionWithEqualSignRange, expressionEndRange } =
					lineCalcResult;

				if (mode === 'append') {
					const endWithEqual = expression.trimEnd().endsWith('=');
					editBuilder.replace(
						expressionEndRange,
						endWithEqual ? insertText : ` = ${insertText}`,
					);
				} else if (mode === 'replace') {
					editBuilder.replace(expressionWithEqualSignRange, insertText);
				}
			}
		});
	}

	async function replaceResult(
		mode: 'append' | 'replace',
		withCursor: boolean,
	) {
		const editor = vscode.window.activeTextEditor;
		if (!editor || !editor.selection.isEmpty) {
			return;
		}
		const doc = editor.document;

		let positionsAndExpressions;
		if (withCursor) {
			positionsAndExpressions = editor.selections.map(
				(selection) =>
					<[vscode.Position, string]>[
						selection.active,
						doc
							.lineAt(selection.active.line)
							.text.slice(0, selection.active.character),
					],
			);
		} else {
			const uniqueLineNumbers = [
				...new Set(editor.selections.map((selection) => selection.active.line)),
			];
			positionsAndExpressions = uniqueLineNumbers.map((number) => {
				const line = doc.lineAt(number);
				return <[vscode.Position, string]>[line.range.end, line.text];
			});
		}
		await replaceResultsWithPositions(editor, positionsAndExpressions, mode);
	}

	extensionContext.subscriptions.push(
		vscode.commands.registerTextEditorCommand('extension.calcAppendWithCursor', () => {
			replaceResult('append', true).catch(onError);
		}),
		vscode.commands.registerTextEditorCommand('extension.calcAppend', () => {
			replaceResult('append', false).catch(onError);
		}),
		vscode.commands.registerTextEditorCommand(
			'extension.calcReplaceWithCursor',
			() => {
				replaceResult('replace', true).catch(onError);
			},
		),
		vscode.commands.registerTextEditorCommand('extension.calcReplace', () => {
			replaceResult('replace', false).catch(onError);
		}),
	);

	const commands = [
		vscode.commands.registerCommand("copyHelper.copySyntaxInLight", copyHelper.copySyntaxInLight),
		vscode.commands.registerCommand("extension.rotateExplorerSortOrder", settingsHelper.rotateExplorerSortOrder),
		vscode.commands.registerCommand("kanban.openWithTextEditor", kanbanHelper.openWithTextEditor),
		vscode.commands.registerCommand("kanban.openInNewWindow", kanbanHelper.openInNewWindow),
		vscode.commands.registerCommand("markdown.newMarkdownFile", markdownHelper.newMarkdownFile),
		vscode.commands.registerCommand('promiseLinesHelper.codeGeneratorQuickPick', promiseLinesHelper.codeGeneratorQuickPick),
		vscode.commands.registerCommand('promiseLinesHelper.insertDateTime', promiseLinesHelper.insertDateTime),
		vscode.commands.registerCommand("promiseLinesHelper.insertAllExtensions", promiseLinesHelper.insertAllExtensions),
		vscode.commands.registerCommand('promiseLinesHelper.transformToProperCase', promiseLinesHelper.transformToProperCase),
		vscode.commands.registerCommand('promiseLinesHelper.transformToParamCase', promiseLinesHelper.transformToParamCase),
		vscode.commands.registerCommand('readOnlyLinesHelper.searchGoogle', readOnlyLinesHelper.searchGoogle),
		vscode.commands.registerCommand('replaceLinesHelper.addCSharpComment', replaceLinesHelper.addCSharpComment),
		vscode.commands.registerCommand('replaceLinesHelper.addVBComment', replaceLinesHelper.addVBComment),
		vscode.commands.registerCommand('replaceLinesHelper.convertToRegularExpression', replaceLinesHelper.convertToRegularExpression),
		vscode.commands.registerCommand('replaceLinesHelper.cutEachLine', replaceLinesHelper.cutEachLine),
		vscode.commands.registerCommand('replaceLinesHelper.distinctLines', replaceLinesHelper.distinctLines),
		vscode.commands.registerCommand('replaceLinesHelper.expandSql', replaceLinesHelper.expandSql),
		vscode.commands.registerCommand('replaceLinesHelper.listToListFamily', replaceLinesHelper.listToListFamily),
		vscode.commands.registerCommand('replaceLinesHelper.listToListWrappedComma', replaceLinesHelper.listToListWrappedComma),
		vscode.commands.registerCommand('replaceLinesHelper.prettySql', replaceLinesHelper.prettySql),
		vscode.commands.registerCommand('replaceLinesHelper.quickFixCamelCaseProperties', replaceLinesHelper.quickFixCamelCaseProperties),
		vscode.commands.registerCommand('replaceLinesHelper.quickFixCS0108', replaceLinesHelper.quickFixCS0108),
		vscode.commands.registerCommand('replaceLinesHelper.quickFixInstanceFieldToCalisthenics', replaceLinesHelper.quickFixInstanceFieldToCalisthenics),
		vscode.commands.registerCommand('replaceLinesHelper.quickFixProperCaseProperties', replaceLinesHelper.quickFixProperCaseProperties),
		vscode.commands.registerCommand('replaceLinesHelper.quickFixPublic', replaceLinesHelper.quickFixPublic),
		vscode.commands.registerCommand('replaceLinesHelper.removeComment', replaceLinesHelper.removeComment),
		vscode.commands.registerCommand('replaceLinesHelper.sortLength', replaceLinesHelper.sortLength),
		vscode.commands.registerCommand('replaceLinesHelper.sortNormal', replaceLinesHelper.sortNormal),
		vscode.commands.registerCommand('replaceLinesHelper.splitBySpaceReverseJoinSort', replaceLinesHelper.splitBySpaceReverseJoinSort),
		vscode.commands.registerCommand('replaceLinesHelper.unwrapSql', replaceLinesHelper.unwrapSql),
		vscode.commands.registerCommand('replaceLinesHelper.wrapSqlCSharp', replaceLinesHelper.wrapSqlCSharp),
		vscode.commands.registerCommand('replaceLinesHelper.wrapSqlVB', replaceLinesHelper.wrapSqlVB),
		vscode.commands.registerCommand("webview.backlogMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'HTML'); }),
		vscode.commands.registerCommand("webview.costOfDelayMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', ''); }),
		vscode.commands.registerCommand("webview.costOfDelayEffortMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'EFFORT'); }),
		vscode.commands.registerCommand("webview.costOfDelayLiveMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'LIVE'); }),
		vscode.commands.registerCommand("webview.costOfDelayWSJFMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'WSJF'); }),
		vscode.commands.registerCommand("webview.backlogLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'HTML'); }),
		vscode.commands.registerCommand("webview.costOfDelayLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', ''); }),
		vscode.commands.registerCommand("webview.costOfDelayEffortLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'EFFORT'); }),
		vscode.commands.registerCommand("webview.costOfDelayLiveLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'LIVE'); }),
		vscode.commands.registerCommand("webview.costOfDelayWSJFLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'WSJF'); }),
		vscode.commands.registerCommand("webview.example", () => { WebviewPanelExample.WebviewPanelExample.createOrShow(extensionContext); })
	];

	commands.forEach(command => extensionContext.subscriptions.push(command));
}

// This method is called when your extension is deactivated
export function deactivate() { }