using APIMappers;
using Dto;
using HeartTrackAPI.Controllers;
using HeartTrackAPI.Request;
using HeartTrackAPI.Responce;
using JetBrains.Annotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Model;
using Model.Manager;
using Model.Repository;
using Moq;
using Shared;
using StubAPI;


namespace UnitTestApi.Controllers
{
    [TestClass]
    public class ActivityControllerTest
    {
        private Mock<IDataManager> _dataManagerMock;
        private ActivityController _activityController;

        private readonly List<Activity> _activities = new List<Activity>
        {
            new Activity { Id = 1, Type = "Running", Date = DateTime.Today, StartTime = DateTime.Now, EndTime = DateTime.Now.AddHours(1), Effort = 3, Variability = 0.5f, Variance = 0.1f, StandardDeviation = 0.2f, Average = 150.5f, Maximum = 180, Minimum = 120, AverageTemperature = 25.5f, HasAutoPause = false },
            new Activity { Id = 2, Type = "Cycling", Date = DateTime.Today, StartTime = DateTime.Now, EndTime = DateTime.Now.AddHours(2), Effort = 4, Variability = 0.6f, Variance = 0.2f, StandardDeviation = 0.3f, Average = 200.5f, Maximum = 220, Minimum = 160, AverageTemperature = 28.5f, HasAutoPause = true },
            new Activity { Id = 3, Type = "Swimming", Date = DateTime.Today, StartTime = DateTime.Now, EndTime = DateTime.Now.AddHours(1.5), Effort = 2, Variability = 0.4f, Variance = 0.05f, StandardDeviation = 0.15f, Average = 120.5f, Maximum = 140, Minimum = 100, AverageTemperature = 20.5f, HasAutoPause = false }
        };

        [TestInitialize]
        public void SetUp()
        {
            _dataManagerMock = new Mock<IDataManager>();

            _dataManagerMock.Setup(dm => dm.ActivityRepo.GetNbItems()).ReturnsAsync(_activities.Count);
            _dataManagerMock.Setup(dm =>
                dm.ActivityRepo.GetActivities(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<ActivityOrderCriteria>(), It.IsAny<bool>()))
                .ReturnsAsync((int index, int count, ActivityOrderCriteria criteria, bool descending) =>
                    _activities.GetItemsWithFilterAndOrdering(c => true, index, count,
                        criteria != ActivityOrderCriteria.None ? criteria : null, descending));

            _activityController = new ActivityController(_dataManagerMock.Object, new NullLogger<ActivityController>());
        }

        [TestMethod]
        public async Task GetActivities_ReturnsPageResponse_WhenRequestIsValid()
        {
            var request = new PageRequest
            {
                Index = 0,
                Count = 3,
                OrderingPropertyName = "Id",
                Descending = false
            };

            var result = await _activityController.GetActivities(request);

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));
            var okResult = result.Result as OkObjectResult;

            Assert.IsNotNull(okResult);
            Assert.IsInstanceOfType(okResult.Value, typeof(PageResponse<ActivityDto>));
            var pageResponse = okResult.Value as PageResponse<ActivityDto>;

