// *****************************************************************************
// Copyright (C) 2025 EclipseSource GmbH.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// http://www.eclipse.org/legal/epl-2.0.
//
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License v. 2.0 are satisfied: GNU General Public License, version 2
// with the GNU Classpath Exception which is available at
// https://www.gnu.org/software/classpath/license.html.
//
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
// *****************************************************************************

import { nls } from '@theia/core/lib/common/nls';
import { inject, injectable } from '@theia/core/shared/inversify';
import { Prioritizeable } from '@theia/core/lib/common/prioritizeable';
import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
import { AiConfigurationService, LanguageModel, LanguageModelResponse, ReasoningSettings, UserRequest } from '../common';
import { LanguageModelServiceImpl } from '../common/language-model-service';
import {
    PREFERENCE_NAME_REQUEST_SETTINGS,
    PREFERENCE_NAME_REASONING,
    RequestSetting,
    ReasoningPreferenceEntry,
    getRequestSettingSpecificity
} from '../common/ai-core-preferences';

@injectable()
export class FrontendLanguageModelServiceImpl extends LanguageModelServiceImpl {

    @inject(WorkspaceTrustService)
    protected readonly workspaceTrustService: WorkspaceTrustService;

    @inject(AiConfigurationService)
    protected readonly aiConfiguration: AiConfigurationService;

    override async sendRequest(
        languageModel: LanguageModel,
        languageModelRequest: UserRequest
    ): Promise<LanguageModelResponse> {
        const requestSettings = this.aiConfiguration.get<RequestSetting[]>(PREFERENCE_NAME_REQUEST_SETTINGS, []) ?? [];
        const reasoningEntries = this.aiConfiguration.get<ReasoningPreferenceEntry[]>(PREFERENCE_NAME_REASONING, []) ?? [];
        const trusted = await this.workspaceTrustService.getWorkspaceTrust();
        if (!trusted) {
            throw new Error(nls.localize('theia/ai-core/aiDisabledInRestrictedMode', 'AI features are not available in untrusted workspaces.'));
        }

        const ids = languageModel.id.split('/');
        const matchingSetting = mergeRequestSettings(requestSettings, ids[1], ids[0], languageModelRequest.agentId);
        if (matchingSetting?.requestSettings) {
            // Merge the settings, with user request taking precedence
            languageModelRequest.settings = {
                ...matchingSetting.requestSettings,
                ...languageModelRequest.settings
            };
        }
        if (matchingSetting?.clientSettings) {
            // Merge the clientSettings, with user request taking precedence
            languageModelRequest.clientSettings = {
                ...matchingSetting.clientSettings,
                ...languageModelRequest.clientSettings
            };
        }

        // Reasoning resolution order (highest first): already-set session override → preference entry
        // matching this scope → model's declared `defaultLevel`. The selector displays the same
        // fallback chain, so what the user sees is what gets sent.
        if (!languageModelRequest.reasoning) {
            const matchingReasoning = mergeReasoningSettings(reasoningEntries, ids[1], ids[0], languageModelRequest.agentId);
            if (matchingReasoning?.reasoning) {
                languageModelRequest.reasoning = matchingReasoning.reasoning;
            } else if (languageModel.reasoningSupport?.defaultLevel) {
                languageModelRequest.reasoning = { level: languageModel.reasoningSupport.defaultLevel };
            }
        }

        return super.sendRequest(languageModel, languageModelRequest);
    }
}

export const mergeRequestSettings = (requestSettings: RequestSetting[], modelId: string, providerId: string, agentId?: string): RequestSetting => {
    const prioritizedSettings = Prioritizeable.prioritizeAllSync(requestSettings,
        setting => getRequestSettingSpecificity(setting, {
            modelId,
            providerId,
            agentId
        }));
    // merge all settings from lowest to highest, identical priorities will be overwritten by the following
    const matchingSetting = prioritizedSettings.reduceRight((acc, cur) => ({ ...acc, ...cur.value }), {} as RequestSetting);
    return matchingSetting;
};

export const mergeReasoningSettings = (
    reasoningEntries: ReasoningPreferenceEntry[],
    modelId: string,
    providerId: string,
    agentId?: string
): ReasoningPreferenceEntry | undefined => {
    const prioritizedSettings = Prioritizeable.prioritizeAllSync(reasoningEntries,
        setting => getRequestSettingSpecificity(setting, {
            modelId,
            providerId,
            agentId
        }));
    const matchingSetting = prioritizedSettings.reduceRight<ReasoningPreferenceEntry | undefined>(
        (acc, cur) => {
            if (!acc) {
                return cur.value;
            }
            return {
                ...acc,
                reasoning: {
                    ...acc.reasoning,
                    ...cur.value.reasoning
                } as ReasoningSettings
            };
        },
        undefined
    );
    return matchingSetting;
};
