import { spawn } from "child_process";
import fs from "fs";
import path from "path";
import { prisma } from "@repo/db/client";

const LOCAL_BACKUP_DIR = path.resolve(process.cwd(), "backups");

const MIGRATIONS_DIR = path.resolve(__dirname, "../../../../packages/db/prisma/migrations");

async function applyMissingMigrations() {
  let folders: string[];
  try {
    folders = fs.readdirSync(MIGRATIONS_DIR)
      .filter((name) => fs.statSync(path.join(MIGRATIONS_DIR, name)).isDirectory())
      .sort();
  } catch {
    console.warn("Could not read migrations directory, skipping post-import migration.");
    return;
  }

  let applied: Set<string>;
  try {
    const rows = await prisma.$queryRaw<{ migration_name: string }[]>`
      SELECT migration_name FROM "_prisma_migrations" WHERE finished_at IS NOT NULL
    `;
    applied = new Set(rows.map((r: { migration_name: string }) => r.migration_name));
  } catch {
    applied = new Set();
  }

  for (const folder of folders) {
    if (applied.has(folder)) continue;
    const sqlFile = path.join(MIGRATIONS_DIR, folder, "migration.sql");
    if (!fs.existsSync(sqlFile)) continue;
    const sql = fs.readFileSync(sqlFile, "utf8");
    try {
      await prisma.$executeRawUnsafe(sql);
      console.log(`Applied migration: ${folder}`);
    } catch (err: any) {
      console.warn(`Migration ${folder} had errors (may already be applied):`, err.message);
    }
  }
}

function getLatestBackupFile(): string | null {
  if (!fs.existsSync(LOCAL_BACKUP_DIR)) return null;

  const files = fs.readdirSync(LOCAL_BACKUP_DIR)
    .filter((f) => f.endsWith(".zip"))
    .map((f) => ({ name: f, mtime: fs.statSync(path.join(LOCAL_BACKUP_DIR, f)).mtimeMs }))
    .sort((a, b) => b.mtime - a.mtime);

  if (files.length === 0) return null;
  return path.join(LOCAL_BACKUP_DIR, files[0].name);
}

export async function importLatestBackup(): Promise<void> {
  const backupFile = getLatestBackupFile();
  if (!backupFile) {
    throw new Error("No backup files found in backups folder");
  }

  console.log(`[auto-import] Importing ${path.basename(backupFile)}...`);

  try {
    await prisma.$executeRawUnsafe(`DROP SCHEMA public CASCADE`);
    await prisma.$executeRawUnsafe(`CREATE SCHEMA public`);
  } catch (err: any) {
    throw new Error(`Failed to reset schema: ${err.message}`);
  }

  return new Promise((resolve, reject) => {
    const psql = spawn(
      "psql",
      [
        "-h", process.env.DB_HOST || "localhost",
        "-U", process.env.DB_USER || "postgres",
        process.env.DB_NAME || "dental_db",
      ],
      { env: { ...process.env, PGPASSWORD: process.env.DB_PASSWORD } }
    );

    let stderr = "";
    psql.stderr.on("data", (d) => (stderr += d.toString()));

    psql.on("error", (err) => {
      reject(new Error(`Failed to start psql: ${err.message}`));
    });

    psql.on("close", async (code) => {
      if (code !== 0) {
        return reject(new Error(`psql restore failed (exit ${code}): ${stderr}`));
      }

      try {
        await prisma.$disconnect();
        await prisma.$connect();
      } catch (_) {}

      try {
        await applyMissingMigrations();
      } catch (err) {
        console.error("applyMissingMigrations failed after auto-import:", err);
      }

      console.log(`[auto-import] Successfully imported ${path.basename(backupFile)}`);
      resolve();
    });

    const unzip = spawn("unzip", ["-p", backupFile, "*.sql"]);
    unzip.stderr.on("data", (d) => console.warn(`[auto-import] unzip: ${d.toString().trim()}`));
    unzip.on("error", (err) => {
      reject(new Error(`Failed to extract backup zip: ${err.message}`));
    });
    unzip.stdout.pipe(psql.stdin);
  });
}