import { Test, TestingModule } from "@nestjs/testing";
import { NotFoundException } from "@nestjs/common";
import { ProjectService } from "./project.service";
import { ProjectRepository } from "./project.repository";

type MockProject = { id: string; name: string };

describe("ProjectService", () => {
  let service: ProjectService;

  const mockFindAll = jest.fn<Promise<MockProject[]>, []>();
  const mockFindOne = jest.fn<Promise<MockProject | undefined>, [string]>();
  const mockCreate = jest.fn<Promise<MockProject>, [Record<string, unknown>]>();
  const mockUpdate = jest.fn<Promise<MockProject>, [string, Record<string, unknown>]>();
  const mockRemove = jest.fn<Promise<MockProject>, [string]>();

  beforeEach(async () => {
    mockFindAll.mockReset();
    mockFindOne.mockReset();
    mockCreate.mockReset();
    mockUpdate.mockReset();
    mockRemove.mockReset();

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        ProjectService,
        {
          provide: ProjectRepository,
          useValue: {
            findAll: mockFindAll,
            findOne: mockFindOne,
            create: mockCreate,
            update: mockUpdate,
            remove: mockRemove,
          },
        },
      ],
    }).compile();

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

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

  describe("findAll", () => {
    it("should return all projects", async () => {
      const expected = [{ id: "1", name: "Test" }];
      mockFindAll.mockResolvedValue(expected);

      const result = await service.findAll();
      expect(result).toEqual(expected);
      expect(mockFindAll).toHaveBeenCalled();
    });
  });

  describe("findOne", () => {
    it("should return a project by id", async () => {
      const expected = { id: "1", name: "Test" };
      mockFindOne.mockResolvedValue(expected);

      const result = await service.findOne("1");
      expect(result).toEqual(expected);
      expect(mockFindOne).toHaveBeenCalledWith("1");
    });

    it("should throw NotFoundException when project not found", async () => {
      mockFindOne.mockResolvedValue(undefined);

      await expect(service.findOne("nonexistent")).rejects.toThrow(NotFoundException);
    });
  });

  describe("create", () => {
    it("should create and return a project", async () => {
      const body = { name: "New Project" };
      const expected = { id: "1", name: "New Project" };
      mockCreate.mockResolvedValue(expected);

      const result = await service.create(body);
      expect(result).toEqual(expected);
      expect(mockCreate).toHaveBeenCalledWith(body);
    });
  });

  describe("update", () => {
    it("should update and return a project", async () => {
      const body = { name: "Updated" };
      const expected = { id: "1", name: "Updated" };
      mockFindOne.mockResolvedValue({ id: "1" } as MockProject);
      mockUpdate.mockResolvedValue(expected);

      const result = await service.update("1", body);
      expect(result).toEqual(expected);
      expect(mockFindOne).toHaveBeenCalledWith("1");
      expect(mockUpdate).toHaveBeenCalledWith("1", body);
    });
  });

  describe("remove", () => {
    it("should delete and return a project", async () => {
      mockFindOne.mockResolvedValue({ id: "1" } as MockProject);
      mockRemove.mockResolvedValue({ id: "1" } as MockProject);

      const result = await service.remove("1");
      expect(result).toEqual({ id: "1" });
      expect(mockFindOne).toHaveBeenCalledWith("1");
      expect(mockRemove).toHaveBeenCalledWith("1");
    });
  });
});