/**
 * Backup Import Command
 * Imports a local file into the backup system as a module backup.
 */

import { existsSync, statSync } from 'node:fs';
import { resolve } from 'node:path';
import { formatSize } from '../../services/backup-metadata';
import { askConfirm, withInterviewSession } from '../../services/bus-interview';
import { celiloIntro, celiloOutro } from '../prompts';
import type { CommandResult } from '../types';

export async function handleBackupImport(
  args: string[],
  flags: Record<string, boolean | string> = {},
): Promise<CommandResult> {
  try {
    celiloIntro('Import Backup');

    const filePath = args[0];
    const moduleId = args[1];

    if (!filePath || !moduleId) {
      return {
        success: false,
        error:
          'File path and module ID are required\n\nUsage: celilo backup import <file-path> <module-id>',
      };
    }

    const resolvedPath = resolve(filePath);

    if (!existsSync(resolvedPath)) {
      return { success: false, error: `File not found: ${resolvedPath}` };
    }

    const fileSize = statSync(resolvedPath).size;
    const name = typeof flags.name === 'string' ? flags.name : undefined;
    const schemaVersion =
      typeof flags['schema-version'] === 'string' ? flags['schema-version'] : undefined;
    const storageId = typeof flags.storage === 'string' ? flags.storage : undefined;

    console.log('\nImport Details:');
    console.log(`  File:           ${resolvedPath}`);
    console.log(`  Size:           ${formatSize(fileSize)}`);
    console.log(`  Module:         ${moduleId}`);
    if (schemaVersion) {
      console.log(`  Schema Version: ${schemaVersion}`);
    }
    if (name) {
      console.log(`  Name:           ${name}`);
    }
    console.log('');

    // Confirm unless --yes
    if (!flags.yes) {
      const confirmed = await withInterviewSession(() =>
        askConfirm({
          scope: `backup-import:${moduleId}`,
          key: 'import',
          message: `Import this file as a backup for ${moduleId}?`,
          defaultValue: true,
        }),
      );

      if (!confirmed) {
        return { success: false, error: 'Cancelled by user' };
      }
    }

    console.log('\n▸ Packaging and encrypting...');

    const { importModuleBackup } = await import('../../services/backup-create');
    const result = await importModuleBackup(resolvedPath, moduleId, {
      storageId,
      schemaVersion,
      name,
    });

    if (!result.success) {
      console.log(`✗ ${result.error}`);
      return { success: false, error: result.error ?? 'Import failed' };
    }

    console.log(`✓ Imported (${formatSize(result.sizeBytes ?? 0)})`);
    console.log(`  → ${result.storagePath}`);
    console.log(`  ID: ${result.backupId}`);

    celiloOutro(
      `Import complete. Restore with: celilo backup restore ${result.backupId?.slice(0, 8)}`,
    );

    return { success: true, message: `Imported backup: ${result.backupId}` };
  } catch (error) {
    return {
      success: false,
      error: `Import failed: ${error instanceof Error ? error.message : String(error)}`,
    };
  }
}