// @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 { selectLimit } = vi.hoisted(() => {
	const selectLimit = vi.fn().mockResolvedValue([]);
	return { selectLimit };
});

vi.mock("@/env", () => ({ env: { CONVERT_PASSWORDS: false } }));
vi.mock("@/lib/auth/password", () => ({ checkLogin: vi.fn() }));
vi.mock("@/lib/db", () => ({
	db: {
		select: vi.fn(() => ({
			from: vi.fn(() => ({
				where: vi.fn(() => ({
					limit: selectLimit,
				})),
			})),
		})),
	},
	User: {
		password: "password",
		twoFactorConfirmedAt: "twoFactorConfirmedAt",
		mail: "mail",
		mailVerified: "mailVerified",
		username: "username",
	},
}));
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);
	selectLimit.mockResolvedValue([]);
});

describe("precheckLogin", () => {
	it("returns ok for valid login without 2FA", async () => {
		selectLimit.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 () => {
		selectLimit.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);
		selectLimit.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 () => {
		selectLimit.mockResolvedValue([]);
		const result = await precheckLogin("nonexistent", "pass");
		expect(result).toBe("invalid");
		expect(checkLogin).toHaveBeenCalled();
	});

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