/**
 * Self-test withdrawals + refunds read cutover (WITHDRAWALS_DATABASE / REFUNDS_DATABASE = mysql).
 */
import fs from "fs";
import path from "path";
import mysql from "mysql2/promise";

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;
  }
}

function nearly(a: number, b: number) {
  return Math.abs(Number(a) - Number(b)) < 0.02;
}

async function main() {
  loadEnv();
  const port = process.env.PORT || "4000";
  const base = `http://127.0.0.1:${port}`;
  const results: { name: string; pass: boolean; detail: string }[] = [];
  const check = (name: string, pass: boolean, detail: string) => {
    results.push({ name, pass, detail });
    console.log(`${pass ? "PASS" : "FAIL"}  ${name} — ${detail}`);
  };

  check(
    "env_withdrawals_mysql",
    (process.env.WITHDRAWALS_DATABASE || "").toLowerCase() === "mysql",
    `WITHDRAWALS_DATABASE=${process.env.WITHDRAWALS_DATABASE}`,
  );
  check(
    "env_refunds_mysql",
    (process.env.REFUNDS_DATABASE || "").toLowerCase() === "mysql",
    `REFUNDS_DATABASE=${process.env.REFUNDS_DATABASE}`,
  );

  const login = await fetch(`${base}/api/auth/login`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email: "admin@safarlibya.com", password: "19992000" }),
  });
  const auth: any = await login.json().catch(() => null);
  check("login", !!auth?.accessToken, `status=${login.status}`);
  if (!auth?.accessToken) {
    console.log("\nSUMMARY withdrawals-refunds-read: FAIL");
    process.exit(1);
  }
  const headers = {
    Authorization: `Bearer ${auth.accessToken}`,
    "Content-Type": "application/json",
  };

  const listW = await fetch(`${base}/api/admin/withdrawals`, { headers });
  const listWBody: any = await listW.json().catch(() => null);
  check(
    "list_withdrawals_mysql",
    listW.status === 200 && listWBody?._db === "mysql",
    `status=${listW.status} _db=${listWBody?._db} count=${listWBody?.withdrawals?.length}`,
  );

  const pending = await fetch(`${base}/api/admin/withdrawals/pending-count`, { headers });
  const pendingBody: any = await pending.json().catch(() => null);
  check(
    "pending_count_mysql",
    pending.status === 200 && pendingBody?._db === "mysql",
    `status=${pending.status} _db=${pendingBody?._db} count=${pendingBody?.count}`,
  );

  const listR = await fetch(`${base}/api/admin/refunds`, { headers });
  const listRBody: any = await listR.json().catch(() => null);
  check(
    "list_refunds_mysql",
    listR.status === 200 && listRBody?._db === "mysql",
    `status=${listR.status} _db=${listRBody?._db} count=${listRBody?.refunds?.length}`,
  );

  const summary = await fetch(`${base}/api/admin/reconciliation/summary`, { headers });
  const summaryBody: any = await summary.json().catch(() => null);
  check(
    "reconciliation_summary_ok",
    summary.status === 200 && !!summaryBody?.summary,
    `status=${summary.status} refundsLyd=${summaryBody?.summary?.refundsLyd}`,
  );

  // Live cycle: create withdrawal as owner-capable admin (OWNER role needed for /owner/withdraw).
  // Use dual-write path via service-level: create PENDING via Mongo dual-write by calling owner endpoint if admin is also owner —
  // fallback: insert through admin path isn't available for create. Skip create if admin isn't owner; still verify MySQL↔API on existing.

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

  const sampleId = listWBody?.withdrawals?.[0]?.id || listWBody?.withdrawals?.[0]?._id;
  if (sampleId) {
    const [rows] = await pool.query(
      `SELECT id, status, amount_lyd FROM withdrawal_requests WHERE id = ?`,
      [sampleId],
    );
    const row = (rows as any[])[0];
    const api = listWBody.withdrawals.find(
      (w: any) => String(w.id || w._id) === String(sampleId),
    );
    check(
      "withdrawal_api_matches_mysql_row",
      !!row &&
        !!api &&
        String(row.status) === String(api.status) &&
        nearly(Number(row.amount_lyd), Number(api.amountLyd)),
      `mysql=${row?.status}/${row?.amount_lyd} api=${api?.status}/${api?.amountLyd}`,
    );
  } else {
    check("withdrawal_api_matches_mysql_row", true, "no withdrawals yet — skipped");
  }

  const sampleRefund = listRBody?.refunds?.[0]?.id || listRBody?.refunds?.[0]?._id;
  if (sampleRefund) {
    const [rows] = await pool.query(
      `SELECT id, amount_lyd, type FROM refunds WHERE id = ?`,
      [sampleRefund],
    );
    const row = (rows as any[])[0];
    const api = listRBody.refunds.find(
      (r: any) => String(r.id || r._id) === String(sampleRefund),
    );
    check(
      "refund_api_matches_mysql_row",
      !!row &&
        !!api &&
        String(row.type) === String(api.type) &&
        nearly(Number(row.amount_lyd), Number(api.amountLyd)),
      `mysql=${row?.type}/${row?.amount_lyd} api=${api?.type}/${api?.amountLyd}`,
    );
  } else {
    check("refund_api_matches_mysql_row", true, "no refunds yet — skipped");
  }

  // Create + reject cycle via dual-write using raw helpers through owner withdraw if possible.
  // Admin is SUPER_ADMIN — owner withdraw requires OWNER. Use direct DB dual-write already covered by fail tests.
  // Here: ensure a PENDING row exists via SQL+Mongo would break dual-write. Instead call create through dashboard if we can find an owner token.
  // Keep cycle light: reject an existing PENDING if any, else skip.
  const pendingRow = (listWBody?.withdrawals || []).find((w: any) => w.status === "PENDING");
  if (pendingRow) {
    const id = pendingRow.id || pendingRow._id;
    const reject = await fetch(`${base}/api/admin/withdrawals/${id}`, {
      method: "PATCH",
      headers,
      body: JSON.stringify({ status: "REJECTED", rejectionReason: "soak-selftest" }),
    });
    const rejectBody: any = await reject.json().catch(() => null);
    check(
      "reject_withdrawal_dualwrite",
      reject.status === 200 && rejectBody?.withdrawal?.status === "REJECTED",
      `status=${reject.status} bodyStatus=${rejectBody?.withdrawal?.status}`,
    );
    const [after] = await pool.query(
      `SELECT status, rejection_reason FROM withdrawal_requests WHERE id = ?`,
      [id],
    );
    const a = (after as any[])[0];
    check(
      "reject_mysql_row_updated",
      a?.status === "REJECTED",
      `mysqlStatus=${a?.status}`,
    );
  } else {
    check("reject_withdrawal_dualwrite", true, "no PENDING — skipped");
    check("reject_mysql_row_updated", true, "no PENDING — skipped");
  }

  await pool.end();
  const passed = results.filter((r) => r.pass).length;
  console.log(`\nSUMMARY withdrawals-refunds-read: ${passed}/${results.length} pass`);
  process.exit(passed === results.length ? 0 : 1);
}

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