using adas_core.Application.Repositories.Interfaces;
using adas_core.Application.Services;
using adas_core.Application.Services.Interfaces;
using adas_core.Domain.Models.AppSettings;
using adas_core.Domain.Models.GroupedObservations;
using adas_core.Domain.Utils;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MongoDB.Bson;
using Moq;
using static adas_core.Domain.Enums.GroupedObservationEnum;

namespace adas_core.Test.Services;

[TestFixture]
public class GroupedObservationServiceTest
{
    [SetUp]
    public void Setup()
    {
        var configObservationService = new Mock<IConfigObservationService>();
        var observationRepository = new Mock<IObservationRepository>();

        _logger = new Mock<ILogger<GroupedObservationService>>();

        _groupedObservationService = new GroupedObservationService(
            observationRepository.Object, configObservationService.Object,
            _logger.Object, Mock.Of<ICacheService>(), Options.Create(new ApiSettings()), Options.Create(new CacheSettings()));
    }

    private GroupedObservationService _groupedObservationService;
    private Mock<ILogger<GroupedObservationService>> _logger;


    [Test]
    public void Generate_Shift_Observations()
    {
        var dateTime = DateTime.Now;
        if (dateTime.Day <= 2) dateTime = dateTime.AddDays(2);

        var result = new List<BsonDocument>
        {
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 12, 30, "FC", 100, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 10, 30, "FC", 108, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 9, 30, "FC", 106, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 5, 30, "FC", 112, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 4, 30, "FC", 105, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 23, 30, "FC", 190, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 19, 30, "FC", 120, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 15, 30, "FC", 130, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 12, 30, "FC", 140, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 09, 30, "FC", 150, Result.Last, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 2, 15, 30, "FC", 150, Result.Last, null)
        };

        var groupedField = new GroupedField
        {
            StartTimeShift = ["08:00", "15:00", "22:00"],
            Max = 36,
            Result = [Result.Last]
        };

        var shiftObservations = _groupedObservationService.GenerateShiftObservations(result, groupedField);

        var shift1ObsToday = shiftObservations.Count(s => s.Get("shift") == 0 && s.Get("day") == dateTime.Day);

        var shift1ObsYesterday = shiftObservations.Count(s => s.Get("shift") == 0 && s.Get("day") == dateTime.Day - 1);

        var shift2ObsYesterday = shiftObservations.Count(s => s.Get("shift") == 1 && s.Get("day") == dateTime.Day - 1);

        var shif3ObsYesterday = shiftObservations.Count(s => s.Get("shift") == 2 && s.Get("day") == dateTime.Day - 1);

        var shiftTwoDaysAgo = shiftObservations.Count(s => s.Get("shift") == 1 && s.Get("day") == dateTime.Day - 2);
        using (Assert.EnterMultipleScope())
        {
            Assert.That(shift1ObsToday, Is.EqualTo(3));
            Assert.That(shif3ObsYesterday, Is.EqualTo(3));
            Assert.That(shift2ObsYesterday, Is.EqualTo(2));
            Assert.That(shift1ObsYesterday, Is.EqualTo(2));
            Assert.That(shiftTwoDaysAgo, Is.EqualTo(1));
        };
    }

    [Test]
    public void Calculate_Shift_Observations()
    {
        var dateTime = DateTime.Now;

        if (dateTime.Day <= 2) dateTime = dateTime.AddDays(2);


        var groupedField = new GroupedField
        {
            StartTimeShift = ["08:00", "15:00", "22:00"],
            Max = 36,
            Result = [Result.Sum]
        };

        var result = new List<BsonDocument>
        {
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 12, 30, "FC", 100, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 10, 30, "FC", 108, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 9, 30, "FC", 106, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 5, 30, "FC", 112, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 4, 30, "FC", 105, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 23, 30, "FC", 190, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 19, 30, "FC", 120, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 15, 30, "FC", 130, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 12, 30, "FC", 140, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 1, 09, 30, "FC", 150, Result.Sum, null),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day - 2, 15, 30, "FC", 150, Result.Sum, null)
        };


        var shiftObservations = _groupedObservationService.GenerateShiftObservations(result, groupedField);

        _groupedObservationService.CalculateShiftObservations(shiftObservations, groupedField);
        var shift1ObsToday = shiftObservations.First(s => s.Get("shift") == 0 && s.Get("day") == dateTime.Day);
        var shift1ObsYesterday = shiftObservations.First(s => s.Get("shift") == 0 && s.Get("day") == dateTime.Day - 1);

        var shift2ObsYesterday = shiftObservations.First(s => s.Get("shift") == 1 && s.Get("day") == dateTime.Day - 1);

        var shif3ObsYesterday = shiftObservations.First(s => s.Get("shift") == 2 && s.Get("day") == dateTime.Day - 1);

        var shiftTwoDaysAgo = shiftObservations.First(s => s.Get("shift") == 1 && s.Get("day") == dateTime.Day - 2);
        using (Assert.EnterMultipleScope())
        {
            Assert.That(shift1ObsToday.Get("sum")?.ToInt32(), Is.EqualTo(314));
            Assert.That(shif3ObsYesterday.Get("sum")?.ToInt32(), Is.EqualTo(407));

            Assert.That(shift2ObsYesterday.Get("sum")?.ToInt32(), Is.EqualTo(250));
            Assert.That(shift1ObsYesterday.Get("sum")?.ToInt32(), Is.EqualTo(290));
            Assert.That(shiftTwoDaysAgo.Get("sum")?.ToInt32(), Is.EqualTo(150));
        };
    }

