import.ts

import { Command } from '@contentstack/cli-command';
import {
  messageHandler,
  managementSDKClient,
  flags,
  FlagInput,
  ContentstackClient,
  log,
  handleAndLogError,
  configHandler,
  getSessionLogPath,
  CLIProgressManager,
  cliux,
  clearProgressModuleSetting,
  createLogContext,
} from '@contentstack/cli-utilities';

import { Context, ImportConfig } from '../../../types';
import { ModuleImporter } from '../../../import';
import { setupImportConfig } from '../../../utils';

export default class ImportCommand extends Command {
  static description = messageHandler.parse('Import content from a stack');

  static examples: string[] = [
    `csdx cm:stacks:import --stack-api-key <stack_api_key> --data-dir <path/of/export/destination/dir>`,
    `csdx cm:stacks:import --config <path/of/config/dir>`,
    `csdx cm:stacks:import --module <single module name>`,
    `csdx cm:stacks:import --module <single module name> --backup-dir <backup dir>`,
    `csdx cm:stacks:import --alias <management_token_alias>`,
    `csdx cm:stacks:import --alias <management_token_alias> --data-dir <path/of/export/destination/dir>`,
    `csdx cm:stacks:import --alias <management_token_alias> --config <path/of/config/file>`,
    `csdx cm:stacks:import --branch <branch name>  --yes --skip-audit`,
  ];

  static flags: FlagInput = {
    config: flags.string({
      char: 'c',
      description: '[optional] The path of the configuration JSON file containing all the options for a single run.',
    }),
    'stack-api-key': flags.string({
      char: 'k',
      description: 'API Key of the target stack',
    }),
    'data-dir': flags.string({
      char: 'd',
      description: `The path or the location in your file system where the content, you intend to import, is stored. For example, -d "C:\\Users\\Name\\Desktop\\cli\\content". If the export folder has branches involved, then the path should point till the particular branch. For example, “-d "C:\\Users\\Name\\Desktop\\cli\\content\\branch_name"`,
    }),
    alias: flags.string({
      char: 'a',
      description: 'The management token of the destination stack where you will import the content.',
    }),
    module: flags.string({
      required: false,
      description:
        '[optional] Specify the module to import into the target stack. If not specified, the import command will import all the modules into the stack. The available modules are assets, content-types, entries, environments, extensions, marketplace-apps, global-fields, labels, locales, webhooks, workflows, custom-roles, personalize projects, taxonomies, and composable-studio.',
    }),
    'backup-dir': flags.string({
      description: '[optional] Backup directory name when using specific module.',
    }),
    branch: flags.string({
      description:
        "The name of the branch where you want to import your content. If you don't mention the branch name, then by default the content will be imported to the main branch.",
      exclusive: ['branch-alias'],
    }),
    'branch-alias': flags.string({
      description:
        'Specify the branch alias where you want to import your content. If not specified, the content is imported into the main branch by default.',
      exclusive: ['branch'],
    }),
    'import-webhook-status': flags.string({
      description:
        '[default: disable] (optional) This webhook state keeps the same state of webhooks as the source stack. <options: disable|current>',
      options: ['disable', 'current'],
      required: false,
      default: 'disable',
    }),
    yes: flags.boolean({
      char: 'y',
      required: false,
      description: '[optional] Force override all Marketplace prompts.',
    }),
    'replace-existing': flags.boolean({
      required: false,
      description: 'Replaces the existing module in the target stack.',
    }),
    'skip-existing': flags.boolean({
      required: false,
      default: false,
      description: 'Skips the module exists warning messages.',
    }),
    'personalize-project-name': flags.string({
      required: false,
      description: '(optional) Provide a unique name for the Personalize project.',
    }),
    'skip-audit': flags.boolean({
      description: 'Skips the audit fix that occurs during an import operation.',
    }),
    'exclude-global-modules': flags.boolean({
      description: 'Excludes the branch-independent module from the import operation.',
      default: false,
    }),
    'skip-assets-publish': flags.boolean({
      description: 'Skips asset publishing during the import process.',
      default: false,
    }),
    'skip-entries-publish': flags.boolean({
      description: 'Skips entry publishing during the import process',
      default: false,
    }),
    'force-backup': flags.boolean({
      description: 'Forces backup creation even for large datasets that would normally skip backup for memory optimization.',
      default: false,
    }),
    'disable-memory-optimization': flags.boolean({
      description: 'Disables memory optimization features and uses legacy processing (not recommended for large datasets).',
      default: false,
    }),
    'memory-threshold': flags.integer({
      description: 'Memory threshold in MB for triggering garbage collection (default: 768MB for large datasets).',
    }),
    'asset-concurrency': flags.integer({
      description: 'Number of concurrent asset uploads (default: 10).',
    }),
  };

