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

import * as dom from '../../../../base/browser/dom.js';

import { IMouseWheelEvent, StandardMouseEvent } from '../../../../base/browser/mouseEvent.js';

import { Button } from '../../../../base/browser/ui/button/button.js';

import { IHoverOptions } from '../../../../base/browser/ui/hover/hover.js';
import { HoverPosition } from '../../../../base/browser/ui/hover/hoverWidget.js';

import { IListRenderer, IListVirtualDelegate } from '../../../../base/browser/ui/list/list.js';

import { ITreeContextMenuEvent, ITreeElement } from '../../../../base/browser/ui/tree/tree.js';

import { disposableTimeout, RunOnceScheduler, timeout } from '../../../../base/common/async.js';

import { CancellationToken } from '../../../../base/common/cancellation.js';

import { Codicon } from '../../../../base/common/codicons.js';

import { fromNow, fromNowByDay } from '../../../../base/common/date.js';

import { toErrorMessage } from '../../../../base/common/errorMessage.js';
import { Emitter, Event } from '../../../../base/common/event.js';

import { FuzzyScore } from '../../../../base/common/filters.js';

import { IMarkdownString, MarkdownString } from '../../../../base/common/htmlContent.js';

import { Iterable } from '../../../../base/common/iterator.js';

import { KeyCode } from '../../../../base/common/keyCodes.js';

import { Disposable, DisposableStore, IDisposable, MutableDisposable, thenIfNotDisposed } from '../../../../base/common/lifecycle.js';

import { ResourceSet } from '../../../../base/common/map.js';

import { Schemas } from '../../../../base/common/network.js';

import { filter } from '../../../../base/common/objects.js';

import { autorun, observableFromEvent, observableValue } from '../../../../base/common/observable.js';

import { basename, extUri, isEqual } from '../../../../base/common/resources.js';

import { MicrotaskDelay } from '../../../../base/common/symbols.js';

import { isDefined } from '../../../../base/common/types.js';
import { URI } from '../../../../base/common/uri.js';
import { ICodeEditor } from '../../../../editor/browser/editorBrowser.js';
import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';

import { OffsetRange } from '../../../../editor/common/core/ranges/offsetRange.js';

import { localize } from '../../../../nls.js';

import { MenuId } from '../../../../platform/actions/common/actions.js';

import { ICommandService } from '../../../../platform/commands/common/commands.js';

import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';

