#!/usr/bin/env bun
/**
 * Interactive migration runner — safely run Payload migrations against any
 * environment database (dev / stg / prd) from your local machine.
 *
 * Usage:
 *   bun run migrate              # interactive menu
 *   bun run migrate dev          # skip menu, target dev
 *   bun run migrate stg          # skip menu, target staging
 *   bun run migrate prd          # skip menu, target production
 *   bun run migrate --status     # show migration status only (no changes)
 *   bun run migrate prd --status # status for a specific env
 *   bun run migrate --fresh      # drop + recreate (dev only!)
 *
 * Environment files:
 *   .env      — dev (DATABASE_URI for local PostgreSQL)
 *   .env.stg  — staging (DATABASE_URI for staging PostgreSQL)
 *   .env.prd  — production (DATABASE_URI for production PostgreSQL)
 *
 * These files are gitignored. Copy the DATABASE_URI from Coolify and paste
 * into the appropriate file. Template:
 *   DATABASE_URI=postgres://user:password@host:5432/dbname
 */
import { spawn } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";
import * as path from "node:path";

// ── Config ──────────────────────────────────────────────────────────────

type EnvName = "dev" | "stg" | "prd";

interface EnvConfig {
  label: string;
  file: string;
  color: string;
}

const ENVS: Record<EnvName, EnvConfig> = {
  dev: {
    label: "Development",
    file: ".env",
    color: "\x1b[36m",
  },
  stg: {
    label: "Staging",
    file: ".env.stg",
    color: "\x1b[33m",
  },
  prd: {
    label: "Production",
    file: ".env.prd",
    color: "\x1b[31m",
  },
};

const ENV_ORDER: EnvName[] = ["dev", "stg", "prd"];

// ── ANSI helpers ────────────────────────────────────────────────────────

const RESET = "\x1b[0m";
const BOLD = "\x1b[1m";
const DIM = "\x1b[2m";
const RED = "\x1b[31m";
const GREEN = "\x1b[32m";
const YELLOW = "\x1b[33m";

function log(msg: string) {
  console.log(msg);
}

// ── stdin abstraction (handles both TTY and piped) ─────────────────────

const inputLines: string[] = [];
let inputReady: Promise<void>;

function initInput(): Promise<void> {
  if (!process.stdin.isTTY) {
    // Piped input: buffer everything up front so readline never closes early
    inputReady = new Promise((resolve) => {
      let buf = "";
      process.stdin.setEncoding("utf-8");
      process.stdin.on("data", (chunk: string) => {
        buf += chunk;
      });
      process.stdin.on("end", () => {
        for (const line of buf.split("\n")) {
          const trimmed = line.trim();
          if (trimmed) inputLines.push(trimmed);
        }
        resolve();
      });
    });
    return inputReady;
  }
  inputReady = Promise.resolve();
  return inputReady;
}

async function ask(question: string): Promise<string> {
  if (!process.stdin.isTTY) {
    // Consume from buffer
    if (inputLines.length === 0) return "";
    const line = inputLines.shift()!;
    process.stdout.write(`${question}${line}\n`);
    return line;
  }
  // Interactive: use readline for proper prompt
  const { createInterface } = await import("node:readline");
  return new Promise((resolve) => {
    const rl = createInterface({
      input: process.stdin,
      output: process.stdout,
    });
    rl.question(question, (answer) => {
      rl.close();
      resolve(answer.trim());
    });
  });
}

// ── Helpers ─────────────────────────────────────────────────────────────

function redactUri(uri: string): string {
  return uri.replace(/(\/\/[^:]+:)[^@]+(@)/, "$1****$2");
}

