import { Test, TestingModule } from "@nestjs/testing";
import { getRepositoryToken } from "@nestjs/typeorm";
import { Repository, DataSource } from "typeorm";
import { AssetsService } from "./assets.service";
import { Asset } from "../../entities/asset.entity";
import { AssetLog } from "../../entities/asset-log.entity";
import { Group } from "../../entities/group.entity";
import { GroupMember } from "../../entities/group-member.entity";
import {
  AssetType,
  AssetStatus,
  GroupMemberRole,
  AssetLogAction,
} from "../../common/enums";
import {
  NotFoundException,
  ForbiddenException,
  BadRequestException,
} from "@nestjs/common";

describe("AssetsService", () => {
  let service: AssetsService;
  let assetRepository: Repository<Asset>;
  let assetLogRepository: Repository<AssetLog>;
  let groupRepository: Repository<Group>;
  let groupMemberRepository: Repository<GroupMember>;

  const mockAsset = {
    id: "asset-1",
    groupId: "group-1",
    type: AssetType.ACCOUNT,
    name: "测试账号",
    description: "测试描述",
    accountCredentials: "encrypted-data",
    quantity: 1,
    status: AssetStatus.AVAILABLE,
    currentBorrowerId: null,
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  const mockGroup = {
    id: "group-1",
    name: "测试小组",
  };

  const mockGroupMember = {
    id: "member-1",
    userId: "user-1",
    groupId: "group-1",
    role: GroupMemberRole.ADMIN,
  };

  const mockDataSource = {
    createQueryRunner: jest.fn().mockReturnValue({
      connect: jest.fn(),
      startTransaction: jest.fn(),
      commitTransaction: jest.fn(),
      rollbackTransaction: jest.fn(),
      release: jest.fn(),
      manager: {
        findOne: jest.fn(),
        find: jest.fn(),
        create: jest.fn(),
        save: jest.fn(),
      },
    }),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AssetsService,
        {
          provide: getRepositoryToken(Asset),
          useValue: {
            create: jest.fn(),
            save: jest.fn(),
            find: jest.fn(),
            findOne: jest.fn(),
            remove: jest.fn(),
          },
        },
        {
          provide: getRepositoryToken(AssetLog),
          useValue: {
            create: jest.fn(),
            save: jest.fn(),
            find: jest.fn(),
          },
        },
        {
          provide: getRepositoryToken(Group),
          useValue: {
            findOne: jest.fn(),
          },
        },
        {
          provide: getRepositoryToken(GroupMember),
          useValue: {
            findOne: jest.fn(),
          },
        },
        {
          provide: DataSource,
          useValue: mockDataSource,
        },
      ],
    }).compile();

    service = module.get<AssetsService>(AssetsService);
    assetRepository = module.get<Repository<Asset>>(getRepositoryToken(Asset));
    assetLogRepository = module.get<Repository<AssetLog>>(
      getRepositoryToken(AssetLog),
    );
    groupRepository = module.get<Repository<Group>>(getRepositoryToken(Group));
    groupMemberRepository = module.get<Repository<GroupMember>>(
      getRepositoryToken(GroupMember),
    );
  });

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

  describe("create", () => {
    it("应该成功创建资产", async () => {
      const createDto = {
        groupId: "group-1",
        type: AssetType.ACCOUNT,
        name: "测试账号",
        description: "测试描述",
      };

      jest
        .spyOn(groupRepository, "findOne")
        .mockResolvedValue(mockGroup as any);
      jest
        .spyOn(groupMemberRepository, "findOne")
        .mockResolvedValue(mockGroupMember as any);
      jest.spyOn(assetRepository, "create").mockReturnValue(mockAsset as any);
      jest.spyOn(assetRepository, "save").mockResolvedValue(mockAsset as any);
      jest
        .spyOn(assetRepository, "findOne")
        .mockResolvedValue(mockAsset as any);

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

      expect(result).toBeDefined();
      expect(groupRepository.findOne).toHaveBeenCalledWith({
        where: { id: "group-1" },
      });
      expect(groupMemberRepository.findOne).toHaveBeenCalled();
    });

    it("小组不存在时应该抛出异常", async () => {
      const createDto = {
        groupId: "group-1",
        type: AssetType.ACCOUNT,
        name: "测试账号",
      };

      jest.spyOn(groupRepository, "findOne").mockResolvedValue(null);

      await expect(service.create("user-1", createDto)).rejects.toThrow(
        NotFoundException,
      );
    });

    it("无权限时应该抛出异常", async () => {
      const createDto = {
        groupId: "group-1",
        type: AssetType.ACCOUNT,
        name: "测试账号",
      };

      jest
        .spyOn(groupRepository, "findOne")
        .mockResolvedValue(mockGroup as any);
      jest.spyOn(groupMemberRepository, "findOne").mockResolvedValue({
        ...mockGroupMember,
        role: GroupMemberRole.MEMBER,
      } as any);

      await expect(service.create("user-1", createDto)).rejects.toThrow(
        ForbiddenException,
      );
    });
  });

  describe("findAll", () => {
    it("应该返回资产列表", async () => {
      jest.spyOn(assetRepository, "find").mockResolvedValue([mockAsset] as any);

      const result = await service.findAll("group-1");

      expect(result).toHaveLength(1);
      expect(result[0].accountCredentials).toBeUndefined();
    });
  });

  describe("borrow", () => {
    it("应该成功借用资产", async () => {
      const borrowDto = { reason: "需要使用" };

      jest
        .spyOn(assetRepository, "findOne")
        .mockResolvedValue(mockAsset as any);
      jest
        .spyOn(groupMemberRepository, "findOne")
        .mockResolvedValue(mockGroupMember as any);
      jest
        .spyOn(assetRepository, "save")
        .mockResolvedValue({ ...mockAsset, status: AssetStatus.IN_USE } as any);
      jest.spyOn(assetLogRepository, "create").mockReturnValue({} as any);
      jest.spyOn(assetLogRepository, "save").mockResolvedValue({} as any);

      const result = await service.borrow("user-1", "asset-1", borrowDto);

      expect(result.message).toBe("借用成功");
      expect(assetRepository.save).toHaveBeenCalled();
      expect(assetLogRepository.save).toHaveBeenCalled();
    });

    it("资产不可用时应该抛出异常", async () => {
      const borrowDto = { reason: "需要使用" };

      jest.spyOn(assetRepository, "findOne").mockResolvedValue({
        ...mockAsset,
        status: AssetStatus.IN_USE,
      } as any);

      await expect(
        service.borrow("user-1", "asset-1", borrowDto),
      ).rejects.toThrow(BadRequestException);
    });
  });

  describe("return", () => {
    it("应该成功归还资产", async () => {
      jest.spyOn(assetRepository, "findOne").mockResolvedValue({
        ...mockAsset,
        currentBorrowerId: "user-1",
      } as any);
      jest.spyOn(assetRepository, "save").mockResolvedValue(mockAsset as any);
      jest.spyOn(assetLogRepository, "create").mockReturnValue({} as any);
      jest.spyOn(assetLogRepository, "save").mockResolvedValue({} as any);

      const result = await service.return("user-1", "asset-1", "已归还");

      expect(result.message).toBe("归还成功");
      expect(assetRepository.save).toHaveBeenCalled();
    });

    it("非借用人归还时应该抛出异常", async () => {
      jest.spyOn(assetRepository, "findOne").mockResolvedValue({
        ...mockAsset,
        currentBorrowerId: "user-2",
      } as any);

      await expect(service.return("user-1", "asset-1")).rejects.toThrow(
        ForbiddenException,
      );
    });
  });

  describe("remove", () => {
    it("应该成功删除资产", async () => {
      jest
        .spyOn(assetRepository, "findOne")
        .mockResolvedValue(mockAsset as any);
      jest
        .spyOn(groupMemberRepository, "findOne")
        .mockResolvedValue(mockGroupMember as any);
      jest.spyOn(assetRepository, "remove").mockResolvedValue(mockAsset as any);

      const result = await service.remove("user-1", "asset-1");

      expect(result.message).toBe("删除成功");
      expect(assetRepository.remove).toHaveBeenCalled();
    });
  });
});