//         [Test]
//         public void Calculate_Half_Time_Observations()
//         {
//             /*
//        09:18 - Toma 1: 50/100/75
//        09:38 - Toma 2: 52/102/76
//        10:07 - Toma 3: 54/101/72
//        10:18 - Toma 4: 51/102/73
//        10:58 - Toma 5: 52/107/79
//        12:04 - Toma 6: 60/120/90
//
//        El api convierte a
//
//        09h - Toma 2: 52/102/76
//        10h - Toma 4: 51/102/73
//        11h - Toma 5: 52/107/79
//        12h- Toma 6: 60/120/90
//    */
//
//
//             var dateTime = DateTime.Now;
//
//             var values9 = new BsonArray {
//                 new BsonDocument
//                 {
//                     { "value", 50},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,9,18,0))},
//
//                 },
//                  new BsonDocument
//                 {
//                     { "value", 100},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,9,38,0))}
//                 }
//             };
//
//             var values10 = new BsonArray {
//                new BsonDocument
//                 {
//                     { "value", 50},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,10,7,0))}
//                 },
//                    new BsonDocument
//                 {
//                     { "value", 60},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,10,18,0))}
//                 },
//                                       new BsonDocument
//                 {
//                     { "value", 70},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,10,58,0))}
//                 }
//             };
//
//             var values11 = new BsonArray
//             {
//
//             };
//
//             var values12 = new BsonArray
//             {
//                      new BsonDocument
//                 {
//                     { "value", 50},
//                     { "time", new BsonDateTime(new DateTime(2021,3,10,12,04,0))}
//                 }
//             };
//
//
//             var result = new List<BsonDocument>()
//             {
//                  GenerateBsonDocument(dateTime.Year,dateTime.Month,dateTime.Day,9,0,"TAM", 100, Result.HalfHour,values9),
//                  GenerateBsonDocument(dateTime.Year,dateTime.Month,dateTime.Day,10,0,"TAM", 100, Result.HalfHour,values10),
//                  GenerateBsonDocument(dateTime.Year,dateTime.Month,dateTime.Day,11,0,"TAM", 100, Result.HalfHour,values11),
//                  GenerateBsonDocument(dateTime.Year,dateTime.Month,dateTime.Day,12,0,"TAM", 100, Result.HalfHour,values12)
//             };
//
//             var halfObservations = _groupedObservationService.CalculateHalfHourObservations(result);
//
//             Assert.That(halfObservations, Has.Count.EqualTo(4));
//             Assert.Multiple(() =>
//             {
//                 Assert.That(halfObservations[0].GetByCodeSysAndCode("halfhour")?.AsBsonDocument.GetByCodeSysAndCode("value")?.AsInt32, Is.EqualTo(100));
//                 Assert.That(halfObservations[1].GetByCodeSysAndCode("halfhour")?.AsBsonDocument.GetByCodeSysAndCode("value")?.AsInt32, Is.EqualTo(60));
//                 Assert.That(halfObservations[2].GetByCodeSysAndCode("halfhour")?.AsBsonDocument.GetByCodeSysAndCode("value")?.AsInt32, Is.EqualTo(70));
//                 Assert.That(halfObservations[3].GetByCodeSysAndCode("halfhour")?.AsBsonDocument.GetByCodeSysAndCode("value")?.AsInt32, Is.EqualTo(50));
//             });
//         }

    [Test]
    public async Task Calculate_Last_Filled_Observations_should_add_Minus_4_hour_to_complete_last_five_hours()
    {
        var dateTime = DateTime.Now;

        //Falta el -4 tiene que crearlo el calculate last filled observation
        var result = new List<BsonDocument>
        {
            GenerateBsonDocument(dateTime.AddHours(-5).Year, dateTime.AddHours(-5).Month, dateTime.AddHours(-5).Day,
                dateTime.AddHours(-5).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-3).Year, dateTime.AddHours(-3).Month, dateTime.AddHours(-3).Day,
                dateTime.AddHours(-3).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-2).Year, dateTime.AddHours(-2).Month, dateTime.AddHours(-2).Day,
                dateTime.AddHours(-2).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-1).Year, dateTime.AddHours(-1).Month, dateTime.AddHours(-1).Day,
                dateTime.AddHours(-1).Hour, 0, "TAM", 100, Result.LastFilled, null)
        };


        var groupedField = new GroupedField
        {
            Max = 5,
            Name = "TAM",
            Regularity = Regularity.Hour
        };
        var patientId = ObjectId.GenerateNewId();

        var lastFilledObservations =
            await _groupedObservationService.CalculateLastFilledObservations(result, groupedField, patientId);
        using (Assert.EnterMultipleScope())
        {
            Assert.That(lastFilledObservations, Has.Count.EqualTo(5));
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-5).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-4).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-3).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-2).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-1).Hour),
                Is.True);
        };
    }

    [Test]
    public async Task Calculate_Last_Filled_Observations_should_add_Minus_1_hour_to_complete_last_five_hours()
    {
        var dateTime = DateTime.Now;

        //Falta el -4 tiene que crearlo el calculate last filled observation
        var result = new List<BsonDocument>
        {
            GenerateBsonDocument(dateTime.AddHours(-5).Year, dateTime.AddHours(-5).Month, dateTime.AddHours(-5).Day,
                dateTime.AddHours(-5).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-4).Year, dateTime.AddHours(-4).Month, dateTime.AddHours(-4).Day,
                dateTime.AddHours(-4).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-3).Year, dateTime.AddHours(-3).Month, dateTime.AddHours(-3).Day,
                dateTime.AddHours(-3).Hour, 0, "TAM", 100, Result.LastFilled, null),
            GenerateBsonDocument(dateTime.AddHours(-2).Year, dateTime.AddHours(-2).Month, dateTime.AddHours(-2).Day,
                dateTime.AddHours(-2).Hour, 0, "TAM", 100, Result.LastFilled, null)
        };


        var groupedField = new GroupedField
        {
            Max = 5,
            Name = "TAM",
            Regularity = Regularity.Hour
        };
        var patientId = ObjectId.GenerateNewId();

        var lastFilledObservations =
            await _groupedObservationService.CalculateLastFilledObservations(result, groupedField, patientId);
        using (Assert.EnterMultipleScope())
        {
            Assert.That(lastFilledObservations, Has.Count.EqualTo(5));
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-5).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-4).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-3).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-2).Hour),
                Is.True);
            Assert.That(
                lastFilledObservations.Exists(i => i.Get("time")?.ToLocalTime().Hour == dateTime.AddHours(-1).Hour),
                Is.True);
        };
    }

    [Test]
    public void FillHoursObservations()
    {
        /*
            09:18 - Toma 1: 50/100/75
            09:38 - Toma 2: 52/102/76
            10:07 - Toma 3: 54/101/72
            10:18 - Toma 4: 51/102/73
            10:58 - Toma 5: 52/107/79
            12:04 - Toma 6: 60/120/90

            El api convierte a

            09h - Toma 2: 52/102/76
            10h - Toma 4: 51/102/73
            11h - Toma 5: 52/107/79
            12h- Toma 6: 60/120/90
        */

        var groupedField = new GroupedField
        {
            Max = 5,
            Name = "TAM",
            Regularity = Regularity.Hour
        };


        var dateTime =
            new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 12, 30, 0).ToUniversalTime();

        var values9 = new BsonArray
        {
            new BsonDocument
            {
                { "value", 50 },
                {
                    "time",
                    new BsonDateTime(
                        new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 9, 18, 0).ToUniversalTime())
                }
            },
            new BsonDocument
            {
                { "value", 100 },
                {
                    "time",
                    new BsonDateTime(
                        new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 9, 38, 0).ToUniversalTime())
                }
            }
        };

        var values10 = new BsonArray
        {
            new BsonDocument
            {
                { "value", 50 },
                {
                    "time",
                    new BsonDateTime(
                        new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 10, 7, 0).ToUniversalTime())
                }
            },
            new BsonDocument
            {
                { "value", 60 },
                {
                    "time",
                    new BsonDateTime(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 10, 18, 0)
                        .ToUniversalTime())
                }
            },
            new BsonDocument
            {
                { "value", 70 },
                {
                    "time",
                    new BsonDateTime(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 10, 58, 0)
                        .ToUniversalTime())
                }
            }
        };

        var values12 = new BsonArray
        {
            new BsonDocument
            {
                { "value", 50 },
                {
                    "time",
                    new BsonDateTime(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 12, 04, 0)
                        .ToUniversalTime())
                }
            }
        };


        var result = new List<BsonDocument>
        {
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 9, 0, "TAM", 100, Result.HalfHour,
                values9),
            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 10, 0, "TAM", 100, Result.HalfHour,
                values10),

            GenerateBsonDocument(dateTime.Year, dateTime.Month, dateTime.Day, 12, 0, "TAM", 100, Result.HalfHour,
                values12)
        };

        var halfObservations = _groupedObservationService.CalculateHalfHourObservations(result);

        var fillHoursObservations = _groupedObservationService.FillHours(halfObservations, groupedField);


        Assert.That(fillHoursObservations, Is.Not.Empty);
    }


    private static BsonDocument GenerateBsonDocument(int? year, int? month, int? day, int? hour, int? minute,
        string name, object value, Result resultType, BsonArray? all)
    {
        var result = new BsonDocument
        {
            {
                "_id", new BsonDocument
                {
                    { "year", year ?? new DateTime().Year },
                    { "month", month ?? new DateTime().Month },
                    { "day", day ?? new DateTime().Day },
                    { "hour", hour ?? new DateTime().Hour },
                    { "minute", minute ?? new DateTime().Minute },
                    { "name", name }
                }
            },
            { "time", new BsonDateTime(new DateTime((int)year!, (int)month!, (int)day!, (int)hour!, (int)minute!, 0)) }
        };


        /*
        {resultType.ToString().ToLower(), new BsonDocument{
            {"time", new BsonDateTime(new System.DateTime((int)year, (int)month, (int)day, (int)hour, (int)minute,0)) },
            {"value",  value.ToString() }
        }},
        { "time", new BsonDateTime(new System.DateTime((int)year, (int)month, (int)day, (int)hour, (int)minute,0)) },

        };
        */

        if (resultType != Result.HalfHour && resultType != Result.Sum && resultType != Result.Count
            && resultType != Result.Min && resultType != Result.Average && resultType != Result.Max)
            result.Add(resultType.ToString().ToLower(), new BsonDocument
            {
                { "time", new BsonDateTime(new DateTime((int)year, (int)month, (int)day, (int)hour, (int)minute, 0)) },
                { "value", value.ToString() }
            });
        else
            result.AddRange(new Dictionary<string, object> { { resultType.ToString().ToLower(), value } });

        if (all != null) result.Add("all", all);

        return result;
    }
}