  static usage: string =
    'cm:stacks:import [--config <value>] [--stack-api-key <value>] [--data-dir <value>] [--alias <value>] [--module <value>] [--backup-dir <value>] [--branch <value>] [--import-webhook-status disable|current]';

  async run(): Promise<void> {
    // setup import config
    // initialize the importer
    // start import
    let backupDir: string;
    let importConfig: ImportConfig;
    try {
      const { flags } = await this.parse(ImportCommand);
      importConfig = await setupImportConfig(flags);
      // Prepare the context object
      createLogContext(
        this.context?.info?.command || 'cm:stacks:export',
        importConfig.apiKey,
        importConfig.authenticationMethod
      );
      const context = this.createImportContext(importConfig.apiKey, importConfig.authenticationMethod);
      importConfig.context = { ...context };
      //log.info(`Using Cli Version: ${this.context?.cliVersion}`, importConfig.context);

      // Note setting host to create cma client
      importConfig.host = this.cmaHost;
      importConfig.region = this.region;
      if (this.developerHubUrl) importConfig.developerHubBaseUrl = this.developerHubUrl;
      if (this.personalizeUrl) importConfig.modules.personalize.baseURL[importConfig.region.name] = this.personalizeUrl;
      if (this.composableStudioUrl) importConfig.modules['composable-studio'].apiBaseUrl = this.composableStudioUrl;

      const managementAPIClient: ContentstackClient = await managementSDKClient(importConfig);

      if (flags.branch) {
        CLIProgressManager.initializeGlobalSummary(
          `IMPORT-${flags.branch}`,
          flags.branch,
          `Importing content into "${flags.branch}" branch...`,
        );
      } else {
        CLIProgressManager.initializeGlobalSummary(`IMPORT`, flags.branch, 'Importing content...');
      }

      const moduleImporter = new ModuleImporter(managementAPIClient, importConfig);
      const result = await moduleImporter.start();
      backupDir = importConfig.backupDir;
      //Note: Final summary is now handled by summary manager
      CLIProgressManager.printGlobalSummary();
      this.logSuccessAndBackupMessages(backupDir, importConfig);
      // Clear progress module setting now that import is complete
      clearProgressModuleSetting();
    } catch (error) {
      // Clear progress module setting even on error
      clearProgressModuleSetting();

      handleAndLogError(error);
      this.logAndPrintErrorDetails(error, importConfig);
    }
  }

  private logAndPrintErrorDetails(error: unknown, importConfig: any) {
    cliux.print('\n');
    const sessionLogPath = getSessionLogPath();
    const logMsg = `The log has been stored at '${sessionLogPath}'`;

    const backupDir = importConfig?.backupDir;
    const backupDirMsg = backupDir
      ? `The backup content has been stored at '${backupDir}'`
      : 'No backup directory was created due to early termination';

    log.info(logMsg);
    log.info(backupDirMsg);

    const showConsoleLogs = configHandler.get('log')?.showConsoleLogs;
    if (!showConsoleLogs) {
      cliux.print(`Error: ${error}`, { color: 'red' });
      cliux.print(logMsg, { color: 'blue' });
      cliux.print(backupDirMsg, { color: 'blue' });
    }
  }

  private logSuccessAndBackupMessages(backupDir: string, importConfig: any) {
    cliux.print('\n');
    const sessionLogPath = getSessionLogPath();
    const logMsg = `The log has been stored at '${sessionLogPath}'`;
    const backupDirMsg = `The backup content has been stored at '${backupDir}'`;

    log.success(logMsg, importConfig.context);
    log.info(backupDirMsg, importConfig.context);

    const showConsoleLogs = configHandler.get('log')?.showConsoleLogs;
    if (!showConsoleLogs) {
      cliux.print(logMsg, { color: 'blue' });
      cliux.print(backupDirMsg, { color: 'blue' });
    }
  }

  // Create export context object
  private createImportContext(apiKey: string, authenticationMethod?: string): Context {
    return {
      command: this.context?.info?.command || 'cm:stacks:import',
      module: '',
      userId: configHandler.get('userUid') || '',
      email: configHandler.get('email') || '',
      sessionId: this.context?.sessionId,
      apiKey: apiKey || '',
      orgId: configHandler.get('oauthOrgUid') || '',
      authenticationMethod: authenticationMethod || 'Basic Auth',
    };
  }
}