import { Test, TestingModule } from "@nestjs/testing";
import { RbacService } from "./rbac.service";
import { RbacRepository } from "./repositories/rbac.repository";

describe("RbacService", () => {
	let service: RbacService;
	let repository: RbacRepository;

	const mockRbacRepository = {
		findRolesByUserId: jest.fn(),
		findPermissionsByUserId: jest.fn(),
		countRoles: jest.fn(),
		createRole: jest.fn(),
	};

	beforeEach(async () => {
		jest.clearAllMocks();
		const module: TestingModule = await Test.createTestingModule({
			providers: [
				RbacService,
				{
					provide: RbacRepository,
					useValue: mockRbacRepository,
				},
			],
		}).compile();

		service = module.get<RbacService>(RbacService);
		repository = module.get<RbacRepository>(RbacRepository);
	});

	it("should be defined", () => {
		expect(service).toBeDefined();
	});

	describe("getUserRoles", () => {
		it("should return user roles", async () => {
			const userId = "user-id";
			const mockRoles = ["admin", "user"];
			mockRbacRepository.findRolesByUserId.mockResolvedValue(mockRoles);

			const result = await service.getUserRoles(userId);

			expect(result).toEqual(mockRoles);
			expect(repository.findRolesByUserId).toHaveBeenCalledWith(userId);
		});
	});

	describe("getUserPermissions", () => {
		it("should return user permissions", async () => {
			const userId = "user-id";
			const mockPermissions = ["read", "write"];
			mockRbacRepository.findPermissionsByUserId.mockResolvedValue(
				mockPermissions,
			);

			const result = await service.getUserPermissions(userId);

			expect(result).toEqual(mockPermissions);
			expect(repository.findPermissionsByUserId).toHaveBeenCalledWith(userId);
		});
	});

	describe("seedRoles", () => {
		it("should be called on application bootstrap", async () => {
			const seedRolesSpy = jest.spyOn(service, "seedRoles");
			await service.onApplicationBootstrap();
			expect(seedRolesSpy).toHaveBeenCalled();
		});

		it("should seed roles if none exist", async () => {
			mockRbacRepository.countRoles.mockResolvedValue(0);

			await service.seedRoles();

			expect(repository.countRoles).toHaveBeenCalled();
			expect(repository.createRole).toHaveBeenCalledTimes(3);
			expect(repository.createRole).toHaveBeenCalledWith(
				"Administrator",
				"admin",
				"Full system access",
			);
		});

		it("should not seed roles if some already exist", async () => {
			mockRbacRepository.countRoles.mockResolvedValue(3);

			await service.seedRoles();

			expect(repository.countRoles).toHaveBeenCalled();
			expect(repository.createRole).not.toHaveBeenCalled();
		});
	});
});