import { Test, TestingModule } from '@nestjs/testing';
import { ProjectsController } from './projects.controller';
import { ProjectsService } from '../services/projects.service';
import { CreateProjectDto } from '../dto/create-project.dto';
import { UpdateProjectDto } from '../dto/update-project.dto';
import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';

describe('ProjectsController', () => {
  let controller: ProjectsController;
  let service: ProjectsService;

  // Mock data
  const mockProject = {
    id: 'project1',
    name: 'Test Project',
    description: 'Test Description',
    ownerId: 'user1',
    settings: {},
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  const mockUser = {
    id: 'user2',
    name: 'Test User',
    githubId: '12345',
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  const mockCollaboration = {
    id: 'collab1',
    projectId: 'project1',
    userId: 'user2',
    createdAt: new Date(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [ProjectsController],
      providers: [
        {
          provide: ProjectsService,
          useValue: {
            create: jest.fn().mockResolvedValue(mockProject),
            findAll: jest.fn().mockResolvedValue([mockProject]),
            findByOwnerId: jest.fn().mockResolvedValue([mockProject]),
            findById: jest.fn().mockResolvedValue(mockProject),
            update: jest.fn().mockResolvedValue(mockProject),
            remove: jest.fn().mockResolvedValue(mockProject),
            checkUserAccess: jest.fn().mockResolvedValue(true),
            addCollaborator: jest.fn().mockResolvedValue(mockCollaboration),
            removeCollaborator: jest.fn().mockResolvedValue(mockCollaboration),
            getCollaborators: jest.fn().mockResolvedValue([{ user: mockUser }]),
          },
        },
      ],
    })
    .overrideGuard(JwtAuthGuard)
    .useValue({ canActivate: () => true })
    .compile();

    controller = module.get<ProjectsController>(ProjectsController);
    service = module.get<ProjectsService>(ProjectsService);
  });

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

  describe('create', () => {
    it('should create a new project', async () => {
      const createProjectDto: CreateProjectDto = {
        name: 'Test Project',
        description: 'Test Description',
        ownerId: 'user1',
      };

      expect(await controller.create(createProjectDto)).toBe(mockProject);
      expect(service.create).toHaveBeenCalledWith(createProjectDto);
    });
  });

  describe('findAll', () => {
    it('should return all projects when no ownerId is provided', async () => {
      expect(await controller.findAll()).toEqual([mockProject]);
      expect(service.findAll).toHaveBeenCalled();
    });

    it('should return projects filtered by ownerId when ownerId is provided', async () => {
      const ownerId = 'user1';
      expect(await controller.findAll(ownerId)).toEqual([mockProject]);
      expect(service.findByOwnerId).toHaveBeenCalledWith(ownerId);
    });
  });

  describe('findOne', () => {
    it('should return a project by ID', async () => {
      const id = 'project1';
      expect(await controller.findOne(id)).toBe(mockProject);
      expect(service.findById).toHaveBeenCalledWith(id);
    });
  });

  describe('update', () => {
    it('should update a project', async () => {
      const id = 'project1';
      const updateProjectDto: UpdateProjectDto = {
        name: 'Updated Project',
      };

      expect(await controller.update(id, updateProjectDto)).toBe(mockProject);
      expect(service.update).toHaveBeenCalledWith(id, updateProjectDto);
    });
  });

  describe('remove', () => {
    it('should delete a project', async () => {
      const id = 'project1';
      expect(await controller.remove(id)).toBe(mockProject);
      expect(service.remove).toHaveBeenCalledWith(id);
    });
  });

  describe('checkUserAccess', () => {
    it('should check if a user has access to a project', async () => {
      const projectId = 'project1';
      const userId = 'user1';

      expect(await controller.checkUserAccess(projectId, userId)).toBe(true);
      expect(service.checkUserAccess).toHaveBeenCalledWith(projectId, userId);
    });
  });

  describe('addCollaborator', () => {
    it('should add a collaborator to a project', async () => {
      const projectId = 'project1';
      const userId = 'user2';

      expect(await controller.addCollaborator(projectId, userId)).toBe(mockCollaboration);
      expect(service.addCollaborator).toHaveBeenCalledWith(projectId, userId);
    });
  });

  describe('removeCollaborator', () => {
    it('should remove a collaborator from a project', async () => {
      const projectId = 'project1';
      const userId = 'user2';

      expect(await controller.removeCollaborator(projectId, userId)).toBe(mockCollaboration);
      expect(service.removeCollaborator).toHaveBeenCalledWith(projectId, userId);
    });
  });

  describe('getCollaborators', () => {
    it('should get all collaborators for a project', async () => {
      const projectId = 'project1';
      const mockCollaborators = [{ user: mockUser }];

      expect(await controller.getCollaborators(projectId)).toEqual(mockCollaborators);
      expect(service.getCollaborators).toHaveBeenCalledWith(projectId);
    });
  });
});