import { ExecutionContext, UnauthorizedException } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { Test, TestingModule } from "@nestjs/testing";
import { getIronSession } from "iron-session";
import { JwtService } from "../../crypto/services/jwt.service";
import { AuthGuard } from "./auth.guard";

jest.mock("jose", () => ({}));
jest.mock("iron-session", () => ({
	getIronSession: jest.fn(),
}));

describe("AuthGuard", () => {
	let guard: AuthGuard;
	let _jwtService: JwtService;
	let _configService: ConfigService;

	const mockJwtService = {
		verifyJwt: jest.fn(),
	};

	const mockConfigService = {
		get: jest.fn().mockReturnValue("session-password"),
	};

	beforeEach(async () => {
		const module: TestingModule = await Test.createTestingModule({
			providers: [
				AuthGuard,
				{ provide: JwtService, useValue: mockJwtService },
				{ provide: ConfigService, useValue: mockConfigService },
			],
		}).compile();

		guard = module.get<AuthGuard>(AuthGuard);
		_jwtService = module.get<JwtService>(JwtService);
		_configService = module.get<ConfigService>(ConfigService);
	});

	it("should return true for valid token", async () => {
		const request = { user: null };
		const context = {
			switchToHttp: () => ({
				getRequest: () => request,
				getResponse: () => ({}),
			}),
		} as unknown as ExecutionContext;

		(getIronSession as jest.Mock).mockResolvedValue({
			accessToken: "valid-token",
		});
		mockJwtService.verifyJwt.mockResolvedValue({ sub: "user1" });

		const result = await guard.canActivate(context);
		expect(result).toBe(true);
		expect(request.user).toEqual({ sub: "user1" });
	});

	it("should throw UnauthorizedException if no token", async () => {
		const context = {
			switchToHttp: () => ({
				getRequest: () => ({}),
				getResponse: () => ({}),
			}),
		} as ExecutionContext;

		(getIronSession as jest.Mock).mockResolvedValue({});

		await expect(guard.canActivate(context)).rejects.toThrow(
			UnauthorizedException,
		);
	});

	it("should throw UnauthorizedException if token invalid", async () => {
		const context = {
			switchToHttp: () => ({
				getRequest: () => ({}),
				getResponse: () => ({}),
			}),
		} as ExecutionContext;

		(getIronSession as jest.Mock).mockResolvedValue({ accessToken: "invalid" });
		mockJwtService.verifyJwt.mockRejectedValue(new Error("invalid"));

		await expect(guard.canActivate(context)).rejects.toThrow(
			UnauthorizedException,
		);
	});
});