            Assert.IsNotNull(pageResponse);
            Assert.AreEqual(3, pageResponse.Total);
            Assert.AreEqual(0, pageResponse.Index);
            Assert.AreEqual(3, pageResponse.Count);
        }

        [TestMethod]
        public async Task PostActivity_ReturnsCreatedAtAction_WhenRequestIsValid()
        {
            var activityDto = new ActivityDto
            {
                Id = 4,
                Type = "Running",
                Date = DateTime.Today,
                StartTime = DateTime.Now,
                EndTime = DateTime.Now.AddHours(1),
                EffortFelt = 3,
                Variability = 0.5f,
                Variance = 0.1f,
                StandardDeviation = 0.2f,
                Average = 150.5f,
                Maximum = 180,
                Minimum = 120,
                AverageTemperature = 25.5f,
                HasAutoPause = false
            };

            _dataManagerMock.Setup(dm => dm.ActivityRepo.AddActivity(It.IsAny<Activity>())).ReturnsAsync(_activities.Last());

            var result = await _activityController.PostActivity(activityDto);

            Assert.IsInstanceOfType(result, typeof(CreatedAtActionResult));
            var createdAtActionResult = result as CreatedAtActionResult;

            Assert.IsNotNull(createdAtActionResult);
            Assert.AreEqual("GetActivity", createdAtActionResult.ActionName);
            Assert.AreEqual(201, createdAtActionResult.StatusCode);
        }


        [TestMethod]
        public async Task GetActivity_ReturnsNotFound_WhenActivityDoesNotExist()
        {
            var id = 1;
            _dataManagerMock.Setup(dm => dm.ActivityRepo.GetActivityByIdAsync(id)).ReturnsAsync((Activity)null);

            var result = await _activityController.GetActivity(id);

            Assert.IsInstanceOfType(result.Result, typeof(NotFoundObjectResult));
            var notFoundResult = result.Result as NotFoundObjectResult;

            Assert.IsNotNull(notFoundResult);
            Assert.AreEqual(404, notFoundResult.StatusCode);
        }

        [TestMethod]
        public async Task GetActivity_ReturnsInternalServerError_WhenExceptionOccurs()
        {
            var id = 1;
            _dataManagerMock.Setup(dm => dm.ActivityRepo.GetActivityByIdAsync(id)).ThrowsAsync(new Exception("Simulated exception"));

            var result = await _activityController.GetActivity(id);

            Assert.IsInstanceOfType(result.Result, typeof(ObjectResult));
            var objectResult = result.Result as ObjectResult;

            Assert.IsNotNull(objectResult);
            Assert.AreEqual(500, objectResult.StatusCode);
        }

        [TestMethod]
        public async Task PutActivity_ReturnsNoContent_WhenRequestIsValid()
        {
            // Créer un exemple d'ActivityDto avec des données factices
            var activityDto = new ActivityDto
            {
                Id = 1,
                Type = "Running",
                Date = DateTime.Today,
                StartTime = DateTime.Now,
                EndTime = DateTime.Now.AddHours(1),
                EffortFelt = 3,
                Variability = 0.5f,
                Variance = 0.1f,
                StandardDeviation = 0.2f,
                Average = 150.5f,
                Maximum = 180,
                Minimum = 120,
                AverageTemperature = 25.5f,
                HasAutoPause = false,
                HeartRates = new List<HeartRateDto>
                {
                    new HeartRateDto
                        {
                            Timestamp = DateTime.Now,
                            Latitude = 40.7128,
                            Longitude = -74.0060,
                            Altitude = 10.5,
                            HeartRate = 120,
                            Cadence = 80,
                            Distance = 5.0,
                            Speed = 10.0,
                            Power = 150,
                            Temperature = 20.0
                        }
                    // Ajoutez d'autres objets HeartRateDto si nécessaire
                }
                    };

            // Configurer le mock pour simuler le comportement de la méthode UpdateActivity
            _dataManagerMock.Setup(dm => dm.ActivityRepo.UpdateActivity(It.IsAny<int>(), It.IsAny<Activity>())).Returns(Task.FromResult(new Model.Activity()));


            // Appeler la méthode à tester
            var result = await _activityController.PutActivity(activityDto.Id, activityDto);

            // Vérifier le résultat
            Assert.IsInstanceOfType(result, typeof(NoContentResult));
        }

        [TestMethod]
        public async Task DeleteActivity_ReturnsOk_WhenRequestIsValid()
        {
            var id = 1;

            _dataManagerMock.Setup(dm => dm.ActivityRepo.GetActivityByIdAsync(id)).ReturnsAsync(_activities.FirstOrDefault(a => a.Id == id));
            _dataManagerMock.Setup(dm => dm.ActivityRepo.DeleteActivity(id)).ReturnsAsync(true);

            var result = await _activityController.DeleteActivity(id);

            Assert.IsInstanceOfType(result, typeof(OkResult));
            var okResult = result as OkResult;

            Assert.IsNotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [TestMethod]
        public async Task DeleteActivity_ReturnsNotFound_WhenActivityDoesNotExist()
        {
            var id = 100;

            _dataManagerMock.Setup(dm => dm.ActivityRepo.GetActivityByIdAsync(id)).ReturnsAsync((Activity)null);

            var result = await _activityController.DeleteActivity(id);

            Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
            var notFoundResult = result as NotFoundObjectResult;

            Assert.IsNotNull(notFoundResult);
            Assert.AreEqual(404, notFoundResult.StatusCode);
        }
    }
}