import { Test } from '@nestjs/testing';
import { UserRepo } from '@models/users/repos/user.repo';
import {
  createParamDecorator,
  ExecutionContext,
  NotFoundException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { GetMe } from '@models/users/useCases/GetMe/GetMe';
import { User } from '@models/users/domain/user';
import { jwtConstants } from '@models/users/constants';
import { PrismaService } from '@/database/services/prisma.service';
import { fakerFR } from '@faker-js/faker';

export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;
  },
);

describe('GetMe Controller', () => {
  const mockUser = User.create({
    email: fakerFR.internet.email(),
    firstname: fakerFR.person.firstName(),
    lastname: fakerFR.person.lastName(),
    role: 'USER',
    password: 'testtest',
  });

  let controller: GetMe;
  let userRepo: UserRepo;
  let jwtService: JwtService;
  let userCreated: User;
  let prismaService: PrismaService;

  beforeAll(async () => {
    prismaService = new PrismaService();
    userRepo = new UserRepo(prismaService);

    userCreated = await userRepo.create(mockUser);

    const module = await Test.createTestingModule({
      controllers: [GetMe],
      providers: [
        {
          provide: UserRepo,
          useValue: userRepo,
        },
        {
          provide: JwtService,
          useValue: new JwtService({
            secret: jwtConstants.secret,
          }),
        },
      ],
    }).compile();

    controller = module.get(GetMe);
    jwtService = module.get(JwtService);
  });

  describe('execute', () => {
    it('should return the current user with valid JWT', async () => {
      const result = await controller.execute({ id: mockUser.id });

      expect(result).toEqual({
        id: mockUser.id,
        email: mockUser.email,
        firstname: mockUser.firstname,
        lastname: mockUser.lastname,
        fullname: `${mockUser.firstname} ${mockUser.lastname}`,
        role: 'USER',
      });
    });

    it('should return null when user not found', async () => {
      try {
        const result = await controller.execute({ id: '999' });
      } catch (e) {
        expect(e).toBeInstanceOf(NotFoundException);
      }
    });
  });
});