function parseEnvFile(filePath: string): Record<string, string> {
  const raw = readFileSync(filePath, "utf-8");
  const vars: Record<string, string> = {};
  for (const line of raw.split("\n")) {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith("#")) continue;
    const eqIdx = trimmed.indexOf("=");
    if (eqIdx === -1) continue;
    const key = trimmed.slice(0, eqIdx).trim();
    const val = trimmed.slice(eqIdx + 1).trim();
    vars[key] = val.replace(/^["']|["']$/g, "");
  }
  return vars;
}

function loadDatabaseUri(envName: EnvName): string | null {
  const config = ENVS[envName];
  const filePath = path.resolve(process.cwd(), config.file);
  if (!existsSync(filePath)) return null;
  const vars = parseEnvFile(filePath);
  return vars.DATABASE_URI ?? null;
}

function run(
  cmd: string,
  args: string[],
  envOverrides: Record<string, string>,
  stdinData?: string,
): Promise<{ code: number; stdout: string; stderr: string }> {
  return new Promise((resolve) => {
    const child = spawn(cmd, args, {
      env: { ...process.env, ...envOverrides },
      stdio: [stdinData != null ? "pipe" : "ignore", "pipe", "pipe"],
    });
    if (stdinData != null && child.stdin) {
      child.stdin.write(stdinData);
      child.stdin.end();
    }
    let stdout = "";
    let stderr = "";
    child.stdout?.on("data", (d: Buffer) => {
      const s = d.toString();
      stdout += s;
      process.stdout.write(s);
    });
    child.stderr?.on("data", (d: Buffer) => {
      const s = d.toString();
      stderr += s;
      process.stderr.write(s);
    });
    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
  });
}

// ── Menu ────────────────────────────────────────────────────────────────

async function pickEnv(forced?: string): Promise<{ env: EnvName; uri: string }> {
  if (forced && forced in ENVS) {
    const uri = loadDatabaseUri(forced as EnvName);
    if (!uri) {
      log(`${RED}Cannot find DATABASE_URI in ${ENVS[forced as EnvName].file}${RESET}`);
      log(`Create the file with: DATABASE_URI=postgres://user:pass@host:5432/db`);
      process.exit(1);
    }
    return { env: forced as EnvName, uri };
  }

  log(`\n${BOLD}⚡ Polaris Task Force: Migration Runner${RESET}\n`);
  log("Target environment:\n");

  for (let i = 0; i < ENV_ORDER.length; i++) {
    const key = ENV_ORDER[i];
    const cfg = ENVS[key];
    const exists = loadDatabaseUri(key) !== null;
    const status = exists ? `${GREEN}●${RESET}` : `${DIM}○ missing${RESET}`;
    log(
      `  ${BOLD}${i + 1}${RESET}) ${cfg.color}${cfg.label}${RESET}  ${DIM}(${cfg.file})${RESET}  ${status}`,
    );
  }

  log("");
  const answer = (await ask(`  Select (1-${ENV_ORDER.length}): `)).trim();
  const idx = parseInt(answer, 10) - 1;
  if (isNaN(idx) || idx < 0 || idx >= ENV_ORDER.length) {
    log(`${RED}Invalid selection.${RESET}`);
    process.exit(1);
  }

  const env = ENV_ORDER[idx];
  const uri = loadDatabaseUri(env);
  if (!uri) {
    log(`\n${RED}DATABASE_URI not found in ${ENVS[env].file}${RESET}`);
    log(`Create the file with: ${BOLD}DATABASE_URI=postgres://user:pass@host:5432/db${RESET}`);
    process.exit(1);
  }

  return { env, uri };
}

// ── Main ────────────────────────────────────────────────────────────────

async function main() {
  await initInput();

  const args = process.argv.slice(2);
  const statusOnly = args.includes("--status") || args.includes("-s");
  const freshOnly = args.includes("--fresh");
  const positionalArgs = args.filter((a) => !a.startsWith("-"));

  const forced = positionalArgs[0];
  const { env, uri } = await pickEnv(forced);
  const cfg = ENVS[env];
  const redacted = redactUri(uri);

  // Header
  log(`\n${cfg.color}${BOLD}━━━ ${cfg.label.toUpperCase()} ━━━${RESET}`);
  log(`${DIM}  ${redacted}${RESET}\n`);

  if (statusOnly) {
    log(`${DIM}Migration status:${RESET}\n`);
    await run("bun", ["run", "payload", "migrate:status"], {
      DATABASE_URI: uri,
    });
    return;
  }

  if (freshOnly) {
    if (env !== "dev") {
      log(`${RED}${BOLD}--fresh is only allowed for dev.${RESET}`);
      log(`${DIM}For staging/production, use migrate (up only) or migrate:fresh manually.${RESET}`);
      process.exit(1);
    }
    const confirm = await ask(
      `${YELLOW}This will DROP and recreate all tables on ${cfg.label}. Continue? (y/N): ${RESET}`,
    );
    if (confirm.toLowerCase() !== "y") {
      log("Aborted.");
      return;
    }
    log("");
    await run("bun", ["run", "payload", "migrate:fresh"], {
      DATABASE_URI: uri,
    });
    log(`\n${GREEN}${BOLD}✓ Fresh migration complete.${RESET}`);
    return;
  }

  // Show current status
  log(`${DIM}Migration status:${RESET}\n`);
  const statusResult = await run("bun", ["run", "payload", "migrate:status"], {
    DATABASE_URI: uri,
  });

  // Check for pending migrations
  const hasPending = statusResult.stdout.includes("│ No  │");
  if (!hasPending && !statusResult.stderr) {
    log(`\n${GREEN}All migrations applied. Nothing to do.${RESET}`);
    return;
  }

  // Confirm
  log("");
  if (env === "prd") {
    log(`${RED}${BOLD}  ╔══════════════════════════════════════════╗${RESET}`);
    log(`${RED}${BOLD}  ║   YOU ARE ABOUT TO MIGRATE PRODUCTION    ║${RESET}`);
    log(`${RED}${BOLD}  ╚══════════════════════════════════════════╝${RESET}\n`);
    const confirm = await ask(`${RED}Type "migrate" to confirm: ${RESET}`);
    if (confirm.trim() !== "migrate") {
      log("Aborted.");
      return;
    }
  } else {
    const confirm = await ask(`${YELLOW}Run migrations on ${cfg.label}? (y/N): ${RESET}`);
    if (confirm.toLowerCase() !== "y") {
      log("Aborted.");
      return;
    }
  }

  // Run migration — pipe "y\n" so Payload's dev-mode prompt (triggered by
  // push:true's batch=-1 record) is auto-accepted instead of blocking on
  // non-interactive stdin.
  log(`\n${BOLD}Running migrations...${RESET}\n`);
  const result = await run("bun", ["run", "payload", "migrate"], { DATABASE_URI: uri }, "y\n");

  if (result.code !== 0) {
    log(`\n${RED}${BOLD}✗ Migration failed (exit ${result.code})${RESET}`);
    process.exit(result.code);
  }

  log(`\n${GREEN}${BOLD}✓ Migrations applied successfully.${RESET}`);
}

main().catch((err) => {
  console.error(`${RED}Fatal error:${RESET}`, err);
  process.exit(1);
});