import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { BlacklistService } from './blacklist.service';
import { Blacklist } from '../../entities/blacklist.entity';
import { User } from '../../entities/user.entity';
import { GroupMember } from '../../entities/group-member.entity';
import { BlacklistStatus } from '../../common/enums';
import { NotFoundException, ForbiddenException } from '@nestjs/common';

describe('BlacklistService', () => {
  let service: BlacklistService;
  let blacklistRepository: Repository<Blacklist>;
  let userRepository: Repository<User>;
  let groupMemberRepository: Repository<GroupMember>;

  const mockBlacklist = {
    id: 'blacklist-1',
    reporterId: 'user-1',
    targetGameId: 'game-123',
    targetNickname: '违规玩家',
    reason: '恶意行为',
    proofImages: ['image1.jpg'],
    status: BlacklistStatus.PENDING,
    createdAt: new Date(),
  };

  const mockUser = {
    id: 'user-1',
    username: '举报人',
    isMember: true,
  };

  const mockGroupMember = {
    id: 'member-1',
    userId: 'user-1',
    groupId: 'group-1',
  };

  const mockQueryBuilder = {
    leftJoinAndSelect: jest.fn().mockReturnThis(),
    andWhere: jest.fn().mockReturnThis(),
    orderBy: jest.fn().mockReturnThis(),
    getMany: jest.fn(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        BlacklistService,
        {
          provide: getRepositoryToken(Blacklist),
          useValue: {
            create: jest.fn(),
            save: jest.fn(),
            find: jest.fn(),
            findOne: jest.fn(),
            remove: jest.fn(),
            count: jest.fn(),
            createQueryBuilder: jest.fn(() => mockQueryBuilder),
          },
        },
        {
          provide: getRepositoryToken(User),
          useValue: {
            findOne: jest.fn(),
          },
        },
        {
          provide: getRepositoryToken(GroupMember),
          useValue: {
            find: jest.fn(),
          },
        },
      ],
    }).compile();

    service = module.get<BlacklistService>(BlacklistService);
    blacklistRepository = module.get<Repository<Blacklist>>(getRepositoryToken(Blacklist));
    userRepository = module.get<Repository<User>>(getRepositoryToken(User));
    groupMemberRepository = module.get<Repository<GroupMember>>(getRepositoryToken(GroupMember));
  });

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

  describe('create', () => {
    it('应该成功创建黑名单举报', async () => {
      const createDto = {
        targetGameId: 'game-123',
        targetNickname: '违规玩家',
        reason: '恶意行为',
        proofImages: ['image1.jpg'],
      };

      jest.spyOn(userRepository, 'findOne').mockResolvedValue(mockUser as any);
      jest.spyOn(blacklistRepository, 'create').mockReturnValue(mockBlacklist as any);
      jest.spyOn(blacklistRepository, 'save').mockResolvedValue(mockBlacklist as any);
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue(mockBlacklist as any);

      const result = await service.create('user-1', createDto);

      expect(result).toBeDefined();
      expect(blacklistRepository.create).toHaveBeenCalledWith({
        ...createDto,
        reporterId: 'user-1',
        status: BlacklistStatus.PENDING,
      });
      expect(blacklistRepository.save).toHaveBeenCalled();
    });
  });

  describe('findAll', () => {
    it('应该返回黑名单列表', async () => {
      const query = { status: BlacklistStatus.APPROVED };
      mockQueryBuilder.getMany.mockResolvedValue([mockBlacklist]);

      const result = await service.findAll(query);

      expect(result).toHaveLength(1);
      expect(blacklistRepository.createQueryBuilder).toHaveBeenCalled();
    });

    it('应该支持按状态筛选', async () => {
      const query = { status: BlacklistStatus.PENDING };
      
      mockQueryBuilder.getMany.mockResolvedValue([mockBlacklist]);

      await service.findAll(query);

      expect(mockQueryBuilder.andWhere).toHaveBeenCalledWith(
        'blacklist.status = :status',
        { status: BlacklistStatus.PENDING }
      );
    });
  });

  describe('findOne', () => {
    it('应该返回单个黑名单记录', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue(mockBlacklist as any);

      const result = await service.findOne('blacklist-1');

      expect(result).toBeDefined();
      expect(result.id).toBe('blacklist-1');
    });

    it('记录不存在时应该抛出异常', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue(null);

      await expect(service.findOne('non-existent')).rejects.toThrow(NotFoundException);
    });
  });

  describe('review', () => {
    it('应该成功审核黑名单（会员权限）', async () => {
      const reviewDto = {
        status: BlacklistStatus.APPROVED,
        reviewNote: '确认违规',
      };

      const updatedBlacklist = {
        ...mockBlacklist,
        ...reviewDto,
        reviewerId: 'user-1',
      };

      jest.spyOn(userRepository, 'findOne').mockResolvedValue(mockUser as any);
      jest.spyOn(blacklistRepository, 'findOne')
        .mockResolvedValueOnce(mockBlacklist as any) // First call in review method
        .mockResolvedValueOnce(updatedBlacklist as any); // Second call in findOne at the end
      jest.spyOn(blacklistRepository, 'save').mockResolvedValue(updatedBlacklist as any);

      const result = await service.review('user-1', 'blacklist-1', reviewDto);

      expect(result.status).toBe(BlacklistStatus.APPROVED);
      expect(blacklistRepository.save).toHaveBeenCalled();
    });

    it('非会员审核时应该抛出异常', async () => {
      const reviewDto = {
        status: BlacklistStatus.APPROVED,
      };

      jest.spyOn(userRepository, 'findOne').mockResolvedValue({
        ...mockUser,
        isMember: false,
      } as any);

      await expect(service.review('user-1', 'blacklist-1', reviewDto)).rejects.toThrow(ForbiddenException);
    });

    it('用户不存在时应该抛出异常', async () => {
      const reviewDto = {
        status: BlacklistStatus.APPROVED,
      };

      jest.spyOn(userRepository, 'findOne').mockResolvedValue(null);

      await expect(service.review('user-1', 'blacklist-1', reviewDto)).rejects.toThrow(ForbiddenException);
    });
  });

  describe('checkBlacklist', () => {
    it('应该正确检查玩家是否在黑名单', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue({
        ...mockBlacklist,
        status: BlacklistStatus.APPROVED,
      } as any);

      const result = await service.checkBlacklist('game-123');

      expect(result.isBlacklisted).toBe(true);
      expect(result.blacklist).toBeDefined();
      expect(blacklistRepository.findOne).toHaveBeenCalledWith({
        where: {
          targetGameId: 'game-123',
          status: BlacklistStatus.APPROVED,
        },
      });
    });

    it('玩家不在黑名单时应该返回false', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue(null);

      const result = await service.checkBlacklist('game-123');

      expect(result.isBlacklisted).toBe(false);
      expect(result.blacklist).toBeNull();
    });
  });

  describe('remove', () => {
    it('举报人应该可以删除自己的举报', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue(mockBlacklist as any);
      jest.spyOn(userRepository, 'findOne').mockResolvedValue(mockUser as any);
      jest.spyOn(blacklistRepository, 'remove').mockResolvedValue(mockBlacklist as any);

      const result = await service.remove('user-1', 'blacklist-1');

      expect(result.message).toBe('删除成功');
      expect(blacklistRepository.remove).toHaveBeenCalled();
    });

    it('会员应该可以删除任何举报', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue({
        ...mockBlacklist,
        reporterId: 'other-user',
      } as any);
      jest.spyOn(userRepository, 'findOne').mockResolvedValue(mockUser as any);
      jest.spyOn(blacklistRepository, 'remove').mockResolvedValue(mockBlacklist as any);

      const result = await service.remove('user-1', 'blacklist-1');

      expect(result.message).toBe('删除成功');
    });

    it('非举报人且非会员删除时应该抛出异常', async () => {
      jest.spyOn(blacklistRepository, 'findOne').mockResolvedValue({
        ...mockBlacklist,
        reporterId: 'other-user',
      } as any);
      jest.spyOn(userRepository, 'findOne').mockResolvedValue({
        ...mockUser,
        isMember: false,
      } as any);

      await expect(service.remove('user-1', 'blacklist-1')).rejects.toThrow(ForbiddenException);
    });
  });
});