// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

import { IWorkspaceService } from './common/application/types';
import { isTestExecution } from './common/constants';
import { traceError } from './common/logger';
import { ITerminalHelper } from './common/terminal/types';
import { IConfigurationService, Resource } from './common/types';
import {
    AutoSelectionRule,
    IInterpreterAutoSelectionRule,
    IInterpreterAutoSelectionService
} from './interpreter/autoSelection/types';
import { ICondaService, IInterpreterService, PythonInterpreter } from './interpreter/contracts';
import { IServiceContainer } from './ioc/types';
import { sendTelemetryEvent } from './telemetry';
import { EventName } from './telemetry/constants';
import { EditorLoadTelemetry } from './telemetry/types';

interface IStopWatch {
    elapsedTime: number;
}

export async function sendStartupTelemetry(
    // tslint:disable-next-line:no-any
    activatedPromise: Promise<any>,
    durations: Record<string, number>,
    stopWatch: IStopWatch,
    serviceContainer: IServiceContainer
) {
    if (isTestExecution()) {
        return;
    }

    try {
        await activatedPromise;
        durations.totalActivateTime = stopWatch.elapsedTime;
        const props = await getActivationTelemetryProps(serviceContainer);
        sendTelemetryEvent(EventName.EDITOR_LOAD, durations, props);
    } catch (ex) {
        traceError('sendStartupTelemetry() failed.', ex);
    }
}

export async function sendErrorTelemetry(
    ex: Error,
    durations: Record<string, number>,
    serviceContainer?: IServiceContainer
) {
    try {
        // tslint:disable-next-line:no-any
        let props: any = {};
        if (serviceContainer) {
            try {
                props = await getActivationTelemetryProps(serviceContainer);
            } catch (ex) {
                traceError('getActivationTelemetryProps() failed.', ex);
            }
        }
        sendTelemetryEvent(EventName.EDITOR_LOAD, durations, props, ex);
    } catch (exc2) {
        traceError('sendErrorTelemetry() failed.', exc2);
    }
}

function isUsingGlobalInterpreterInWorkspace(currentPythonPath: string, serviceContainer: IServiceContainer): boolean {
    const service = serviceContainer.get<IInterpreterAutoSelectionService>(IInterpreterAutoSelectionService);
    const globalInterpreter = service.getAutoSelectedInterpreter(undefined);
    if (!globalInterpreter) {
        return false;
    }
    return currentPythonPath === globalInterpreter.path;
}

function hasUserDefinedPythonPath(resource: Resource, serviceContainer: IServiceContainer) {
    const workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);
    const settings = workspaceService.getConfiguration('python', resource)!.inspect<string>('pythonPath')!;
    return (settings.workspaceFolderValue && settings.workspaceFolderValue !== 'python') ||
        (settings.workspaceValue && settings.workspaceValue !== 'python') ||
        (settings.globalValue && settings.globalValue !== 'python')
        ? true
        : false;
}

function getPreferredWorkspaceInterpreter(resource: Resource, serviceContainer: IServiceContainer) {
    const workspaceInterpreterSelector = serviceContainer.get<IInterpreterAutoSelectionRule>(
        IInterpreterAutoSelectionRule,
        AutoSelectionRule.workspaceVirtualEnvs
    );
    const interpreter = workspaceInterpreterSelector.getPreviouslyAutoSelectedInterpreter(resource);
    return interpreter ? interpreter.path : undefined;
}

async function getActivationTelemetryProps(serviceContainer: IServiceContainer): Promise<EditorLoadTelemetry> {
    // tslint:disable-next-line:no-suspicious-comment
    // TODO: Not all of this data is showing up in the database...
    // tslint:disable-next-line:no-suspicious-comment
    // TODO: If any one of these parts fails we send no info.  We should
    // be able to partially populate as much as possible instead
    // (through granular try-catch statements).
    const terminalHelper = serviceContainer.get<ITerminalHelper>(ITerminalHelper);
    const terminalShellType = terminalHelper.identifyTerminalShell();
    const condaLocator = serviceContainer.get<ICondaService>(ICondaService);
    const interpreterService = serviceContainer.get<IInterpreterService>(IInterpreterService);
    const workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);
    const configurationService = serviceContainer.get<IConfigurationService>(IConfigurationService);
    const mainWorkspaceUri = workspaceService.hasWorkspaceFolders
        ? workspaceService.workspaceFolders![0].uri
        : undefined;
    const settings = configurationService.getSettings(mainWorkspaceUri);
    const [condaVersion, interpreter, interpreters] = await Promise.all([
        condaLocator
            .getCondaVersion()
            .then(ver => (ver ? ver.raw : ''))
            .catch<string>(() => ''),
        interpreterService.getActiveInterpreter().catch<PythonInterpreter | undefined>(() => undefined),
        interpreterService.getInterpreters(mainWorkspaceUri).catch<PythonInterpreter[]>(() => [])
    ]);
    const workspaceFolderCount = workspaceService.hasWorkspaceFolders ? workspaceService.workspaceFolders!.length : 0;
    const pythonVersion = interpreter && interpreter.version ? interpreter.version.raw : undefined;
    const interpreterType = interpreter ? interpreter.type : undefined;
    const usingUserDefinedInterpreter = hasUserDefinedPythonPath(mainWorkspaceUri, serviceContainer);
    const preferredWorkspaceInterpreter = getPreferredWorkspaceInterpreter(mainWorkspaceUri, serviceContainer);
    const usingGlobalInterpreter = isUsingGlobalInterpreterInWorkspace(settings.pythonPath, serviceContainer);
    const usingAutoSelectedWorkspaceInterpreter = preferredWorkspaceInterpreter
        ? settings.pythonPath === getPreferredWorkspaceInterpreter(mainWorkspaceUri, serviceContainer)
        : false;
    const hasPython3 =
        interpreters!.filter(item => (item && item.version ? item.version.major === 3 : false)).length > 0;

    return {
        condaVersion,
        terminal: terminalShellType,
        pythonVersion,
        interpreterType,
        workspaceFolderCount,
        hasPython3,
        usingUserDefinedInterpreter,
        usingAutoSelectedWorkspaceInterpreter,
        usingGlobalInterpreter
    };
}