using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using Server.Controller.v1;
using Server.Dto.Request;
using Server.Dto.Response;
using Server.IServices;
using Shared.Criteria;

namespace TestAPI.ControllerTests
{
    public class EventTest
    {
        private readonly ILogger<EventsController> _loggerMock = Mock.Of<ILogger<EventsController>>();
        private readonly Mock<IEventsService> _servicesMock = new Mock<IEventsService>();

        [Fact]
        public async Task GetEvents()
        {
            // Arrange
            var expectedEvents = new List<ResponseEventDto>
            {
                new ResponseEventDto { Id = "1", Title = "Event 1" },
                new ResponseEventDto { Id = "2", Title = "Event 2" }
            };
            _servicesMock.Setup(s => s.GetEvents(null, 0, 10, EventOrderCriteria.Date, true))
                         .ReturnsAsync((expectedEvents.Count, expectedEvents));

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = await eventsController.GetEvents(null, 0, 10);

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);
            var eventList = Assert.IsAssignableFrom<IEnumerable<ResponseEventDto>>(okResult.Value);
            Assert.Equal(expectedEvents.Count, eventList.Count());
        }

        [Fact]
        public async Task GetEventById_ValidId()
        {
            // Arrange
            var expectedEvent = new ResponseEventDto { Id = "1", Title = "Event 1" };
            _servicesMock.Setup(s => s.GetEventById("1")).ReturnsAsync(expectedEvent);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.GetEventById("1");

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);
            var eventItem = Assert.IsType<ResponseEventDto>(okResult.Value);
            Assert.Equal(expectedEvent.Id, eventItem.Id);
            Assert.Equal(expectedEvent.Title, eventItem.Title);
        }

        [Fact]
        public async Task GetEventById_InvalidId()
        {
            // Arrange
            _servicesMock.Setup(s => s.GetEventById("InvalidId")).ReturnsAsync((ResponseEventDto?)null);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.GetEventById("InvalidId");

            // Assert
            Assert.IsType<NotFoundResult>(result);
        }

        [Fact]
        public async Task CreateEvent()
        {
            // Arrange
            var newEvent = new RequestEventDto
            {
                AlumniId = "A1",
                Title = "New Event",
                Description = "Description",
                Date = DateTime.Now,
                nbMaxRegistrations = 100
            };
            var expectedEvent = new ResponseEventDto { Id = "3", Title = "New Event" };
            _servicesMock.Setup(s => s.CreateEvent(newEvent)).ReturnsAsync(expectedEvent);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.CreateEvent(newEvent);

            // Assert
            var createdAtResult = Assert.IsType<CreatedAtActionResult>(result);
            var createdEvent = Assert.IsType<ResponseEventDto>(createdAtResult.Value);
            Assert.Equal(expectedEvent.Id, createdEvent.Id);
            Assert.Equal(expectedEvent.Title, createdEvent.Title);
        }

        [Fact]
        public async Task UpdateEvent_ValidId()
        {
            // Arrange
            var updatedEvent = new RequestEventDto
            {
                Title = "Updated Event",
                Description = "Updated Description",
                Date = DateTime.Now.AddDays(1),
                nbMaxRegistrations = 200
            };
            var expectedEvent = new ResponseEventDto { Id = "1", Title = "Updated Event" };
            _servicesMock.Setup(s => s.UpdateEvent("1", updatedEvent)).ReturnsAsync(expectedEvent);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.UpdateEvent("1", updatedEvent);

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);
            var updatedEventResult = Assert.IsType<ResponseEventDto>(okResult.Value);
            Assert.Equal(expectedEvent.Id, updatedEventResult.Id);
            Assert.Equal(expectedEvent.Title, updatedEventResult.Title);
        }

        [Fact]
        public async Task UpdateEvent_InvalidId()
        {
            // Arrange
            var updatedEvent = new RequestEventDto
            {
                Title = "Updated Event",
                Description = "Updated Description",
                Date = DateTime.Now.AddDays(1),
                nbMaxRegistrations = 200
            };
            _servicesMock.Setup(s => s.UpdateEvent("InvalidId", updatedEvent)).ReturnsAsync((ResponseEventDto?)null);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.UpdateEvent("InvalidId", updatedEvent);

            // Assert
            Assert.IsType<BadRequestResult>(result);
        }

        [Fact]
        public async Task DeleteEvent_ValidId()
        {
            // Arrange
            _servicesMock.Setup(s => s.DeleteEvent("1")).ReturnsAsync(true);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.DeleteEvent("1");

            // Assert
            Assert.IsType<OkResult>(result);
        }

        [Fact]
        public async Task DeleteEvent_InvalidId()
        {
            // Arrange
            _servicesMock.Setup(s => s.DeleteEvent("InvalidId")).ReturnsAsync(false);

            var eventsController = new EventsController(_loggerMock, _servicesMock.Object);

            // Act
            var result = eventsController.DeleteEvent("InvalidId");

            // Assert
            Assert.IsType<NotFoundResult>(result);
        }
    }
}