/**
 * Deployment Rollback System
 *
 * Provides comprehensive rollback capabilities to restore the system
 * to a previous state in case of deployment failures.
 */

import { execSync } from "node:child_process";
import { existsSync, readFileSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { migrationLogger } from "./migration-logger";

interface RollbackOptions {
  backupPath?: string;
  rollbackDatabase: boolean;
  rollbackCode: boolean;
  rollbackEnvironment: boolean;
  skipConfirmation: boolean;
  dryRun: boolean;
}

interface RollbackStep {
  name: string;
  description: string;
  critical: boolean;
  execute: () => Promise<void>;
  verify?: () => Promise<boolean>;
}

interface RollbackResult {
  success: boolean;
  completedSteps: string[];
  failedStep?: string;
  totalDuration: number;
  error?: Error;
}

export class RollbackManager {
  private readonly defaultOptions: RollbackOptions = {
    rollbackDatabase: true,
    rollbackCode: true,
    rollbackEnvironment: true,
    skipConfirmation: false,
    dryRun: false,
  };

  private options: RollbackOptions;
  private steps: RollbackStep[] = [];
  private completedSteps: string[] = [];

  constructor(options?: Partial<RollbackOptions>) {
    this.options = { ...this.defaultOptions, ...options };
    this.setupRollbackSteps();
  }

  /**
   * Execute complete rollback process
   */
  async rollback(): Promise<RollbackResult> {
    const startTime = Date.now();

    try {
      migrationLogger.startPhase("ROLLBACK", "Starting deployment rollback");

      // Confirmation check
      if (!this.options.skipConfirmation && !this.options.dryRun) {
        await this.confirmRollback();
      }

      // Execute rollback steps
      for (const step of this.steps) {
        await this.executeRollbackStep(step);
        this.completedSteps.push(step.name);
      }

      const totalDuration = Date.now() - startTime;

      migrationLogger.completePhase("ROLLBACK");
      migrationLogger.info("ROLLBACK", "Rollback completed successfully", {
        totalDuration,
        steps: this.completedSteps.length,
      });

      return {
        success: true,
        completedSteps: this.completedSteps,
        totalDuration,
      };
    } catch (error) {
      const totalDuration = Date.now() - startTime;

      migrationLogger.error("ROLLBACK", "Rollback failed", error as Error);

      return {
        success: false,
        completedSteps: this.completedSteps,
        totalDuration,
        error: error as Error,
      };
    }
  }

  /**
   * Create rollback snapshot before deployment
   */
  async createRollbackSnapshot(): Promise<string> {
    migrationLogger.startStep(
      "ROLLBACK_SNAPSHOT",
      "Creating rollback snapshot"
    );

    try {
      const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
      const snapshotDir = join(process.cwd(), "rollback-snapshots", timestamp);

      const fs = await import("node:fs/promises");
      await fs.mkdir(snapshotDir, { recursive: true });

      // Save environment snapshot
      await this.saveEnvironmentSnapshot(snapshotDir);

      // Save package.json and lock file snapshot
      await this.savePackageSnapshot(snapshotDir);

      // Save git commit information
      await this.saveGitSnapshot(snapshotDir);

      // Save deployment state
      await this.saveDeploymentState(snapshotDir);

      migrationLogger.completeStep("ROLLBACK_SNAPSHOT");
      migrationLogger.info("ROLLBACK_SNAPSHOT", "Rollback snapshot created", {
        snapshotDir,
      });

      return snapshotDir;
    } catch (error) {
      migrationLogger.failStep("ROLLBACK_SNAPSHOT", error as Error);
      throw error;
    }
  }

  private setupRollbackSteps(): void {
    this.steps = [
      {
        name: "Pre-Rollback Validation",
        description: "Validate rollback prerequisites",
        critical: true,
        execute: async () => {
          await this.validateRollbackPrerequisites();
        },
      },

      {
        name: "Stop Services",
        description: "Stop application services safely",
        critical: true,
        execute: async () => {
          await this.stopServices();
        },
      },

      {
        name: "Database Rollback",
        description: "Restore database to previous state",
        critical: true,
        execute: async () => {
          if (this.options.rollbackDatabase) {
            await this.rollbackDatabase();
          } else {
            migrationLogger.info("DB_ROLLBACK", "Database rollback skipped");
          }
        },
        verify: async () => {
          return await this.verifyDatabaseRollback();
        },
      },

      {
        name: "Code Rollback",
        description: "Restore application code to previous version",
        critical: true,
        execute: async () => {
          if (this.options.rollbackCode) {
            await this.rollbackCode();
          } else {
            migrationLogger.info("CODE_ROLLBACK", "Code rollback skipped");
          }
        },
      },

      {
        name: "Environment Rollback",
        description: "Restore environment configuration",
        critical: false,
        execute: async () => {
          if (this.options.rollbackEnvironment) {
            await this.rollbackEnvironment();
          } else {
            migrationLogger.info(
              "ENV_ROLLBACK",
              "Environment rollback skipped"
            );
          }
        },
      },

      {
        name: "Dependencies Restoration",
        description: "Restore previous dependencies",
        critical: true,
        execute: async () => {
          await this.restoreDependencies();
        },
      },

      {
        name: "Restart Services",
        description: "Restart services with previous configuration",
        critical: true,
        execute: async () => {
          await this.restartServices();
        },
      },

      {
        name: "Verify Rollback",
        description: "Verify system is working correctly",
        critical: true,
        execute: async () => {
          await this.verifyRollback();
        },
      },
    ];
  }

  private async executeRollbackStep(step: RollbackStep): Promise<void> {
    try {
      migrationLogger.startStep(
        step.name.replace(/\s+/g, "_").toUpperCase(),
        step.description
      );

      if (this.options.dryRun) {
        migrationLogger.info("DRY_RUN", `Would execute rollback: ${step.name}`);
        await new Promise((resolve) => setTimeout(resolve, 100));
      } else {
        await step.execute();
      }

      // Run verification if provided
      if (step.verify && !this.options.dryRun) {
        const verified = await step.verify();
        if (!verified) {
          throw new Error(
            `Verification failed for rollback step: ${step.name}`
          );
        }
      }

      migrationLogger.completeStep(
        step.name.replace(/\s+/g, "_").toUpperCase()
      );
    } catch (error) {
      migrationLogger.failStep(
        step.name.replace(/\s+/g, "_").toUpperCase(),
        error as Error
      );

      if (step.critical) {
        throw error;
      } else {
        migrationLogger.warn(
          "ROLLBACK_STEP",
          `Non-critical rollback step failed: ${step.name}`,
          {
            error: (error as Error).message,
          }
        );
      }
    }
  }

  private async confirmRollback(): Promise<void> {
    console.log("\n⚠️  ROLLBACK CONFIRMATION REQUIRED ⚠️");
    console.log("This will restore the system to a previous state.");
    console.log("The following actions will be performed:");

    if (this.options.rollbackDatabase) {
      console.log("  - Restore database from backup");
    }
    if (this.options.rollbackCode) {
      console.log("  - Restore application code to previous version");
    }
    if (this.options.rollbackEnvironment) {
      console.log("  - Restore environment configuration");
    }

    console.log("\nThis operation cannot be easily undone.");

    // In a real implementation, you would prompt for user input
    // For automation purposes, we'll check for a confirmation flag
    if (!process.env.ROLLBACK_CONFIRMED) {
      throw new Error(
        "Rollback not confirmed. Set ROLLBACK_CONFIRMED=true to proceed."
      );
    }
  }

  private async validateRollbackPrerequisites(): Promise<void> {
    migrationLogger.info(
      "ROLLBACK_VALIDATION",
      "Validating rollback prerequisites"
    );

    // Check if backup exists
    if (this.options.rollbackDatabase && this.options.backupPath) {
      if (!existsSync(this.options.backupPath)) {
        throw new Error(`Backup file not found: ${this.options.backupPath}`);
      }
    }

    // Check if pg_restore is available for database rollback
    if (this.options.rollbackDatabase) {
      try {
        execSync("pg_restore --version", { stdio: "ignore" });
      } catch (error) {
        throw new Error(
          "pg_restore not found - database rollback not possible"
        );
      }
    }

    // Check git status for code rollback
    if (this.options.rollbackCode) {
      try {
        execSync("git status", { stdio: "ignore" });
      } catch (error) {
        throw new Error("Git not available - code rollback not possible");
      }
    }

    migrationLogger.info(
      "ROLLBACK_VALIDATION",
      "Prerequisites validated successfully"
    );
  }

  private async stopServices(): Promise<void> {
    migrationLogger.info("SERVICE_STOP", "Stopping application services");

    // In a real deployment, this would stop the actual services
    // For this implementation, we'll simulate service stopping
    await new Promise((resolve) => setTimeout(resolve, 1000));

    migrationLogger.info("SERVICE_STOP", "Services stopped successfully");
  }

  private async rollbackDatabase(): Promise<void> {
    if (!this.options.backupPath) {
      migrationLogger.warn(
        "DB_ROLLBACK",
        "No backup path specified, skipping database rollback"
      );
      return;
    }

    migrationLogger.info(
      "DB_ROLLBACK",
      `Restoring database from backup: ${this.options.backupPath}`
    );

    try {
      // Parse database URL
      const dbUrl = process.env.DATABASE_URL;
      if (!dbUrl) {
        throw new Error("DATABASE_URL not found");
      }

      const parsed = new URL(dbUrl);

      // Drop existing connections
      migrationLogger.info(
        "DB_ROLLBACK",
        "Terminating existing database connections"
      );

      // Restore from backup
      const restoreCommand = [
        "pg_restore",
        "-h",
        parsed.hostname,
        "-p",
        parsed.port || "5432",
        "-U",
        parsed.username,
        "-d",
        parsed.pathname.slice(1),
        "--clean",
        "--if-exists",
        "--verbose",
        this.options.backupPath,
      ].join(" ");

      migrationLogger.debug("DB_ROLLBACK", `Executing: ${restoreCommand}`);

      execSync(restoreCommand, {
        env: {
          ...process.env,
          PGPASSWORD: parsed.password,
        },
        stdio: "pipe",
      });

      migrationLogger.info(
        "DB_ROLLBACK",
        "Database rollback completed successfully"
      );
    } catch (error) {
      throw new Error(`Database rollback failed: ${(error as Error).message}`);
    }
  }

  private async verifyDatabaseRollback(): Promise<boolean> {
    try {
      migrationLogger.info("DB_VERIFY", "Verifying database rollback");

      // Test database connection
      const { PrismaClient } = await import("@prisma/client");
      const prisma = new PrismaClient();

      try {
        await prisma.$queryRaw`SELECT 1`;
        await prisma.$disconnect();

        migrationLogger.info("DB_VERIFY", "Database verification successful");
        return true;
      } catch (error) {
        await prisma.$disconnect();
        migrationLogger.error(
          "DB_VERIFY",
          "Database verification failed",
          error as Error
        );
        return false;
      }
    } catch (error) {
      migrationLogger.error(
        "DB_VERIFY",
        "Database verification error",
        error as Error
      );
      return false;
    }
  }

  private async rollbackCode(): Promise<void> {
    migrationLogger.info("CODE_ROLLBACK", "Rolling back application code");

    try {
      // Get the previous commit (this is a simplified approach)
      const previousCommit = execSync("git rev-parse HEAD~1", {
        encoding: "utf8",
      }).trim();

      migrationLogger.info(
        "CODE_ROLLBACK",
        `Rolling back to commit: ${previousCommit}`
      );

      // Reset to previous commit
      execSync(`git reset --hard ${previousCommit}`, { stdio: "pipe" });

      migrationLogger.info(
        "CODE_ROLLBACK",
        "Code rollback completed successfully"
      );
    } catch (error) {
      throw new Error(`Code rollback failed: ${(error as Error).message}`);
    }
  }

  private async rollbackEnvironment(): Promise<void> {
    migrationLogger.info(
      "ENV_ROLLBACK",
      "Rolling back environment configuration"
    );

    try {
      // Look for environment backup
      const backupFiles = [
        ".env.local.backup",
        ".env.backup",
        ".env.production.backup",
      ];

      let restored = false;

      for (const backupFile of backupFiles) {
        const backupPath = join(process.cwd(), backupFile);
        const targetPath = backupPath.replace(".backup", "");

        if (existsSync(backupPath)) {
          const backupContent = readFileSync(backupPath, "utf8");
          writeFileSync(targetPath, backupContent);

          migrationLogger.info(
            "ENV_ROLLBACK",
            `Restored ${targetPath} from ${backupFile}`
          );
          restored = true;
        }
      }

      if (!restored) {
        migrationLogger.warn(
          "ENV_ROLLBACK",
          "No environment backup found to restore"
        );
      } else {
        migrationLogger.info(
          "ENV_ROLLBACK",
          "Environment rollback completed successfully"
        );
      }
    } catch (error) {
      throw new Error(
        `Environment rollback failed: ${(error as Error).message}`
      );
    }
  }

  private async restoreDependencies(): Promise<void> {
    migrationLogger.info("DEPS_RESTORE", "Restoring dependencies");

    try {
      // Check if package-lock.json backup exists
      const packageLockBackup = join(process.cwd(), "package-lock.json.backup");
      const packageLock = join(process.cwd(), "package-lock.json");

      if (existsSync(packageLockBackup)) {
        const backupContent = readFileSync(packageLockBackup, "utf8");
        writeFileSync(packageLock, backupContent);
        migrationLogger.info(
          "DEPS_RESTORE",
          "Restored package-lock.json from backup"
        );
      }

      // Reinstall dependencies
      execSync("npm ci", { stdio: "pipe" });

      migrationLogger.info(
        "DEPS_RESTORE",
        "Dependencies restored successfully"
      );
    } catch (error) {
      throw new Error(
        `Dependencies restoration failed: ${(error as Error).message}`
      );
    }
  }

  private async restartServices(): Promise<void> {
    migrationLogger.info(
      "SERVICE_RESTART",
      "Restarting services after rollback"
    );

    // In a real deployment, this would restart the actual services
    await new Promise((resolve) => setTimeout(resolve, 2000));

    migrationLogger.info("SERVICE_RESTART", "Services restarted successfully");
  }

  private async verifyRollback(): Promise<void> {
    migrationLogger.info("ROLLBACK_VERIFY", "Verifying rollback success");

    try {
      // Test database connection
      const { PrismaClient } = await import("@prisma/client");
      const prisma = new PrismaClient();

      await prisma.$queryRaw`SELECT 1`;
      await prisma.$disconnect();

      // Test basic application functionality
      // This would typically involve checking key endpoints or services

      migrationLogger.info(
        "ROLLBACK_VERIFY",
        "Rollback verification successful"
      );
    } catch (error) {
      throw new Error(
        `Rollback verification failed: ${(error as Error).message}`
      );
    }
  }

  private async saveEnvironmentSnapshot(snapshotDir: string): Promise<void> {
    const fs = await import("node:fs/promises");

    const envFiles = [".env.local", ".env.production", ".env"];

    for (const envFile of envFiles) {
      const envPath = join(process.cwd(), envFile);
      if (existsSync(envPath)) {
        const content = await fs.readFile(envPath, "utf8");
        await fs.writeFile(join(snapshotDir, envFile), content);
      }
    }
  }

  private async savePackageSnapshot(snapshotDir: string): Promise<void> {
    const fs = await import("node:fs/promises");

    const packageFiles = [
      "package.json",
      "package-lock.json",
      "pnpm-lock.yaml",
    ];

    for (const packageFile of packageFiles) {
      const packagePath = join(process.cwd(), packageFile);
      if (existsSync(packagePath)) {
        const content = await fs.readFile(packagePath, "utf8");
        await fs.writeFile(join(snapshotDir, packageFile), content);
      }
    }
  }

  private async saveGitSnapshot(snapshotDir: string): Promise<void> {
    try {
      const gitInfo = {
        commit: execSync("git rev-parse HEAD", { encoding: "utf8" }).trim(),
        branch: execSync("git rev-parse --abbrev-ref HEAD", {
          encoding: "utf8",
        }).trim(),
        status: execSync("git status --porcelain", { encoding: "utf8" }).trim(),
        remotes: execSync("git remote -v", { encoding: "utf8" }).trim(),
      };

      const fs = await import("node:fs/promises");
      await fs.writeFile(
        join(snapshotDir, "git-info.json"),
        JSON.stringify(gitInfo, null, 2)
      );
    } catch (error) {
      migrationLogger.warn("GIT_SNAPSHOT", "Failed to save git snapshot", {
        error: (error as Error).message,
      });
    }
  }

  private async saveDeploymentState(snapshotDir: string): Promise<void> {
    const deploymentState = {
      timestamp: new Date().toISOString(),
      nodeVersion: process.version,
      platform: process.platform,
      architecture: process.arch,
      environment: process.env.NODE_ENV,
      rollbackOptions: this.options,
    };

    const fs = await import("node:fs/promises");
    await fs.writeFile(
      join(snapshotDir, "deployment-state.json"),
      JSON.stringify(deploymentState, null, 2)
    );
  }
}

// CLI interface
if (import.meta.url === `file://${process.argv[1]}`) {
  const args = process.argv.slice(2);

  const options: Partial<RollbackOptions> = {};

  // Parse command line arguments
  args.forEach((arg, index) => {
    switch (arg) {
      case "--dry-run":
        options.dryRun = true;
        break;
      case "--skip-confirmation":
        options.skipConfirmation = true;
        break;
      case "--no-database":
        options.rollbackDatabase = false;
        break;
      case "--no-code":
        options.rollbackCode = false;
        break;
      case "--no-environment":
        options.rollbackEnvironment = false;
        break;
      case "--backup":
        options.backupPath = args[index + 1];
        break;
    }
  });

  const command = args[0];

  if (command === "snapshot") {
    const rollbackManager = new RollbackManager();
    rollbackManager
      .createRollbackSnapshot()
      .then((snapshotDir) => {
        console.log("\n=== ROLLBACK SNAPSHOT CREATED ===");
        console.log(`Snapshot Directory: ${snapshotDir}`);
        console.log("\nThe snapshot contains:");
        console.log("  - Environment configuration");
        console.log("  - Package dependencies");
        console.log("  - Git information");
        console.log("  - Deployment state");
        console.log("\nUse this snapshot for rollback if needed.");
        process.exit(0);
      })
      .catch((error) => {
        console.error("Snapshot creation failed:", error);
        process.exit(1);
      });
  } else {
    const rollbackManager = new RollbackManager(options);

    rollbackManager
      .rollback()
      .then((result) => {
        console.log("\n=== ROLLBACK RESULTS ===");
        console.log(`Success: ${result.success ? "✅" : "❌"}`);
        console.log(`Total Duration: ${result.totalDuration}ms`);
        console.log(`Completed Steps: ${result.completedSteps.length}`);

        if (result.failedStep) {
          console.log(`Failed Step: ${result.failedStep}`);
        }

        if (result.error) {
          console.error(`Error: ${result.error.message}`);
        }

        console.log("\nCompleted Steps:");
        result.completedSteps.forEach((step) => console.log(`  ✅ ${step}`));

        if (result.success) {
          console.log("\n🎉 ROLLBACK SUCCESSFUL!");
          console.log("\nNext Steps:");
          console.log("1. Verify system functionality");
          console.log("2. Monitor logs for any issues");
          console.log("3. Investigate root cause of deployment failure");
        } else {
          console.log("\n💥 ROLLBACK FAILED!");
          console.log("\nNext Steps:");
          console.log("1. Check logs for error details");
          console.log("2. Manual intervention may be required");
          console.log("3. Contact system administrators");
        }

        process.exit(result.success ? 0 : 1);
      })
      .catch((error) => {
        console.error("Rollback failed:", error);
        process.exit(1);
      });
  }
}