using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.Extensions.Logging;
using Moq;
using MoreLinq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Biz.Configuration;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.DbContexts.Snowflake;
using Strata.ContinuousImprovement.Biz.Exploration;
using Strata.ContinuousImprovement.Biz.Exploration.CaseTypeFamilies;
using Strata.ContinuousImprovement.Biz.Exploration.Filters;
using Strata.ContinuousImprovement.Biz.FiscalMonths;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.ContinuousImprovement.Biz.Utilities;
using Strata.ContinuousImprovement.JazzEntityFrameworkStub;
using Strata.SqlTools.Configuration.Common.AsyncFactory;
using Strata.StrataSphereCompare.Client;
using Strata.StrataSphereCompare.Client.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using VerifyNUnit;
using VerifyTests;
using static Strata.ContinuousImprovement.Biz.Exploration.ExplorationService;
using ExplorationFilter = Strata.ContinuousImprovement.Biz.Exploration.Filters.Filter;

namespace Strata.ContinuousImprovement.Biz.Test.Unit.Exploration
{
    [TestFixture, Category("Unit")]
    public class ExplorationServiceTest
    {
        private const string SourceFilePath = @"Exploration/source/";

        public IAsyncDbContextFactory<JazzDbContext> DbContextFactory { get; set; }
        public JazzEntityFrameworkFactory JAZZ_Framework { get; set; }
        public JazzDbContext JazzDbContext { get; set; }
        public ISqlGridReaderWrapper SqlGridReader { get; set; }
        public ISnowflakeDatabaseContext SnowflakeDatabaseContext { get; set; }
        public IConfigurationService ConfigurationService { get; set; }
        public IFiscalMonthResolver FiscalMonthResolver { get; set; }
        public ILogger<ExplorationService> Logger { get; set; }
        public VerifySettings VerifySettings { get; set; }
        public IFeatureFlagWrapper FeatureFlagWrapper { get; set; }
        public IStrataSphereCompareService StrataSphereCompareService { get; set; }
        public IExplorationFilterService ExplorationFilterService { get; set; }

        [OneTimeSetUp]
        public void ExplorationServiceTestOneTimeSetUp()
        {
            DbContextFactory = Mock.Of<IAsyncDbContextFactory<JazzDbContext>>();
            JAZZ_Framework = new JazzEntityFrameworkFactory();

            Mock.Get(DbContextFactory)
                .Setup(s => s.CreateDbContextAsync(It.IsAny<CancellationToken>()))
                .Returns(async () =>
                {
                    JazzDbContext = await JAZZ_Framework.CreateDbContextAsync(CancellationToken.None);
                    return JazzDbContext;
                });

            SqlGridReader = Mock.Of<ISqlGridReaderWrapper>();
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read(It.IsAny<bool>()))
                .Returns(Enumerable.Empty<dynamic>());
            SnowflakeDatabaseContext = Mock.Of<ISnowflakeDatabaseContext>();
            Mock.Get(SnowflakeDatabaseContext)
                .Setup(s => s.QueryMultipleAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<object>(), It.IsAny<TimeSpan>()))
                .Returns(Task.FromResult(SqlGridReader));

            ConfigurationService = Mock.Of<IConfigurationService>();
            FiscalMonthResolver = Mock.Of<IFiscalMonthResolver>();
            Logger = Mock.Of<ILogger<ExplorationService>>();
            VerifySettings = TestExtensions.TestSettings();
            FeatureFlagWrapper = Mock.Of<IFeatureFlagWrapper>();
            StrataSphereCompareService = Mock.Of<IStrataSphereCompareService>();
            ExplorationFilterService = Mock.Of<IExplorationFilterService>();