import { ContextKeyExpr, IContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';

import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
import { ITextResourceEditorInput } from '../../../../platform/editor/common/editor.js';

import { IHoverService, WorkbenchHoverDelegate } from '../../../../platform/hover/browser/hover.js';

import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';

import { WorkbenchList, WorkbenchObjectTree } from '../../../../platform/list/browser/listService.js';

import { ILogService } from '../../../../platform/log/common/log.js';

import { bindContextKey } from '../../../../platform/observable/common/platformObservableUtils.js';

import product from '../../../../platform/product/common/product.js';

import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';

import { buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground } from '../../../../platform/theme/common/colorRegistry.js';

import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';

import { IThemeService } from '../../../../platform/theme/common/themeService.js';

import { IWorkspaceContextService, WorkbenchState } from '../../../../platform/workspace/common/workspace.js';

import { EditorResourceAccessor } from '../../../../workbench/common/editor.js';
import { IEditorService } from '../../../../workbench/services/editor/common/editorService.js';

import { ViewContainerLocation } from '../../../common/views.js';

import { IChatEntitlementService } from '../../../services/chat/common/chatEntitlementService.js';

import { IWorkbenchLayoutService, Position } from '../../../services/layout/browser/layoutService.js';

import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';

import { IViewsService } from '../../../services/views/common/viewsService.js';

import { katexContainerClassName } from '../../markdown/common/markedKatexExtension.js';

import { checkModeOption } from '../common/chat.js';

import { IChatAgentAttachmentCapabilities, IChatAgentCommand, IChatAgentData, IChatAgentService } from '../common/chatAgents.js';

import { ChatContextKeys } from '../common/chatContextKeys.js';

import { applyingChatEditsFailedContextKey, decidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey, IChatEditingService, IChatEditingSession, inChatEditingSessionContextKey, ModifiedFileEntryState } from '../common/chatEditingService.js';

import { IChatLayoutService } from '../common/chatLayoutService.js';

import { IChatModel, IChatResponseModel } from '../common/chatModel.js';

import { ChatMode, IChatModeService } from '../common/chatModes.js';

import { chatAgentLeader, ChatRequestAgentPart, ChatRequestDynamicVariablePart, ChatRequestSlashPromptPart, ChatRequestToolPart, ChatRequestToolSetPart, chatSubcommandLeader, formatChatQuestion, IParsedChatRequest } from '../common/chatParserTypes.js';

import { ChatRequestParser } from '../common/chatRequestParser.js';

import { IChatLocationData, IChatSendRequestOptions, IChatService } from '../common/chatService.js';

import { IChatSessionsService } from '../common/chatSessionsService.js';

import { IChatSlashCommandService } from '../common/chatSlashCommands.js';

import { IChatTodoListService } from '../common/chatTodoListService.js';

import { ChatRequestVariableSet, IChatRequestVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, PromptFileVariableKind, toPromptFileVariableEntry } from '../common/chatVariableEntries.js';

import { ChatViewModel, IChatRequestViewModel, IChatResponseViewModel, isRequestVM, isResponseVM } from '../common/chatViewModel.js';

import { IChatInputState } from '../common/chatWidgetHistoryService.js';

import { CodeBlockModelCollection } from '../common/codeBlockModelCollection.js';

import { ChatAgentLocation, ChatConfiguration, ChatModeKind } from '../common/constants.js';

import { ILanguageModelToolsService, IToolData, ToolSet } from '../common/languageModelToolsService.js';

import { ComputeAutomaticInstructions } from '../common/promptSyntax/computeAutomaticInstructions.js';
import { PromptsConfig } from '../common/promptSyntax/config/config.js';

import { IHandOff, PromptHeader, Target } from '../common/promptSyntax/promptFileParser.js';

import { IPromptsService } from '../common/promptSyntax/service/promptsService.js';

import { handleModeSwitch } from './actions/chatActions.js';

import { ChatTreeItem, ChatViewId, IChatAcceptInputOptions, IChatAccessibilityService, IChatCodeBlockInfo, IChatFileTreeInfo, IChatListItemRendererOptions, IChatWidget, IChatWidgetService, IChatWidgetViewContext, IChatWidgetViewOptions, isIChatResourceViewContext, isIChatViewViewContext } from './chat.js';

import { ChatAccessibilityProvider } from './chatAccessibilityProvider.js';

import { ChatAttachmentModel } from './chatAttachmentModel.js';

import { ChatSuggestNextWidget } from './chatContentParts/chatSuggestNextWidget.js';

import { ChatInputPart, IChatInputPartOptions, IChatInputStyles } from './chatInputPart.js';

import { ChatListDelegate, ChatListItemRenderer, IChatListItemTemplate, IChatRendererDelegate } from './chatListRenderer.js';

import { ChatEditorOptions } from './chatOptions.js';

import { ChatViewPane } from './chatViewPane.js';

import './media/chat.css';
import './media/chatAgentHover.css';
import './media/chatViewWelcome.css';

import { ChatViewWelcomePart, IChatSuggestedPrompts, IChatViewWelcomeContent } from './viewsWelcome/chatViewWelcomeController.js';

const $ = dom.$;

const defaultChat = {
	provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
	termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
	privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? ''
};

export interface IChatViewState {

	inputValue?: string;

	inputState?: IChatInputState;

}

export interface IChatWidgetStyles extends IChatInputStyles {

	inputEditorBackground: string;
	resultEditorBackground: string;
}

export interface IChatWidgetContrib extends IDisposable {
	readonly id: string;

	/**
	 * A piece of state which is related to the input editor of the chat widget
	 */

	getInputState?(): IChatInputState;

	/**
	 * Called with the result of getInputState when navigating input history.
	 */

	setInputState?(s: IChatInputState): void;

}

interface IChatRequestInputOptions {
	input: string;
	attachedContext: ChatRequestVariableSet;
}

export interface IChatWidgetLocationOptions {
	location: ChatAgentLocation;
	resolveData?(): IChatLocationData | undefined;
}

export function isQuickChat(widget: IChatWidget): boolean {

	return isIChatResourceViewContext(widget.viewContext) && Boolean(widget.viewContext.isQuickChat);

}

export function isInlineChat(widget: IChatWidget): boolean {

	return isIChatResourceViewContext(widget.viewContext) && Boolean(widget.viewContext.isInlineChat);

}

interface IChatHistoryListItem {

	readonly sessionResource: URI;

	readonly title: string;
	readonly lastMessageDate: number;
	readonly isActive: boolean;
}

type ChatHandoffClickEvent = {
	fromAgent: string;
	toAgent: string;
	hasPrompt: boolean;
	autoSend: boolean;
};

type ChatHandoffClickClassification = {
	owner: 'digitarald';
	comment: 'Event fired when a user clicks on a handoff prompt in the chat suggest-next widget';
	fromAgent: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The agent/mode the user was in before clicking the handoff' };
	toAgent: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The agent/mode specified in the handoff' };
	hasPrompt: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Whether the handoff includes a prompt' };
	autoSend: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Whether the handoff automatically submits the request' };
};

type ChatHandoffWidgetShownEvent = {
	agent: string;
	handoffCount: number;
};

type ChatHandoffWidgetShownClassification = {
	owner: 'digitarald';
	comment: 'Event fired when the suggest-next widget is shown with handoff prompts';
	agent: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The current agent/mode that has handoffs defined' };
	handoffCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Number of handoff options shown to the user' };
};

class ChatHistoryListDelegate implements IListVirtualDelegate<IChatHistoryListItem> {
	getHeight(element: IChatHistoryListItem): number {
		return 22;
	}

	getTemplateId(element: IChatHistoryListItem): string {
		return 'chatHistoryItem';
	}
}

interface IChatHistoryTemplate {
	container: HTMLElement;
	title: HTMLElement;
	date: HTMLElement;
	disposables: DisposableStore;
}

class ChatHistoryHoverDelegate extends WorkbenchHoverDelegate {
	constructor(
		private readonly getViewContainerLocation: () => ViewContainerLocation,
		@IWorkbenchLayoutService private readonly layoutService: IWorkbenchLayoutService,
		@IConfigurationService configurationService: IConfigurationService,
		@IHoverService hoverService: IHoverService,
	) {
		super('element', {
			instantHover: true
		}, () => this.getHoverOptions(), configurationService, hoverService);
	}

	private getHoverOptions(): Partial<IHoverOptions> {
		const sideBarPosition = this.layoutService.getSideBarPosition();
		const viewContainerLocation = this.getViewContainerLocation();

		let hoverPosition: HoverPosition;
		if (viewContainerLocation === ViewContainerLocation.Sidebar) {
			hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.RIGHT : HoverPosition.LEFT;
		} else if (viewContainerLocation === ViewContainerLocation.AuxiliaryBar) {
			hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.LEFT : HoverPosition.RIGHT;
		} else {
			hoverPosition = HoverPosition.RIGHT;
		}

		return { additionalClasses: ['chat-history-item-hover'], position: { hoverPosition, forcePosition: true } };
	}
}

class ChatHistoryListRenderer implements IListRenderer<IChatHistoryListItem, IChatHistoryTemplate> {
	readonly templateId = 'chatHistoryItem';

	constructor(
		private readonly onDidClickItem: (item: IChatHistoryListItem) => void,
		private readonly formatHistoryTimestamp: (timestamp: number, todayMidnightMs: number) => string,
		private readonly todayMidnightMs: number
	) { }

	renderTemplate(container: HTMLElement): IChatHistoryTemplate {
		const disposables = new DisposableStore();

		container.classList.add('chat-welcome-history-item');
		const title = dom.append(container, $('.chat-welcome-history-title'));
		const date = dom.append(container, $('.chat-welcome-history-date'));

		container.tabIndex = 0;
		container.setAttribute('role', 'button');

		return { container, title, date, disposables };
	}

	renderElement(element: IChatHistoryListItem, index: number, templateData: IChatHistoryTemplate): void {
		const { container, title, date, disposables } = templateData;

		disposables.clear();

		title.textContent = element.title;
		date.textContent = this.formatHistoryTimestamp(element.lastMessageDate, this.todayMidnightMs);
		container.setAttribute('aria-label', element.title);

		disposables.add(dom.addDisposableListener(container, dom.EventType.CLICK, () => {
			this.onDidClickItem(element);
		}));

		disposables.add(dom.addStandardDisposableListener(container, dom.EventType.KEY_DOWN, e => {
			if (e.equals(KeyCode.Enter) || e.equals(KeyCode.Space)) {
				e.preventDefault();
				e.stopPropagation();
				this.onDidClickItem(element);
			}
		}));
	}

	disposeTemplate(templateData: IChatHistoryTemplate): void {
		templateData.disposables.dispose();
	}
}

const supportsAllAttachments: Required<IChatAgentAttachmentCapabilities> = {
	supportsFileAttachments: true,
	supportsToolAttachments: true,
	supportsMCPAttachments: true,
	supportsImageAttachments: true,
	supportsSearchResultAttachments: true,
	supportsInstructionAttachments: true,
	supportsSourceControlAttachments: true,
	supportsProblemAttachments: true,
	supportsSymbolAttachments: true,

	supportsTerminalAttachments: true,

};

export class ChatWidget extends Disposable implements IChatWidget {

	// eslint-disable-next-line @typescript-eslint/no-explicit-any

	public static readonly CONTRIBS: { new(...args: [IChatWidget, ...any]): IChatWidgetContrib }[] = [];

	private readonly _onDidSubmitAgent = this._register(new Emitter<{ agent: IChatAgentData; slashCommand?: IChatAgentCommand }>());
	public readonly onDidSubmitAgent = this._onDidSubmitAgent.event;

	private _onDidChangeAgent = this._register(new Emitter<{ agent: IChatAgentData; slashCommand?: IChatAgentCommand }>());
	readonly onDidChangeAgent = this._onDidChangeAgent.event;

	private _onDidFocus = this._register(new Emitter<void>());
	readonly onDidFocus = this._onDidFocus.event;

	private _onDidChangeViewModel = this._register(new Emitter<void>());
	readonly onDidChangeViewModel = this._onDidChangeViewModel.event;

	private _onDidScroll = this._register(new Emitter<void>());
	readonly onDidScroll = this._onDidScroll.event;

	private _onDidAcceptInput = this._register(new Emitter<void>());
	readonly onDidAcceptInput = this._onDidAcceptInput.event;

	private _onDidHide = this._register(new Emitter<void>());
	readonly onDidHide = this._onDidHide.event;

	private _onDidShow = this._register(new Emitter<void>());
	readonly onDidShow = this._onDidShow.event;

	private _onDidChangeParsedInput = this._register(new Emitter<void>());
	readonly onDidChangeParsedInput = this._onDidChangeParsedInput.event;

	private readonly _onWillMaybeChangeHeight = new Emitter<void>();
	readonly onWillMaybeChangeHeight: Event<void> = this._onWillMaybeChangeHeight.event;

	private _onDidChangeHeight = this._register(new Emitter<number>());
	readonly onDidChangeHeight = this._onDidChangeHeight.event;

	private readonly _onDidChangeContentHeight = new Emitter<void>();
	readonly onDidChangeContentHeight: Event<void> = this._onDidChangeContentHeight.event;

	private contribs: ReadonlyArray<IChatWidgetContrib> = [];

	private tree!: WorkbenchObjectTree<ChatTreeItem, FuzzyScore>;

	private renderer!: ChatListItemRenderer;

	private readonly _codeBlockModelCollection: CodeBlockModelCollection;

	private lastItem: ChatTreeItem | undefined;

	private readonly inputPartDisposable: MutableDisposable<ChatInputPart> = this._register(new MutableDisposable());
	private readonly inlineInputPartDisposable: MutableDisposable<ChatInputPart> = this._register(new MutableDisposable());

	private readonly timeoutDisposable: MutableDisposable<IDisposable> = this._register(new MutableDisposable());

	private inputContainer!: HTMLElement;
	private focusedInputDOM!: HTMLElement;

	private editorOptions!: ChatEditorOptions;

	private recentlyRestoredCheckpoint: boolean = false;

	private settingChangeCounter = 0;

	private listContainer!: HTMLElement;
	private container!: HTMLElement;

	private historyListContainer!: HTMLElement;

	get domNode() {
		return this.container;
	}

	private welcomeMessageContainer!: HTMLElement;

	private readonly welcomePart: MutableDisposable<ChatViewWelcomePart> = this._register(new MutableDisposable());

	private readonly welcomeContextMenuDisposable: MutableDisposable<IDisposable> = this._register(new MutableDisposable());

	private readonly historyViewStore = this._register(new DisposableStore());

	private readonly chatSuggestNextWidget: ChatSuggestNextWidget;

	private historyList: WorkbenchList<IChatHistoryListItem> | undefined;

	private bodyDimension: dom.Dimension | undefined;

	private visibleChangeCount = 0;

	private requestInProgress: IContextKey<boolean>;

	private agentInInput: IContextKey<boolean>;

	private inEmptyStateWithHistoryEnabledKey: IContextKey<boolean>;

	private currentRequest: Promise<void> | undefined;

	private _visible = false;
	public get visible() {
		return this._visible;
	}

	private previousTreeScrollHeight: number = 0;

	/**
	 * Whether the list is scroll-locked to the bottom. Initialize to true so that we can scroll to the bottom on first render.
	 * The initial render leads to a lot of `onDidChangeTreeContentHeight` as the renderer works out the real heights of rows.

	*/

	private scrollLock = true;

	private _instructionFilesCheckPromise: Promise<boolean> | undefined;
	private _instructionFilesExist: boolean | undefined;

	private readonly viewModelDisposables = this._register(new DisposableStore());

	private _viewModel: ChatViewModel | undefined;

	// Welcome view rendering scheduler to prevent reentrant calls
	private _welcomeRenderScheduler: RunOnceScheduler;

	// Coding agent locking state

	private _lockedAgent?: {
		id: string;
		name: string;
		prefix: string;
		displayName: string;
	};
	private readonly _lockedToCodingAgentContextKey: IContextKey<boolean>;
	private readonly _agentSupportsAttachmentsContextKey: IContextKey<boolean>;

	private _attachmentCapabilities: IChatAgentAttachmentCapabilities = supportsAllAttachments;

	// Cache for prompt file descriptions to avoid async calls during rendering
	private readonly promptDescriptionsCache = new Map<string, string>();

	private readonly promptUriCache = new Map<string, URI>();

	private _isLoadingPromptDescriptions = false;

	private _mostRecentlyFocusedItemIndex: number = -1;

	private set viewModel(viewModel: ChatViewModel | undefined) {

		if (this._viewModel === viewModel) {
			return;
		}

		this.viewModelDisposables.clear();

		this._viewModel = viewModel;
		if (viewModel) {
			this.viewModelDisposables.add(viewModel);

			this.logService.debug('ChatWidget#setViewModel: have viewModel');
		} else {
			this.logService.debug('ChatWidget#setViewModel: no viewModel');

		}

		this._onDidChangeViewModel.fire();
	}

	get viewModel() {
		return this._viewModel;
	}

	private readonly _editingSession = observableValue<IChatEditingSession | undefined>(this, undefined);

	private parsedChatRequest: IParsedChatRequest | undefined;
	get parsedInput() {
		if (this.parsedChatRequest === undefined) {

			if (!this.viewModel) {
				return { text: '', parts: [] };
			}

			this.parsedChatRequest = this.instantiationService.createInstance(ChatRequestParser)

				.parseChatRequest(this.viewModel.sessionResource, this.getInput(), this.location, {

					selectedAgent: this._lastSelectedAgent,
					mode: this.input.currentModeKind,

					forcedAgent: this._lockedAgent?.id ? this.chatAgentService.getAgent(this._lockedAgent.id) : undefined

				});

			this._onDidChangeParsedInput.fire();

		}

		return this.parsedChatRequest;
	}

	get scopedContextKeyService(): IContextKeyService {
		return this.contextKeyService;
	}

	private readonly _location: IChatWidgetLocationOptions;
	get location() {
		return this._location.location;
	}

	readonly viewContext: IChatWidgetViewContext;

	get supportsChangingModes(): boolean {
		return !!this.viewOptions.supportsChangingModes;

	}

	get chatDisclaimer(): string {
		return localize('chatDisclaimer', "AI responses may be inaccurate.");
	}