import { config } from "dotenv";

config({ path: ".env.local" });

async function main() {
  const { db } = await import("@/lib/db");
  const { createExtensionRequest, approveExtensionRequest } = await import(
    "@/lib/extension-requests"
  );
  const { ACTIVATE_STATUSES, ACCOUNT_TYPES, REQUEST_STATUSES } = await import(
    "@/lib/constants"
  );

  const scenarios = [
    {
      label: "TRIAL status + paid tier (BASIC_20)",
      accountType: ACCOUNT_TYPES.BASIC_20,
    },
    {
      label: "TRIAL status + trial tier (STUDENT_TRIAL)",
      accountType: ACCOUNT_TYPES.STUDENT_TRIAL,
    },
  ];

  let failures = 0;

  for (const scenario of scenarios) {
    const stamp = Date.now();
    const testName = `__TEST_TRIAL_EXT_${stamp}__`.slice(0, 50);
    const initialAvailable = new Date(2000, 0, 1);
    let maestroID: number | null = null;

    console.log(`\n=== Scenario: ${scenario.label} ===`);

    try {
      const created = await db.maestro.create({
        data: {
          Name: testName,
          Password: "",
          Email: `${stamp}@test.invalid`.slice(0, 50),
          AccountType: scenario.accountType,
          ActivateStatus: ACTIVATE_STATUSES.TRIAL,
          AvailableActivateDateTime: initialAvailable,
          PlayerCount: 0,
          AcceptClausesDateTime: new Date(),
          AllowEditEnterCode: 0,
        },
        select: { MaestroID: true },
      });
      maestroID = created.MaestroID;
      console.log(`  seeded maestro MaestroID=${maestroID}`);

      const requestResult = await createExtensionRequest(maestroID);
      console.log(
        `  createExtensionRequest → maestroExtensionID=${requestResult.maestroExtensionID}, status=${requestResult.status}`
      );

      if (requestResult.status !== REQUEST_STATUSES.REQUESTED) {
        throw new Error(
          `expected new request status=${REQUEST_STATUSES.REQUESTED}, got ${requestResult.status}`
        );
      }

      const approveResult = await approveExtensionRequest(
        requestResult.maestroExtensionID
      );
      console.log(
        `  approveExtensionRequest → availableActivateDateTime=${approveResult.availableActivateDateTime}`
      );

      const afterApprove = await db.maestro.findUniqueOrThrow({
        where: { MaestroID: maestroID },
        select: {
          ActivateStatus: true,
          AvailableActivateDateTime: true,
          AccountType: true,
        },
      });
      const requestRow = await db.maestro_extension.findUniqueOrThrow({
        where: { MaestroExtensionID: requestResult.maestroExtensionID },
        select: { Status: true, AccountType: true },
      });
      const logRows = await db.maestro_log.findMany({
        where: { MaestroID: maestroID },
        select: { Type: true },
        orderBy: { MaestroLogID: "asc" },
      });

      const today = new Date();
      today.setHours(0, 0, 0, 0);
      const expectedYear = today.getFullYear() + 1;
      const actualAvailable = afterApprove.AvailableActivateDateTime;
      const actualYear = actualAvailable.getFullYear();

      const checks: Array<[string, boolean, string]> = [
        [
          "maestro.ActivateStatus becomes ACTIVE",
          afterApprove.ActivateStatus === ACTIVATE_STATUSES.ACTIVE,
          `got ${afterApprove.ActivateStatus}`,
        ],
        [
          "maestro.AccountType preserved",
          afterApprove.AccountType === scenario.accountType,
          `got ${afterApprove.AccountType}`,
        ],
        [
          "AvailableActivateDateTime = today +1 year (initial was in the past)",
          actualYear === expectedYear,
          `got year=${actualYear}, expected ${expectedYear}`,
        ],
        [
          "extension request Status becomes APPLIED",
          requestRow.Status === REQUEST_STATUSES.APPLIED,
          `got ${requestRow.Status}`,
        ],
        [
          "logs include request_extension_maestro",
          logRows.some((l) => l.Type === "request_extension_maestro"),
          JSON.stringify(logRows.map((l) => l.Type)),
        ],
        [
          "logs include extension_maestro",
          logRows.some((l) => l.Type === "extension_maestro"),
          JSON.stringify(logRows.map((l) => l.Type)),
        ],
      ];

      for (const [name, passed, detail] of checks) {
        console.log(`  ${passed ? "PASS" : "FAIL"}  ${name}  (${detail})`);
        if (!passed) failures += 1;
      }
    } catch (error) {
      failures += 1;
      console.error(`  ERROR:`, error);
    } finally {
      if (maestroID !== null) {
        await db.maestro_extension.deleteMany({ where: { MaestroID: maestroID } });
        await db.maestro_log.deleteMany({ where: { MaestroID: maestroID } });
        await db.maestro.delete({ where: { MaestroID: maestroID } });
        console.log(`  cleanup: removed rows for MaestroID=${maestroID}`);
      }
    }
  }

  await db.$disconnect();

  if (failures > 0) {
    console.error(`\n${failures} check(s) failed.`);
    process.exitCode = 1;
  } else {
    console.log(`\nAll checks passed.`);
  }
}

main().catch((error) => {
  console.error("Test run failed");
  console.error(error);
  process.exitCode = 1;
});