/*!
 * Copyright (C) Microsoft Corporation. All rights reserved.
 */
import { ArgumentProvider } from './ArgumentProvider.js';
import { PacCliAuthenticationProvider } from './Authentication/PacCliAuthenticationProvider.js';
import { initializeCliSettings, setCliLogger } from './CliSettings.js';
import { CliError } from './Errors/CliError.js';
import { CliHttpClient } from './HttpClient/CliHttpClient.js';
import { CliLogger } from './Logger/CliLogger.js';
import { addDataSourceAsync, addDataverseApiAsync, addFlowAsync, createConnectionVerbAsync, deleteDataSourceAsync, findDataverseApiAsync, getCodeAppsAsync, initAsync, listConnectionReferences, listConnectionsAsync, listDatasetsAsync, listSqlStoredProceduresAsync, listTablesAsync, logoutAsync, pushAsync, refreshDataSourceAsync, removeFlowAsync, runAsync, } from './Verbs/index.js';
import { listAllEnvironmentVariablesAsync } from './Verbs/ListEnvironmentVariables.js';
import { listFlowsAsync } from './Verbs/ListFlows.js';
import { modifyTelemetrySettings } from './Verbs/TelemetrySettings.js';
let logger;
let exitCode = 0;
export async function boot() {
    try {
        if (process.argv.includes('--no-color')) {
            process.env.NO_COLOR = '1';
        }
        const isPacCli = process.env.IS_PAC_CLI === 'true';
        const isTestRun = process.env.CI === 'true';
        const hasNonInteractiveFlag = process.argv.includes('--non-interactive');
        const source = isPacCli ? 'pac-cli' : 'standalone';
        const interactive = !isPacCli && !isTestRun && !hasNonInteractiveFlag && process.stdin.isTTY === true;
        const cliSettings = await initializeCliSettings({ source, interactive });
        let authenticationProvider;
        if (isPacCli) {
            authenticationProvider = new PacCliAuthenticationProvider();
        }
        else if (isTestRun) {
            const { ServicePrincipalAuthenticationProvider } = await import('./Authentication/ServicePrincipalAuthenticationProvider.js');
            authenticationProvider = new ServicePrincipalAuthenticationProvider();
        }
        else {
            // Dynamically import NodeMsalAuthenticationProvider only when needed
            const { NodeMsalAuthenticationProvider } = await import('./Authentication/NodeMsalAuthenticationProvider.js');
            authenticationProvider = new NodeMsalAuthenticationProvider();
        }
        const httpClient = new CliHttpClient(authenticationProvider);
        // The CLI logger might need to use httpClient and environment info during its initialization
        // So we create it after the httpClient and authenticationProvider are ready
        logger = await CliLogger.create(cliSettings, httpClient);
        setCliLogger(logger);
        const argumentProvider = new ArgumentProvider(httpClient, logger, authenticationProvider);
        argumentProvider.handleGlobalHelpOrFlagsAndExit();
        const verb = argumentProvider.getVerb();
        await executeVerb({ verb, argumentProvider });
    }
    catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        console.error(message);
        exitCode = err instanceof CliError ? err.exitCode : 1;
    }
    finally {
        // Ensure logger flush on exit
        if (logger) {
            await logger.flush();
        }
        process.exit(exitCode);
    }
}
async function executeVerb(config) {
    const { verb, argumentProvider } = config;
    switch (verb) {
        case 'init':
            await initAsync(argumentProvider);
            break;
        case 'list-codeapps':
            await getCodeAppsAsync(argumentProvider);
            break;
        case 'add-data-source':
            await addDataSourceAsync(argumentProvider);
            break;
        case 'list-datasets':
            await listDatasetsAsync(argumentProvider);
            break;
        case 'list-tables':
            await listTablesAsync(argumentProvider);
            break;
        case 'list-sqlStoredProcedures':
            await listSqlStoredProceduresAsync(argumentProvider);
            break;
        case 'delete-data-source':
            await deleteDataSourceAsync(argumentProvider);
            break;
        case 'refresh-data-source':
            await refreshDataSourceAsync(argumentProvider);
            break;
        case 'logout':
            await logoutAsync(argumentProvider);
            break;
        case 'list-environment-variables':
            await listAllEnvironmentVariablesAsync(argumentProvider);
            break;
        case 'list-connection-references':
            await listConnectionReferences(argumentProvider);
            break;
        case 'list-connections':
            await listConnectionsAsync(argumentProvider);
            break;
        case 'list-flows':
            await listFlowsAsync(argumentProvider);
            break;
        case 'add-dataverse-api':
            await addDataverseApiAsync(argumentProvider);
            break;
        case 'add-flow':
            await addFlowAsync(argumentProvider);
            break;
        case 'create-connection':
            await createConnectionVerbAsync(argumentProvider);
            break;
        case 'remove-flow':
            await removeFlowAsync(argumentProvider);
            break;
        case 'find-dataverse-api':
            await findDataverseApiAsync(argumentProvider);
            break;
        case 'push':
            await pushAsync(argumentProvider);
            break;
        case 'run':
            await runAsync(argumentProvider);
            break;
        case 'telemetry':
            await modifyTelemetrySettings(argumentProvider);
            break;
        default:
            unsupportedVerb(verb);
    }
}
// Helper function ensures compile time checking for exhaustive verb handling
function unsupportedVerb(verb) {
    throw new Error(`The verb "${verb}" is not supported.`);
}
//# sourceMappingURL=Cli.js.map