import test from "node:test";
import assert from "node:assert/strict";
import { registerHooks } from "node:module";

let user;
globalThis.__careerCloudMock = {
  database: () => ({
    collection(name) {
      assert.equal(name, "users");
      return {
        where(query) {
          assert.equal(query._id, "u1");
          return {
            async getOne() { return { data: structuredClone(user) }; },
            async update(payload) { Object.assign(user, structuredClone(payload)); return { updated: 1 }; },
          };
        },
      };
    },
  }),
};

registerHooks({
  resolve(specifier, context, nextResolve) {
    const mocks = {
      "@lafjs/cloud": "export default globalThis.__careerCloudMock",
      "@/Utils": "export default { checkToken: (received, expected) => received === expected }",
      "ip2region": "export default class { search() { return null; } }",
      "@/goldMiner/service": "export {}",
      "@/goldMiner/config": "export {}",
    };
    if (Object.hasOwn(mocks, specifier)) {
      return { url: `data:text/javascript,${encodeURIComponent(mocks[specifier])}`, shortCircuit: true };
    }
    return nextResolve(specifier, context);
  },
});

const { default: saveLevel } = await import("../functions/userLevel.ts");

function reset(overrides = {}) {
  user = {
    _id: "u1", token: "secret", isWhite: true, levelAmount: 0, addLevel: 0, film: 100,
    coinAmount: 500, signInActivity: "existing-activity-state", ...overrides,
  };
}

function save(levelAmount, extra = {}) {
  return saveLevel({
    body: { action: "save", uid: "u1", token: "secret", levelAmount, ...extra },
    headers: {},
  });
}

test("every assignment excludes the first 15 main levels and preserves existing career totals", async () => {
  for (const abTests of [
    undefined,
    { layer_1: { name: "new1_50", enabled: true, group: "A" } },
    { layer_1: { name: "new1_50", enabled: true, group: "B" } },
    { layer_1: { name: "new1_50", enabled: false, group: "B" } },
    { layer_1: { name: "other", group: "B" } },
    JSON.stringify({ layer_1: { name: "new1_50", group: "A" } }),
    "invalid-json",
  ]) {
    for (const oldAdd of [0, 7]) {
      for (const [from, to, earned] of [[0, 1, 0], [14, 15, 0], [14, 17, 2], [15, 16, 1], [41, 42, 1], [42, 42, 0]]) {
        reset({ levelAmount: from, addLevel: oldAdd, abTests });
        const result = await save(to);
        assert.equal(result.code, 1);
        assert.equal(user.levelAmount, to);
        assert.equal(user.addLevel, oldAdd + earned);
        assert.equal(user.film, 100 + to - from);
        assert.equal(user.coinAmount, 500);
        assert.equal(user.signInActivity, "existing-activity-state");
        assert.deepEqual(user.abTests, abTests);
      }
    }
  }
});

test("an existing A player keeps earlier career earnings when crossing the new threshold", async () => {
  reset({ levelAmount: 14, addLevel: 14, abTests: { layer_1: { name: "new1_50", group: "A" } } });
  await save(15);
  assert.equal(user.addLevel, 14);
  await save(16);
  assert.equal(user.addLevel, 15);
  await save(16);
  assert.equal(user.addLevel, 15);
});

test("endless victories still add one career win without changing main progress", async () => {
  reset({ levelAmount: 42, addLevel: 12 });
  const result = await save(42, { isWuXian: "true" });
  assert.equal(result.code, 1);
  assert.equal(user.levelAmount, 42);
  assert.equal(user.addLevel, 13);
  assert.equal(user.film, 100);
});