import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import {
  NotFoundException,
  BadRequestException,
  ForbiddenException,
} from '@nestjs/common';
import { LedgersService } from './ledgers.service';
import { Ledger } from '../../entities/ledger.entity';
import { Group } from '../../entities/group.entity';
import { GroupMember } from '../../entities/group-member.entity';

enum LedgerType {
  INCOME = 'income',
  EXPENSE = 'expense',
}

describe('LedgersService', () => {
  let service: LedgersService;
  let mockLedgerRepository: any;
  let mockGroupRepository: any;
  let mockGroupMemberRepository: any;

  const mockUser = { id: 'user-1', username: 'testuser' };
  const mockGroup = { 
    id: 'group-1', 
    name: '测试小组', 
    isActive: true,
    parentId: null,
  };
  const mockMembership = {
    id: 'member-1',
    userId: 'user-1',
    groupId: 'group-1',
    role: 'member',
    isActive: true,
  };

  const mockLedger = {
    id: 'ledger-1',
    groupId: 'group-1',
    creatorId: 'user-1',
    type: LedgerType.INCOME,
    amount: 100,
    category: '聚餐费用',
    description: '周末聚餐',
    createdAt: new Date('2024-01-20T10:00:00Z'),
    updatedAt: new Date(),
  };

  beforeEach(async () => {
    mockLedgerRepository = {
      create: jest.fn(),
      save: jest.fn(),
      findOne: jest.fn(),
      remove: jest.fn(),
      createQueryBuilder: jest.fn(),
    };

    mockGroupRepository = {
      findOne: jest.fn(),
      find: jest.fn(),
    };

    mockGroupMemberRepository = {
      findOne: jest.fn(),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        LedgersService,
        {
          provide: getRepositoryToken(Ledger),
          useValue: mockLedgerRepository,
        },
        {
          provide: getRepositoryToken(Group),
          useValue: mockGroupRepository,
        },
        {
          provide: getRepositoryToken(GroupMember),
          useValue: mockGroupMemberRepository,
        },
      ],
    }).compile();

    service = module.get<LedgersService>(LedgersService);
  });

  describe('create', () => {
    it('应该成功创建账目', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockLedgerRepository.create.mockReturnValue(mockLedger);
      mockLedgerRepository.save.mockResolvedValue(mockLedger);
      mockLedgerRepository.findOne.mockResolvedValue({
        ...mockLedger,
        group: mockGroup,
        creator: mockUser,
      });

      const result = await service.create('user-1', {
        groupId: 'group-1',
        type: LedgerType.INCOME,
        amount: 100,
        category: '聚餐费用',
        description: '周末聚餐',
      });

      expect(result).toHaveProperty('id');
      expect(result.amount).toBe(100);
      expect(mockLedgerRepository.save).toHaveBeenCalled();
    });

    it('应该在小组不存在时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(null);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          type: LedgerType.INCOME,
          amount: 100,
          category: '聚餐费用',
          description: '测试',
        }),
      ).rejects.toThrow(NotFoundException);
    });

    it('应该在用户不在小组中时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(null);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          type: LedgerType.INCOME,
          amount: 100,
          category: '聚餐费用',
          description: '测试',
        }),
      ).rejects.toThrow(ForbiddenException);
    });

    it('应该在金额无效时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          type: LedgerType.INCOME,
          amount: -100,
          category: '聚餐费用',
          description: '测试',
        }),
      ).rejects.toThrow(BadRequestException);
    });
  });

  describe('findAll', () => {
    it('应该成功获取账目列表', async () => {
      const mockQueryBuilder = {
        leftJoinAndSelect: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        orderBy: jest.fn().mockReturnThis(),
        skip: jest.fn().mockReturnThis(),
        take: jest.fn().mockReturnThis(),
        getManyAndCount: jest.fn().mockResolvedValue([[mockLedger], 1]),
      };

      mockLedgerRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      const result = await service.findAll('user-1', {
        groupId: 'group-1',
        page: 1,
        limit: 10,
      });

      expect(result).toHaveProperty('items');
      expect(result).toHaveProperty('total');
      expect(result.items).toHaveLength(1);
    });

    it('应该支持按类型筛选', async () => {
      const mockQueryBuilder = {
        leftJoinAndSelect: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        orderBy: jest.fn().mockReturnThis(),
        skip: jest.fn().mockReturnThis(),
        take: jest.fn().mockReturnThis(),
        getManyAndCount: jest.fn().mockResolvedValue([[mockLedger], 1]),
      };

      mockLedgerRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      const result = await service.findAll('user-1', {
        groupId: 'group-1',
        type: LedgerType.INCOME,
        page: 1,
        limit: 10,
      });

      expect(result.items).toHaveLength(1);
      expect(mockQueryBuilder.andWhere).toHaveBeenCalled();
    });
  });

  describe('findOne', () => {
    it('应该成功获取账目详情', async () => {
      mockLedgerRepository.findOne.mockResolvedValue({
        ...mockLedger,
        group: mockGroup,
        creator: mockUser,
      });

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

      expect(result).toHaveProperty('id');
      expect(result.id).toBe('ledger-1');
    });

    it('应该在账目不存在时抛出异常', async () => {
      mockLedgerRepository.findOne.mockResolvedValue(null);

      await expect(service.findOne('ledger-1')).rejects.toThrow(
        NotFoundException,
      );
    });
  });

  describe('update', () => {
    it('应该成功更新账目', async () => {
      mockLedgerRepository.findOne
        .mockResolvedValueOnce(mockLedger)
        .mockResolvedValueOnce({
          ...mockLedger,
          amount: 200,
          group: mockGroup,
          creator: mockUser,
        });
      mockGroupMemberRepository.findOne.mockResolvedValue({
        ...mockMembership,
        role: 'admin',
      });
      mockLedgerRepository.save.mockResolvedValue({
        ...mockLedger,
        amount: 200,
      });

      const result = await service.update('user-1', 'ledger-1', {
        amount: 200,
      });

      expect(result.amount).toBe(200);
    });

    it('应该在账目不存在时抛出异常', async () => {
      mockLedgerRepository.findOne.mockResolvedValue(null);

      await expect(
        service.update('user-1', 'ledger-1', { amount: 200 }),
      ).rejects.toThrow(NotFoundException);
    });

    it('应该在无权限时抛出异常', async () => {
      mockLedgerRepository.findOne.mockResolvedValue(mockLedger);
      mockGroupMemberRepository.findOne.mockResolvedValue({
        ...mockMembership,
        role: 'member',
      });

      await expect(
        service.update('user-2', 'ledger-1', { amount: 200 }),
      ).rejects.toThrow(ForbiddenException);
    });
  });

  describe('remove', () => {
    it('应该成功删除账目', async () => {
      mockLedgerRepository.findOne.mockResolvedValue(mockLedger);
      mockGroupMemberRepository.findOne.mockResolvedValue({
        ...mockMembership,
        role: 'admin',
      });
      mockLedgerRepository.remove.mockResolvedValue(mockLedger);

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

      expect(result).toHaveProperty('message');
    });

    it('应该在无权限时抛出异常', async () => {
      mockLedgerRepository.findOne.mockResolvedValue(mockLedger);
      mockGroupMemberRepository.findOne.mockResolvedValue({
        ...mockMembership,
        role: 'member',
      });

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

  describe('getMonthlyStatistics', () => {
    it('应该成功获取月度统计', async () => {
      const mockQueryBuilder = {
        where: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        getMany: jest.fn().mockResolvedValue([
          { ...mockLedger, type: LedgerType.INCOME, amount: 100 },
          { ...mockLedger, type: LedgerType.EXPENSE, amount: 50 },
        ]),
      };

      mockLedgerRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      const result = await service.getMonthlyStatistics('user-1', {
        groupId: 'group-1',
        year: 2024,
        month: 1,
      });

      expect(result).toHaveProperty('income');
      expect(result).toHaveProperty('expense');
      expect(result).toHaveProperty('balance');
      expect(result).toHaveProperty('categories');
    });

    it('应该在用户不在小组时抛出异常', async () => {
      mockGroupMemberRepository.findOne.mockResolvedValue(null);

      await expect(
        service.getMonthlyStatistics('user-1', {
          groupId: 'group-1',
          year: 2024,
          month: 1,
        }),
      ).rejects.toThrow(ForbiddenException);
    });
  });

  describe('getHierarchicalSummary', () => {
    it('应该成功获取层级汇总', async () => {
      const childGroup = { id: 'group-2', name: '子小组', parentId: 'group-1' };
      const mockQueryBuilder = {
        where: jest.fn().mockReturnThis(),
        getMany: jest.fn().mockResolvedValue([mockLedger]),
      };

      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockGroupRepository.find.mockResolvedValue([childGroup]);
      mockLedgerRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);

      const result = await service.getHierarchicalSummary('user-1', 'group-1');

      expect(result).toHaveProperty('groupId');
      expect(result).toHaveProperty('income');
      expect(result).toHaveProperty('expense');
      expect(result).toHaveProperty('balance');
    });
  });
});