/**
 * Step-zero safety: is this live production traffic or local/dev?
 */
import fs from "fs";
import path from "path";
import mysql from "mysql2/promise";
import mongoose from "mongoose";

function loadEnv() {
  const t = fs.readFileSync(path.join(process.cwd(), ".env"), "utf8");
  for (const line of t.split(/\r?\n/)) {
    const s = line.trim();
    if (!s || s.startsWith("#")) continue;
    const eq = s.indexOf("=");
    if (eq <= 0) continue;
    const k = s.slice(0, eq).trim();
    let v = s.slice(eq + 1).trim();
    if (
      (v.startsWith('"') && v.endsWith('"')) ||
      (v.startsWith("'") && v.endsWith("'"))
    ) {
      v = v.slice(1, -1);
    }
    process.env[k] = v;
  }
}

const TEAM = new Set(["admin@safarlibya.com"]);

async function main() {
  loadEnv();
  const since = new Date(Date.now() - 48 * 60 * 60 * 1000);
  const mongoUri = process.env.MONGODB_URI || "";
  const mongoHost = mongoUri.includes("@")
    ? mongoUri.replace(/^.*@/, "").replace(/\/.*$/, "")
    : mongoUri.replace(/^mongodb:\/\//, "").replace(/\/.*$/, "");

  const report: Record<string, unknown> = {
    verdictHint: null,
    env: {
      NODE_ENV: process.env.NODE_ENV || "(unset)",
      PORT: process.env.PORT || null,
      FRONTEND_URL: process.env.FRONTEND_URL || null,
      CORS_ORIGIN: process.env.CORS_ORIGIN || null,
      MYSQL_HOST: process.env.MYSQL_HOST || null,
      MONGODB_HOST: mongoHost,
      ACTIVE_DATABASE: process.env.ACTIVE_DATABASE || null,
      AUTH_DATABASE: process.env.AUTH_DATABASE || null,
    },
    since: since.toISOString(),
  };

  const conn = await mysql.createConnection({
    host: process.env.MYSQL_HOST,
    port: Number(process.env.MYSQL_PORT || 3306),
    user: process.env.MYSQL_USER,
    password: process.env.MYSQL_PASSWORD,
    database: process.env.MYSQL_DATABASE,
  });

  const [mysqlUsers] = await conn.query(
    `SELECT email, role, status, created_at, updated_at
     FROM users
     WHERE created_at >= ? OR updated_at >= ?
     ORDER BY GREATEST(IFNULL(updated_at, created_at), created_at) DESC
     LIMIT 40`,
    [since, since],
  );

  const [mysqlNewUsers] = await conn.query(
    `SELECT email, role, created_at FROM users WHERE created_at >= ? ORDER BY created_at DESC LIMIT 20`,
    [since],
  );

  const [mysqlRefresh] = await conn.query(
    `SELECT COUNT(*) AS c FROM refresh_tokens WHERE created_at >= ?`,
    [since],
  );
  const [mysqlOtp] = await conn.query(
    `SELECT COUNT(*) AS c FROM otp_challenges WHERE created_at >= ?`,
    [since],
  );
  const [mysqlBookings] = await conn.query(
    `SELECT COUNT(*) AS c FROM bookings WHERE created_at >= ? OR updated_at >= ?`,
    [since, since],
  );
  const [mysqlContact] = await conn.query(
    `SELECT COUNT(*) AS c FROM contact_messages WHERE created_at >= ?`,
    [since],
  );

  report.mysql = {
    usersTouched48h: (mysqlUsers as any[]).map((u) => ({
      email: u.email,
      role: u.role,
      status: u.status,
      created_at: u.created_at,
      updated_at: u.updated_at,
      isTeamEmail: TEAM.has(String(u.email).toLowerCase()),
    })),
    usersCreated48h: (mysqlNewUsers as any[]).map((u) => ({
      email: u.email,
      role: u.role,
      created_at: u.created_at,
      isTeamEmail: TEAM.has(String(u.email).toLowerCase()),
    })),
    refreshTokensCreated48h: Number((mysqlRefresh as any[])[0]?.c || 0),
    otpChallengesCreated48h: Number((mysqlOtp as any[])[0]?.c || 0),
    bookingsTouched48h: Number((mysqlBookings as any[])[0]?.c || 0),
    contactMessagesCreated48h: Number((mysqlContact as any[])[0]?.c || 0),
  };
  await conn.end();

  await mongoose.connect(process.env.MONGODB_URI!);
  const db = mongoose.connection.db!;
  const sinceFilter = {
    $or: [{ createdAt: { $gte: since } }, { updatedAt: { $gte: since } }],
  };
  const mongoUsers = await db
    .collection("users")
    .find(sinceFilter)
    .project({ email: 1, role: 1, status: 1, createdAt: 1, updatedAt: 1 })
    .sort({ updatedAt: -1 })
    .limit(40)
    .toArray();
  const mongoCreated = await db
    .collection("users")
    .find({ createdAt: { $gte: since } })
    .project({ email: 1, role: 1, createdAt: 1 })
    .sort({ createdAt: -1 })
    .limit(20)
    .toArray();

  report.mongo = {
    usersTouched48h: mongoUsers.map((u: any) => ({
      email: u.email,
      role: u.role,
      status: u.status,
      createdAt: u.createdAt,
      updatedAt: u.updatedAt,
      isTeamEmail: TEAM.has(String(u.email || "").toLowerCase()),
    })),
    usersCreated48h: mongoCreated.map((u: any) => ({
      email: u.email,
      role: u.role,
      createdAt: u.createdAt,
      isTeamEmail: TEAM.has(String(u.email || "").toLowerCase()),
    })),
    refreshTokensCreated48h: await db
      .collection("refreshtokens")
      .countDocuments({ createdAt: { $gte: since } }),
    bookingsTouched48h: await db.collection("bookings").countDocuments(sinceFilter),
    contactMessagesCreated48h: await db
      .collection("contactmessages")
      .countDocuments({ createdAt: { $gte: since } }),
  };

  await mongoose.disconnect();

  const frontendLocal = /localhost|127\.0\.0\.1/i.test(String(process.env.FRONTEND_URL || ""));
  const corsLocal = /localhost|127\.0\.0\.1/i.test(String(process.env.CORS_ORIGIN || ""));
  const dbLocal =
    /localhost|127\.0\.0\.1/i.test(String(process.env.MYSQL_HOST || "")) &&
    /localhost|127\.0\.0\.1/i.test(mongoHost);

  const nonTeamMysql = ((report.mysql as any).usersTouched48h || []).filter(
    (u: any) => !u.isTeamEmail,
  );
  const nonTeamMongo = ((report.mongo as any).usersTouched48h || []).filter(
    (u: any) => !u.isTeamEmail,
  );
  const nonTeamCreated = [
    ...((report.mysql as any).usersCreated48h || []),
    ...((report.mongo as any).usersCreated48h || []),
  ].filter((u: any) => !u.isTeamEmail);

  report.assessment = {
    frontendLooksLocal: frontendLocal,
    corsLooksLocal: corsLocal,
    databasesLookLocal: dbLocal,
    nonTeamUsersTouched48h: {
      mysql: nonTeamMysql.length,
      mongo: nonTeamMongo.length,
      sampleEmails: [...nonTeamMysql, ...nonTeamMongo]
        .slice(0, 10)
        .map((u: any) => u.email),
    },
    nonTeamUsersCreated48h: {
      count: nonTeamCreated.length,
      sampleEmails: nonTeamCreated.slice(0, 10).map((u: any) => u.email),
    },
  };

  const looksDev = frontendLocal && corsLocal && dbLocal;
  const hasExternalTraffic =
    nonTeamCreated.length > 0 ||
    nonTeamMysql.length > 5 ||
    nonTeamMongo.length > 5;

  report.verdict = looksDev && !hasExternalTraffic
    ? "DEV_OR_STAGING_LOCAL"
    : looksDev && hasExternalTraffic
      ? "LOCAL_STACK_BUT_NON_TEAM_ACTIVITY"
      : "POSSIBLE_PRODUCTION_OR_UNKNOWN";

  const out = path.join(process.cwd(), "logs", "step-zero-safety-check.json");
  fs.mkdirSync(path.dirname(out), { recursive: true });
  fs.writeFileSync(out, JSON.stringify(report, null, 2), "utf8");
  console.log(JSON.stringify(report, null, 2));
  console.log("\nWROTE", out);
}

main().catch((e) => {
  console.error(e instanceof Error ? e.message : e);
  process.exit(1);
});