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

const configUrl = new URL("../functions/dailyTaskConfig.ts", import.meta.url);
const serviceUrl = new URL("../functions/dailyTaskService.ts", import.meta.url);
const functionUrl = new URL("../functions/dailyTaskDebug.ts", import.meta.url);
const state = { user: null };

registerHooks({
  resolve(specifier, context, nextResolve) {
    if (specifier === "@/dailyTaskConfig") return { url: configUrl.href, shortCircuit: true };
    if (specifier === "@/dailyTaskService") return { url: serviceUrl.href, shortCircuit: true };
    if (specifier === "@/Utils") {
      return { url: "data:text/javascript,export default { checkToken: (a, b) => a === b }", shortCircuit: true };
    }
    if (specifier === "@lafjs/cloud") {
      return {
        url: `data:text/javascript,export default globalThis.__dailyTaskDebugCloud`,
        shortCircuit: true,
      };
    }
    return nextResolve(specifier, context);
  },
});

globalThis.__dailyTaskDebugCloud = {
  database() {
    return {
      collection() {
        return {
          where() {
            return {
              async getOne() { return { data: state.user }; },
              async update(data) { Object.assign(state.user, data); return { updated: 1 }; },
            };
          },
        };
      },
    };
  },
};
process.env.DAILY_TASK_DEBUG_KEY = "debug-key";

const handler = (await import(functionUrl)).default;

function makeUser(isDebug = "true") {
  state.user = { _id: "debug-user", token: "token", isDebug, levelAmount: 20, task: null };
}

async function call(action, extra = {}) {
  return handler({ body: { uid: "debug-user", token: "token", debugKey: "debug-key", action, ...extra } });
}

test("rejects non-debug users", async () => {
  makeUser(false);
  const result = await call("complete_all_daily");
  assert.equal(result.code, 403);
});

test("rejects an invalid debug key", async () => {
  makeUser();
  const result = await call("complete_all_daily", { debugKey: "wrong-key" });
  assert.equal(result.code, 403);
});

test("completes one daily task by slot", async () => {
  makeUser();
  const result = await call("complete_daily", { slot: 0 });
  assert.equal(result.code, 1);
  assert.equal(result.data.task.dailyTasks[0].value, result.data.task.dailyTasks[0].target);
  assert.equal(result.data.task.dailyTasks[0].state, 1);
});

test("sets weekly stars and unlocks matching rewards", async () => {
  makeUser();
  const result = await call("set_weekly_stars", { value: 105 });
  assert.equal(result.data.task.weeklyStars, 105);
  assert.deepEqual(result.data.task.weeklyRewards.map(item => item.state), [1, 1, 1, 0]);
});

test("daily reset preserves weekly progress and weekly reset preserves daily tasks", async () => {
  makeUser();
  const weekly = await call("set_weekly_stars", { value: 70 });
  state.user.task = JSON.stringify(weekly.data.task);
  const resetDaily = await call("reset_daily");
  assert.equal(resetDaily.data.task.weeklyStars, 70);
  const dailyIds = resetDaily.data.task.dailyTasks.map(item => item.taskId);
  state.user.task = JSON.stringify(resetDaily.data.task);
  const resetWeekly = await call("reset_weekly");
  assert.equal(resetWeekly.data.task.weeklyStars, 0);
  assert.deepEqual(resetWeekly.data.task.dailyTasks.map(item => item.taskId), dailyIds);
});