// @ts-nocheck
import { beforeEach, describe, expect, it, vi } from "vitest";
import { checkLogin } from "@/lib/auth/password";
import { clientIp, rateLimit } from "@/lib/rate-limit";
import { captchaConfig, verifyCaptcha } from "@/lib/services/captcha";
import { siteSettings } from "@/lib/services/site-settings";
import { precheckLogin } from "./auth-precheck";

const { queryPreparedOne } = vi.hoisted(() => {
	const queryPreparedOne = vi.fn().mockResolvedValue(null);
	return { queryPreparedOne };
});

vi.mock("@/env", () => ({ env: { CONVERT_PASSWORDS: false } }));
vi.mock("@/lib/auth/password", () => ({ checkLogin: vi.fn() }));
vi.mock("@/lib/db", () => ({ queryPreparedOne }));
vi.mock("@/lib/rate-limit", () => ({ clientIp: vi.fn(), rateLimit: vi.fn() }));
vi.mock("@/lib/services/captcha", () => ({
	captchaConfig: vi.fn(),
	verifyCaptcha: vi.fn(),
}));
vi.mock("@/lib/services/site-settings", () => ({
	siteSettings: { getBool: vi.fn() },
}));

beforeEach(() => {
	vi.clearAllMocks();
	vi.mocked(clientIp).mockResolvedValue("1.2.3.4");
	vi.mocked(rateLimit).mockResolvedValue({ ok: true });
	vi.mocked(checkLogin).mockResolvedValue({ valid: true } as never);
	vi.mocked(captchaConfig).mockResolvedValue({ provider: "none" } as never);
	queryPreparedOne.mockResolvedValue(null);
});

describe("precheckLogin", () => {
	it("returns ok for valid login without 2FA", async () => {
		queryPreparedOne.mockResolvedValue({
			password: "hash",
			twoFactorConfirmedAt: null,
			mail: null,
			mailVerified: "0",
		});
		expect(await precheckLogin("user", "pass")).toBe("ok");
	});

	it("returns twofactor when 2FA is set up", async () => {
		queryPreparedOne.mockResolvedValue({
			password: "hash",
			twoFactorConfirmedAt: new Date(),
			mail: null,
			mailVerified: "0",
		});
		expect(await precheckLogin("user", "pass")).toBe("twofactor");
	});

	it("returns invalid for empty inputs", async () => {
		expect(await precheckLogin("", "")).toBe("invalid");
	});

	it("returns captcha when captcha required", async () => {
		vi.mocked(captchaConfig).mockResolvedValue({
			provider: "hcaptcha",
		} as never);
		vi.mocked(verifyCaptcha).mockResolvedValue(false);
		queryPreparedOne.mockResolvedValue({
			password: "hash",
			twoFactorConfirmedAt: null,
			mail: null,
			mailVerified: "0",
		});
		expect(await precheckLogin("user", "pass", "bad-token")).toBe("captcha");
	});

	it("returns invalid when user not found (dummy hash check)", async () => {
		queryPreparedOne.mockResolvedValue(null);
		const result = await precheckLogin("nonexistent", "pass");
		expect(result).toBe("invalid");
		expect(checkLogin).toHaveBeenCalled();
	});

	it("returns unverified when email verification required", async () => {
		queryPreparedOne.mockResolvedValue({
			password: "hash",
			twoFactorConfirmedAt: null,
			mail: "user@example.com",
			mailVerified: "0",
		});
		vi.mocked(siteSettings.getBool).mockResolvedValue(true);
		expect(await precheckLogin("user", "pass")).toBe("unverified");
	});
});