const Event = require('../../Models/Event');
const User = require('../../Models/User');
const EventParticipationLog = require('../../Models/EventParticipationLog');

// Mock external dependencies
jest.mock('../../Models/Event');
jest.mock('../../Models/User');
jest.mock('../../Models/EventParticipationLog');

// Import the controller functions
const eventController = require('../../Controller/event');

describe('Event Controller Unit Tests', () => {
  let mockReq, mockRes, mockNext;

  beforeEach(() => {
    // Reset all mocks
    jest.clearAllMocks();

    // Setup mock request, response, and next
    mockReq = {
      body: {},
      params: {},
      query: {},
      headers: {},
      user: null,
    };

    mockRes = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn().mockReturnThis(),
      send: jest.fn().mockReturnThis(),
    };

    mockNext = jest.fn();
  });

  describe('createEvent', () => {
    it('should create a new event successfully', async () => {
      const eventData = {
        title: 'Test Event',
        description: 'Test Description',
        category: 'Technology',
        location: 'Test Location',
        schedule: {
          start: new Date('2024-01-01T10:00:00Z'),
          end: new Date('2024-01-01T12:00:00Z'),
        },
        maxParticipants: 50,
        registrationDeadline: new Date('2023-12-31T23:59:59Z'),
      };

      mockReq.body = eventData;
      mockReq.user = { userId: 'host123' };

      const mockEvent = {
        _id: 'event123',
        ...eventData,
        hostId: 'host123',
        status: 'upcoming',
        participants: [],
        save: jest.fn().mockResolvedValue(true),
      };

      Event.create = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.createEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.create).toHaveBeenCalledWith({
        ...eventData,
        hostId: 'host123',
        status: 'upcoming',
        participants: [],
      });
      expect(mockRes.status).toHaveBeenCalledWith(201);
      expect(mockRes.json).toHaveBeenCalledWith({
        message: 'Event created successfully',
        event: mockEvent,
      });
    });

    it('should handle event creation errors', async () => {
      const eventData = {
        title: 'Test Event',
        description: 'Test Description',
      };

      mockReq.body = eventData;
      mockReq.user = { userId: 'host123' };

      Event.create = jest.fn().mockRejectedValue(new Error('Database error'));

      // Execute
      await eventController.createEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(500);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'Server error creating event.',
      });
    });
  });

  describe('getAllEvents', () => {
    it('should return all events with pagination', async () => {
      const mockEvents = [
        {
          _id: 'event1',
          title: 'Event 1',
          status: 'upcoming',
        },
        {
          _id: 'event2',
          title: 'Event 2',
          status: 'upcoming',
        },
      ];

      mockReq.query = {
        page: '1',
        limit: '10',
        category: 'Technology',
        status: 'upcoming',
      };

      Event.find = jest.fn().mockReturnValue({
        sort: jest.fn().mockReturnValue({
          skip: jest.fn().mockReturnValue({
            limit: jest.fn().mockResolvedValue(mockEvents),
          }),
        }),
      });

      Event.countDocuments = jest.fn().mockResolvedValue(2);

      // Execute
      await eventController.getAllEvents(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.find).toHaveBeenCalledWith({
        category: 'Technology',
        status: 'upcoming',
      });
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith({
        events: mockEvents,
        pagination: {
          currentPage: 1,
          totalPages: 1,
          totalEvents: 2,
          hasNext: false,
          hasPrev: false,
        },
      });
    });

    it('should handle database errors', async () => {
      mockReq.query = {};

      Event.find = jest.fn().mockRejectedValue(new Error('Database error'));

      // Execute
      await eventController.getAllEvents(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(500);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'Server error fetching events.',
      });
    });
  });

  describe('getEventById', () => {
    it('should return event by ID successfully', async () => {
      const mockEvent = {
        _id: 'event123',
        title: 'Test Event',
        description: 'Test Description',
        hostId: 'host123',
        status: 'upcoming',
      };

      mockReq.params = { id: 'event123' };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.getEventById(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.findById).toHaveBeenCalledWith('event123');
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith(mockEvent);
    });

    it('should return 404 if event not found', async () => {
      mockReq.params = { id: 'nonexistent' };

      Event.findById = jest.fn().mockResolvedValue(null);

      // Execute
      await eventController.getEventById(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(404);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'Event not found',
      });
    });
  });

  describe('updateEvent', () => {
    it('should update event successfully', async () => {
      const updateData = {
        title: 'Updated Event Title',
        description: 'Updated Description',
      };

      mockReq.body = updateData;
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'host123' };

      const mockEvent = {
        _id: 'event123',
        title: 'Original Title',
        description: 'Original Description',
        hostId: 'host123',
        save: jest.fn().mockResolvedValue(true),
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.updateEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.findById).toHaveBeenCalledWith('event123');
      expect(mockEvent.title).toBe('Updated Event Title');
      expect(mockEvent.description).toBe('Updated Description');
      expect(mockEvent.save).toHaveBeenCalled();
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith({
        message: 'Event updated successfully',
        event: mockEvent,
      });
    });

    it('should return 403 if user is not the host', async () => {
      mockReq.body = { title: 'Updated Title' };
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'otheruser' };

      const mockEvent = {
        _id: 'event123',
        hostId: 'host123',
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.updateEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(403);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'Only the event host can update this event',
      });
    });
  });

  describe('deleteEvent', () => {
    it('should delete event successfully', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'host123' };

      const mockEvent = {
        _id: 'event123',
        hostId: 'host123',
        remove: jest.fn().mockResolvedValue(true),
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.deleteEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.findById).toHaveBeenCalledWith('event123');
      expect(mockEvent.remove).toHaveBeenCalled();
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith({
        message: 'Event deleted successfully',
      });
    });
  });

  describe('joinEvent', () => {
    it('should join event successfully', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'user123' };

      const mockEvent = {
        _id: 'event123',
        title: 'Test Event',
        participants: [],
        maxParticipants: 50,
        save: jest.fn().mockResolvedValue(true),
      };

      const mockUser = {
        _id: 'user123',
        name: 'Test User',
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);
      User.findById = jest.fn().mockResolvedValue(mockUser);
      EventParticipationLog.create = jest.fn().mockResolvedValue({});

      // Execute
      await eventController.joinEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.findById).toHaveBeenCalledWith('event123');
      expect(User.findById).toHaveBeenCalledWith('user123');
      expect(mockEvent.participants).toContain('user123');
      expect(mockEvent.save).toHaveBeenCalled();
      expect(EventParticipationLog.create).toHaveBeenCalledWith({
        eventId: 'event123',
        userId: 'user123',
        action: 'joined',
      });
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith({
        message: 'Successfully joined the event',
        event: mockEvent,
      });
    });

    it('should return error if event is full', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'user123' };

      const mockEvent = {
        _id: 'event123',
        participants: Array(50).fill('user'),
        maxParticipants: 50,
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.joinEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(400);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'Event is full',
      });
    });

    it('should return error if user already joined', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'user123' };

      const mockEvent = {
        _id: 'event123',
        participants: ['user123'],
        maxParticipants: 50,
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.joinEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(400);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'You have already joined this event',
      });
    });
  });

  describe('leaveEvent', () => {
    it('should leave event successfully', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'user123' };

      const mockEvent = {
        _id: 'event123',
        participants: ['user123', 'user456'],
        save: jest.fn().mockResolvedValue(true),
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);
      EventParticipationLog.create = jest.fn().mockResolvedValue({});

      // Execute
      await eventController.leaveEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(Event.findById).toHaveBeenCalledWith('event123');
      expect(mockEvent.participants).not.toContain('user123');
      expect(mockEvent.save).toHaveBeenCalled();
      expect(EventParticipationLog.create).toHaveBeenCalledWith({
        eventId: 'event123',
        userId: 'user123',
        action: 'left',
      });
      expect(mockRes.status).toHaveBeenCalledWith(200);
      expect(mockRes.json).toHaveBeenCalledWith({
        message: 'Successfully left the event',
        event: mockEvent,
      });
    });

    it('should return error if user not in event', async () => {
      mockReq.params = { id: 'event123' };
      mockReq.user = { userId: 'user123' };

      const mockEvent = {
        _id: 'event123',
        participants: ['user456'],
      };

      Event.findById = jest.fn().mockResolvedValue(mockEvent);

      // Execute
      await eventController.leaveEvent(mockReq, mockRes, mockNext);

      // Assertions
      expect(mockRes.status).toHaveBeenCalledWith(400);
      expect(mockRes.json).toHaveBeenCalledWith({
        error: 'You are not part of this event',
      });
    });
  });
});