            // Setup the mock to return empty results
            Mock.Get(ExplorationFilterService)
                .Setup(s => s.GetFilterStringsAsync(It.IsAny<IEnumerable<FilterChipItem>>(), It.IsAny<IQueryParamBase>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(("", ""));
            Mock.Get(ExplorationFilterService)
                .Setup(s => s.BuildDataFiltersAsync(It.IsAny<CaseTypeFamily>(), It.IsAny<string>(), It.IsAny<ExplorationFilter>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(new CostDetailsFilterDto());
            Mock.Get(ExplorationFilterService)
                .Setup(s => s.CreateCostDriverFilter())
                .Returns(new FilterChipItem());
            Mock.Get(FeatureFlagWrapper)
                .Setup(f => f.IsCiBenchmarkingEnabled(It.IsAny<bool>()))
                .ReturnsAsync(true);


        }

        [TestCaseSource(nameof(GetCaseTypeFamilyDetailsTestCases))]
        public async Task GetCaseTypeFamilyDetailsTest(GetCaseTypeFamilyDetailsTestData data)
        {
            // arrange
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<CTFGroupCalcs>(It.IsAny<bool>()))
                .Returns(data.CTFGroupCalcsList);
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<EntityGroupCalcs>(It.IsAny<bool>()))
                .Returns(data.EntityGroupCalcsList);
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<EntityCodeGroupCalcs>(It.IsAny<bool>()))
                .Returns(data.EntityCodeGroupCalcsList);
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<EntityCodePhysicianGroupCalcs>(It.IsAny<bool>()))
                .Returns(data.EntityCodePhysicianGroupCalcsList);
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<CTFEncounterDetail>(It.IsAny<bool>()))
                .Returns(data.CTFEncounterDetailList);

            var explorationService = new ExplorationService(
                DbContextFactory,
                SnowflakeDatabaseContext,
                FiscalMonthResolver,
                FeatureFlagWrapper,
                StrataSphereCompareService,
                ExplorationFilterService,
                Logger);

            // act
            var taskResult = await explorationService.GetCaseTypeFamilyDetailsAsync(data.ExplorationDetailInfoData, CancellationToken.None);

            // assert
            await Verifier.Verify(taskResult, VerifySettings)
                .UseFileName(TestContext.CurrentContext.TestName());
        }

        [TestCaseSource(nameof(GetEncountersTestCases))]
        public async Task GetEncountersTest(GetEncountersTestData data)
        {
            // arrange
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<PhysicianInfo>(It.IsAny<bool>()))
                .Returns(data.PhysicianInfoList);
            Mock.Get(SqlGridReader)
                .Setup(s => s.Read<EncounterInfoBase>(It.IsAny<bool>()))
                .Returns(data.EncounterInfoBaseList);
            var configurationGuid = Guid.Empty;

            var explorationService = new ExplorationService(
                DbContextFactory,
                SnowflakeDatabaseContext,
                FiscalMonthResolver,
                FeatureFlagWrapper,
                StrataSphereCompareService,
                ExplorationFilterService,
                Logger);

            // act
            var taskResult = await explorationService.GetEncountersAsync(data.ExplorationDetailInfoData, configurationGuid, CancellationToken.None);

            // assert
            await Verifier.Verify(taskResult, VerifySettings)
                .UseFileName(TestContext.CurrentContext.TestName());
        }

        private static IEnumerable<TestCaseData> GetCaseTypeFamilyDetailsTestCases()
        {
            var testName = "GetCaseTypeFamilyDetailsTest";

            var explorationDetailInfoDataJson = GetSourceFile("ExplorationDetailInfo.txt");
            var ctfGroupCalcsListJson = GetSourceFile("CTFGroupCalcs.txt");
            var entityGroupCalcsListJson = GetSourceFile("EntityGroupCalcs.txt");
            var entityCodeGroupCalcsListJson = GetSourceFile("EntityCodeGroupCalcs.txt");
            var entityCodePhysicianGroupCalcsListJson = GetSourceFile("EntityCodePhysicianGroupCalcs.txt");
            var ctfEncounterDetailListJson = GetSourceFile("CTFEncounterDetail.txt");

            var dataAllMatch = new GetCaseTypeFamilyDetailsTestData()
            {
                ExplorationDetailInfoData = JsonSerializer.Deserialize<ExplorationDetailInfo>(explorationDetailInfoDataJson),
                CTFGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<CTFGroupCalcs>>(ctfGroupCalcsListJson),
                EntityGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityGroupCalcs>>(entityGroupCalcsListJson),
                EntityCodeGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityCodeGroupCalcs>>(entityCodeGroupCalcsListJson),
                EntityCodePhysicianGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityCodePhysicianGroupCalcs>>(entityCodePhysicianGroupCalcsListJson),
                CTFEncounterDetailList = JsonSerializer.Deserialize<IEnumerable<CTFEncounterDetail>>(ctfEncounterDetailListJson)
            };
            dataAllMatch.ExplorationDetailInfoData.Filters = new ExplorationFilter() // FIXED: Changed from Biz.Exploration.Filters.Filter to ExplorationFilter
            {
                FilterChipItems = new List<FilterChipItem>()
                {
                    new FilterChipItem {
                        ChipType = ChipType.DateRange, Key = ChipKey.DischargeDateID,
                        DateRange = new List<DateTime>()
                        {
                            new DateTime(2024, 1, 1),
                            new DateTime(2024, 12, 31)
                        }
                    }
                }
            };
            yield return new TestCaseData(dataAllMatch)
                .SetName($"{testName} All Match");

            var dataPhysicianIdNotMatch = new GetCaseTypeFamilyDetailsTestData()
            {
                ExplorationDetailInfoData = dataAllMatch.ExplorationDetailInfoData,
                CTFGroupCalcsList = dataAllMatch.CTFGroupCalcsList,
                EntityGroupCalcsList = dataAllMatch.EntityGroupCalcsList,
                EntityCodeGroupCalcsList = dataAllMatch.EntityCodeGroupCalcsList,
                EntityCodePhysicianGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityCodePhysicianGroupCalcs>>(entityCodePhysicianGroupCalcsListJson),
                CTFEncounterDetailList = dataAllMatch.CTFEncounterDetailList
            };
            dataPhysicianIdNotMatch.EntityCodePhysicianGroupCalcsList.First().PhysicianId = 0;
            yield return new TestCaseData(dataPhysicianIdNotMatch)
                .SetName($"{testName} PhysicianId Not Match");

            var dataCodeNotMatch = new GetCaseTypeFamilyDetailsTestData()
            {
                ExplorationDetailInfoData = dataAllMatch.ExplorationDetailInfoData,
                CTFGroupCalcsList = dataAllMatch.CTFGroupCalcsList,
                EntityGroupCalcsList = dataAllMatch.EntityGroupCalcsList,
                EntityCodeGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityCodeGroupCalcs>>(entityCodeGroupCalcsListJson),
                EntityCodePhysicianGroupCalcsList = dataAllMatch.EntityCodePhysicianGroupCalcsList,
                CTFEncounterDetailList = dataAllMatch.CTFEncounterDetailList
            };
            dataCodeNotMatch.EntityCodeGroupCalcsList.First().Code = "";
            yield return new TestCaseData(dataCodeNotMatch)
                .SetName($"{testName} Code Not Match");

            var dataEntityNotMatch = new GetCaseTypeFamilyDetailsTestData()
            {
                ExplorationDetailInfoData = dataAllMatch.ExplorationDetailInfoData,
                CTFGroupCalcsList = dataAllMatch.CTFGroupCalcsList,
                EntityGroupCalcsList = JsonSerializer.Deserialize<IEnumerable<EntityGroupCalcs>>(entityGroupCalcsListJson),
                EntityCodeGroupCalcsList = dataAllMatch.EntityCodeGroupCalcsList,
                EntityCodePhysicianGroupCalcsList = dataAllMatch.EntityCodePhysicianGroupCalcsList,
                CTFEncounterDetailList = dataAllMatch.CTFEncounterDetailList
            };
            dataEntityNotMatch.EntityGroupCalcsList.First().EntityId = 0;
            yield return new TestCaseData(dataEntityNotMatch)
                .SetName($"{testName} Entity Not Match");
        }

        private static IEnumerable<TestCaseData> GetEncountersTestCases()
        {
            var testName = "GetEncountersTest";

            var explorationDetailInfoDataJson = GetSourceFile("ExplorationDetailInfo.txt");
            var physicianInfoJson = GetSourceFile("PhysicianInfo.txt");
            var encounterInfoBaseJson = GetSourceFile("EncounterInfoBase.txt");

            var dataAllMatch = new GetEncountersTestData()
            {
                ExplorationDetailInfoData = JsonSerializer.Deserialize<ExplorationDetailInfo>(explorationDetailInfoDataJson),
                PhysicianInfoList = JsonSerializer.Deserialize<IEnumerable<PhysicianInfo>>(physicianInfoJson),
                EncounterInfoBaseList = JsonSerializer.Deserialize<IEnumerable<EncounterInfoBase>>(encounterInfoBaseJson)
            };

            dataAllMatch.ExplorationDetailInfoData.Filters = new ExplorationFilter() // FIXED: Changed from Biz.Exploration.Filters.Filter to ExplorationFilter
            {
                FilterChipItems = new List<FilterChipItem>()
                {
                    new FilterChipItem {
                        ChipType = ChipType.DateRange, Key = ChipKey.DischargeDateID,
                        DateRange = new List<DateTime>()
                        {
                            new DateTime(2024, 1, 1),
                            new DateTime(2024, 12, 31)
                        }
                    }
                }
            };
            yield return new TestCaseData(dataAllMatch)
                .SetName($"{testName} All Match");

            var dataPhysicianIdNotMatch = new GetEncountersTestData()
            {
                ExplorationDetailInfoData = dataAllMatch.ExplorationDetailInfoData,
                PhysicianInfoList = JsonSerializer.Deserialize<IEnumerable<PhysicianInfo>>(physicianInfoJson),
                EncounterInfoBaseList = dataAllMatch.EncounterInfoBaseList,
            };
            dataPhysicianIdNotMatch.PhysicianInfoList.First().PhysicianID = 0;
            yield return new TestCaseData(dataPhysicianIdNotMatch)
                .SetName($"{testName} PhysicianId Not Match");
        }

        private static string GetSourceFile(string file)
        {
            string filePath = Path.Combine(TestHelper.TestsRootDirectory, SourceFilePath, file);
            string jsonData = File.ReadAllText(filePath);
            return jsonData;
        }

        public class GetCaseTypeFamilySummariesTestData
        {
            public ExplorationInfo ExplorationInfoData { get; set; }
            public IEnumerable<CaseTypeFamilyEncounterInfo> CaseTypeFamilyEncounterInfoList { get; set; }

        }

        public class GetCaseTypeFamilyDetailsTestData
        {
            public ExplorationDetailInfo ExplorationDetailInfoData { get; set; }
            public IEnumerable<CTFGroupCalcs> CTFGroupCalcsList { get; set; }
            public IEnumerable<EntityGroupCalcs> EntityGroupCalcsList { get; set; }
            public IEnumerable<EntityCodeGroupCalcs> EntityCodeGroupCalcsList { get; set; }
            public IEnumerable<EntityCodePhysicianGroupCalcs> EntityCodePhysicianGroupCalcsList { get; set; }
            public IEnumerable<CTFEncounterDetail> CTFEncounterDetailList { get; set; }
        }

        public class GetEncountersTestData
        {
            public ExplorationDetailInfo ExplorationDetailInfoData { get; set; }
            public IEnumerable<PhysicianInfo> PhysicianInfoList { get; set; }
            public IEnumerable<EncounterInfoBase> EncounterInfoBaseList { get; set; }
        }
    }
}