
import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
import { AsyncIterableObject } from '../../../../base/common/async.js';
import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
import { MouseTargetType } from '../../../browser/editorBrowser.js';
import { Position } from '../../../common/core/position.js';
import { ModelDecorationInjectedTextOptions } from '../../../common/model/textModel.js';
import { HoverForeignElementAnchor } from '../../hover/browser/hoverTypes.js';
import { ILanguageService } from '../../../common/languages/language.service.js';
import { ITextModelService } from '../../../common/services/resolverService.service.js';
import { getHoverProviderResultsAsAsyncIterable } from '../../hover/browser/getHover.js';
import { MarkdownHoverParticipant, MarkdownHover } from '../../hover/browser/markdownHoverParticipant.js';
import { InlayHintsController, RenderedInlayHintLabelPart } from './inlayHintsController.js';
import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
import { EditorOption } from '../../../common/config/editorOptions.js';
import { localize } from '../../../../nls.js';
import { isMacintosh } from '../../../../base/common/platform.js';
import { asCommandLink } from './inlayHints.js';
import { isNonEmptyArray } from '../../../../base/common/arrays.js';
import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
import { ICommandService } from '../../../../platform/commands/common/commands.service.js';

class InlayHintsHoverAnchor extends HoverForeignElementAnchor {
    constructor(part, owner, initialMousePosX, initialMousePosY) {
        super(10, owner, part.item.anchor.range, initialMousePosX, initialMousePosY, true);
        this.part = part;
    }
}
let InlayHintsHover = class InlayHintsHover extends MarkdownHoverParticipant {
    constructor(editor, languageService, openerService, keybindingService, hoverService, configurationService, _resolverService, languageFeaturesService, commandService) {
        super(editor, languageService, openerService, configurationService, languageFeaturesService, keybindingService, hoverService, commandService);
        this._resolverService = _resolverService;
        this.hoverOrdinal = 6;
    }
    suggestHoverAnchor(mouseEvent) {
        const controller = InlayHintsController.get(this._editor);
        if (!controller) {
            return null;
        }
        if (mouseEvent.target.type !== MouseTargetType.CONTENT_TEXT) {
            return null;
        }
        const options = mouseEvent.target.detail.injectedText?.options;
        if (!(options instanceof ModelDecorationInjectedTextOptions && options.attachedData instanceof RenderedInlayHintLabelPart)) {
            return null;
        }
        return ( new InlayHintsHoverAnchor(options.attachedData, this, mouseEvent.event.posx, mouseEvent.event.posy));
    }
    computeSync() {
        return [];
    }
    computeAsync(anchor, _lineDecorations, source, token) {
        if (!(anchor instanceof InlayHintsHoverAnchor)) {
            return AsyncIterableObject.EMPTY;
        }
        return (new AsyncIterableObject(async (executor) => {
            const { part } = anchor;
            await part.item.resolve(token);
            if (token.isCancellationRequested) {
                return;
            }
            let itemTooltip;
            if (typeof part.item.hint.tooltip === 'string') {
                itemTooltip = ( new MarkdownString()).appendText(part.item.hint.tooltip);
            }
            else if (part.item.hint.tooltip) {
                itemTooltip = part.item.hint.tooltip;
            }
            if (itemTooltip) {
                executor.emitOne(( new MarkdownHover(this, anchor.range, [itemTooltip], false, 0)));
            }
            if (isNonEmptyArray(part.item.hint.textEdits)) {
                executor.emitOne(( new MarkdownHover(this, anchor.range, [( new MarkdownString()).appendText(( localize(1194, "Double-click to insert")))], false, 10001)));
            }
            let partTooltip;
            if (typeof part.part.tooltip === 'string') {
                partTooltip = ( new MarkdownString()).appendText(part.part.tooltip);
            }
            else if (part.part.tooltip) {
                partTooltip = part.part.tooltip;
            }
            if (partTooltip) {
                executor.emitOne(( new MarkdownHover(this, anchor.range, [partTooltip], false, 1)));
            }
            if (part.part.location || part.part.command) {
                let linkHint;
                const useMetaKey = this._editor.getOption(EditorOption.multiCursorModifier) === 'altKey';
                const kb = useMetaKey
                    ? isMacintosh
                        ? ( localize(1195, "cmd + click"))
                        : ( localize(1196, "ctrl + click"))
                    : isMacintosh
                        ? ( localize(1197, "option + click"))
                        : ( localize(1198, "alt + click"));
                if (part.part.location && part.part.command) {
                    linkHint = ( new MarkdownString()).appendText(( localize(1199, 'Go to Definition ({0}), right click for more', kb)));
                }
                else if (part.part.location) {
                    linkHint = ( new MarkdownString()).appendText(( localize(1200, 'Go to Definition ({0})', kb)));
                }
                else if (part.part.command) {
                    linkHint = ( new MarkdownString(`[${( localize(1201, "Execute Command"))}](${asCommandLink(part.part.command)} "${part.part.command.title}") (${kb})`, { isTrusted: true }));
                }
                if (linkHint) {
                    executor.emitOne(( new MarkdownHover(this, anchor.range, [linkHint], false, 10000)));
                }
            }
            const iterable = await this._resolveInlayHintLabelPartHover(part, token);
            for await (const item of iterable) {
                executor.emitOne(item);
            }
        }));
    }
    async _resolveInlayHintLabelPartHover(part, token) {
        if (!part.part.location) {
            return AsyncIterableObject.EMPTY;
        }
        const { uri, range } = part.part.location;
        const ref = await this._resolverService.createModelReference(uri);
        try {
            const model = ref.object.textEditorModel;
            if (!( this._languageFeaturesService.hoverProvider.has(model))) {
                return AsyncIterableObject.EMPTY;
            }
            return ( getHoverProviderResultsAsAsyncIterable(this._languageFeaturesService.hoverProvider, model, ( new Position(range.startLineNumber, range.startColumn)), token)
                .filter(item => !isEmptyMarkdownString(item.hover.contents))
                .map(item => ( new MarkdownHover(this, part.item.anchor.range, item.hover.contents, false, 2 + item.ordinal))));
        }
        finally {
            ref.dispose();
        }
    }
};
InlayHintsHover = ( __decorate([
    ( __param(1, ILanguageService)),
    ( __param(2, IOpenerService)),
    ( __param(3, IKeybindingService)),
    ( __param(4, IHoverService)),
    ( __param(5, IConfigurationService)),
    ( __param(6, ITextModelService)),
    ( __param(7, ILanguageFeaturesService)),
    ( __param(8, ICommandService))
], InlayHintsHover));

export { InlayHintsHover };
