using Azure.Core;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Data;
using SystemX.Core.DB;
using SystemX.Core.Services;
using Web.Tra.Model;
using WebClient.Library.Config;

namespace Web.Tra.Services
{
    public class CPXV2LogService
    {
        private readonly IServiceScopeFactory _scopeFactory;
        private readonly ConfigService<WebClientConfig>? _configService;

        public CPXV2LogService(IServiceProvider serviceProvider, IServiceScopeFactory scopeFactory, ConfigService<WebClientConfig> configService)
        {
            _scopeFactory = scopeFactory;
            _configService = configService;
        }

        //Get Overview
        public async Task<List<SearchData>> GetSearchDataOverview(RequestSearch request)
        {
            List<SearchData> searchData = new List<SearchData>();

            int startYear = request.SearchStart.Year;
            int endYear = request.SearchEnd.Year;

            //search log
            List<HIST_LogSummary> SearchLogList = new List<HIST_LogSummary>();
            for (int i = startYear; i <= endYear; i++)
            {
                using (var scope = _scopeFactory.CreateScope())
                {
                    var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                    using (var context = GetDBContext<CPXV2Log>(provider, i))
                    {
                        if (context is not null)
                        {
                            SearchLogList.AddRange(await context.HIST_LogSummaries.Where(x => request.SearchStart <= DateOnly.FromDateTime(x.TestDT) && DateOnly.FromDateTime(x.TestDT) <= request.SearchEnd).ToListAsync());
                        }
                    }
                }
            }

            //search testlist
            using (var scope = _scopeFactory.CreateScope())
            {
                var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                using (var context = GetDBContext<CPXV2>(provider, 1))
                {
                    if (context is not null)
                    {
                        var varProdVariant = context.PROD_Variants.ToList();
                        var varProudGroup = context.PROD_Groups.ToList();
                        var TesetInfoList = varProdVariant.Select(x => new TestInfo
                        {
                            PROD_Variant = x,
                            PROD_Group = varProudGroup.Find(y => y.No == x.GroupNo)
                        }).ToList();

                        var search = SearchLogList.Select(x => new SearchData
                        {
                            Summary = x,
                            TestInfo = TesetInfoList.Find(y => y.PROD_Variant.No == x.TestListVariantNo)
                        });

                        var ListSearchData = search
                             // .Where(x => x.Summary.TestListVariantNo > 0)
                              .OrderBy(x => x.Summary.TestDT).ToList();

                        searchData.AddRange(ListSearchData);
                    }
                }
            }

            return searchData;
        }

        public async Task<List<Overview>> GetOverviews(List<SearchData> request)
        {
            var group = request
                .GroupBy(x => (x.Summary.HostID, x.Summary.Section))
                .Select(x => x.ToOverview())
                .OrderBy(x => (x.Host, x.Section));

            await Task.CompletedTask;
            return group.ToList();
        }

        public async Task<List<Overview>> GetOverviewMerged(List<SearchData> request)
        {
            var group = request.OrderByDescending(x=>x.Summary.TestDT)
                .GroupBy(x =>
                    (
                    DateOnly.FromDateTime(x.Summary.TestDT.Date),
                    x.Summary.TestType,
                    x.Summary.ProdNo_C,
                    x.Summary.Testcode,
                    x.Summary.TestListFileNo,
                    x.Summary.TestListVariantNo,
                    x.Summary.ProdNo_P,
                    x.Summary.ProdCode,
                    x.Summary.Version,
                    x.Summary.StepVersion
                    ))
                    .Select(x => x.ToOverviewMerged())
                    .OrderByDescending(x=>x.TestDate)                  
                    .DistinctBy(x => (x.TestType, x.ProductNo, x.TestCode))
                    .OrderBy(x => (x.ProductNo, x.ParentNo, x.TestCode));

            await Task.CompletedTask;
            return group.ToList();
        }

        public async Task<List<Overview>> GetDetailOverview(List<SearchData> request, IOverviewModel row)
        {
            var selectRow = row as Overview;
            List<Overview> detailOverview = new List<Overview>();

            if (selectRow is not null)
            {
                detailOverview = request
                  .Where(x => x.Summary.HostID == selectRow.Host &&
                          x.Summary.Section == selectRow.Section &&
                          x.Summary.Testcode == selectRow.TestCode
                          )
                  .OrderByDescending(x => x.Summary.TestDT.Date)
                  .GroupBy(x => (
                      DateOnly.FromDateTime(x.Summary.TestDT.Date),
                      x.Summary.TestListCntID,
                      x.Summary.StepVersion
                  ))
                  .Select(x => x.ToOverview())
                  .OrderBy(x => x.TestDate)
                  .ToList();
            }

            await Task.CompletedTask;
            return detailOverview;
        }

        public async Task<List<Overview>> GetDetailOverviewMerged(List<SearchData> request, IOverviewModel row)
        {
            var selectRow = row as Overview;
            List<Overview> detailOverview = new List<Overview>();

            if (selectRow is not null)
            {
                detailOverview = request
               .Where(x => x.Summary.Testcode == selectRow.TestCode &&
                       x.Summary.ProdNo_C == selectRow.ProductNo &&
                       x.Summary.ProdNo_P == selectRow.ParentNo)
               .GroupBy(x => (
                   DateOnly.FromDateTime(x.Summary.TestDT.Date),
                   x.Summary.StepVersion
               ))
               .Select(x => x.ToOverviewMerged())
               .OrderBy(x => x.TestDate)
               .ToList();
            }

            await Task.CompletedTask;
            return detailOverview;
        }

        public async Task<List<TestHistory>> GetTestHistory(List<SearchData> request, IOverviewModel row)
        {
            var selectRow = row as Overview;
            List<TestHistory> testHistory = new List<TestHistory>();

            if (selectRow is not null)
            {
                testHistory = request
                    .Where(x => x.Summary.TestDT.Date == selectRow.TestDate.Value.Date &&
                            x.Summary.HostID == selectRow.Host &&
                            x.Summary.Section == selectRow.Section &&
                            x.Summary.ProdNo_C == selectRow.ProductNo &&
                            x.Summary.ProdNo_P == selectRow.ParentNo &&
                            x.Summary.TestListCntID == selectRow.TestListCntID)
                    .Select(x => x.ToTestHistory())
                    .OrderBy(x => x.No)
                    .ToList();
            }

            await Task.CompletedTask;
            return testHistory;
        }

        public async Task<List<TestHistory>> GetTestHistoryMerged(List<SearchData> request, IOverviewModel row)
        {
            var selectRow = row as Overview;
            List<TestHistory> testHistory = new List<TestHistory>();

            if(selectRow is not null)
            {
                testHistory = request
                   .Where(x => x.Summary.TestDT.Date == selectRow.TestDate.Value.Date &&
                           x.Summary.Testcode == selectRow.TestCode &&
                           x.Summary.ProdNo_C == selectRow.ProductNo &&
                           x.Summary.ProdNo_P == selectRow.ParentNo)
                   .Select(x => x.ToTestHistory())
                   .OrderBy(x => (x.TestListReqID, x.No))
                   .ToList();
            }

            await Task.CompletedTask;
            return testHistory.ToList();
        }

        public async Task<TestList> GetTestList(string productNo, string testCode, int stepVersion)
        {
            TestList testList = new TestList();

            if (TryParseTestCode(testCode, out var outTestCode) == true)
            {
                //cpxv2
                using (var scope = _scopeFactory.CreateScope())
                {
                    var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                    using (var context = GetDBContext<CPXV2>(provider, 1))
                    {
                        if (context is not null)
                        {
                            var prodRelease = context.PROD_Releases.Where(x => x.ProdNo_C == productNo && x.TestCodeNo == outTestCode)?.FirstOrDefault();
                            if(prodRelease is not null)
                            {
                                var prodVariant = context.PROD_Variants.Where(x => x.No == prodRelease.VariantNo)?.FirstOrDefault();
                                var prodGroup = context.PROD_Groups.Where(x => x.No == prodVariant.GroupNo)?.FirstOrDefault();
                                var statTestCode = context.STAT_TestCodes.Where(x => x.No == prodRelease.TestCodeNo)?.FirstOrDefault();
                                var storTestListFile = context.STOR_TestListFiles.Where(x => x.No == prodVariant.TestListFileNo)?.FirstOrDefault();
                                var maxStepVersion = context.HIST_TestListFileLatestStepVersions.Where(x => x.TestListFileNo == prodVariant.TestListFileNo)?.FirstOrDefault();

                                //max version보다 크면 max로
                                if (stepVersion > maxStepVersion.LatestStepVersion)
                                {
                                    stepVersion = maxStepVersion.LatestStepVersion;
                                }
                                else if (stepVersion < 0)
                                {
                                    stepVersion = 0;
                                }

                                var findTestList = context.VRFY_TestListFileReleases
                                    .Where(x => x.TestListFileNo == prodVariant.TestListFileNo && x.StepVersion <= stepVersion)
                                    .OrderBy(x => x.StepID)
                                    .ThenByDescending(x => x.StepVersion)
                                    .AsEnumerable()
                                    .DistinctBy(x => x.StepID)
                                    .ToList();

                                testList.ProdRelease = prodRelease;
                                testList.ProdVariant = prodVariant;
                                testList.ProdGroup = prodGroup;
                                testList.StatTestCode = statTestCode;
                                testList.StorTestListFile = storTestListFile;
                                testList.TestListFile = findTestList;
                            }                           
                        }
                    }
                }
            }

            return testList;
        }

        public async Task<TestResult> GetTestResult(IDataModel row, int stepVersion)
        {
            TestResult result = new TestResult();

            var selectRow = row as TestHistory;
            if(selectRow is not null)
            {                
                TestList testList = new TestList();

                //if (TryParseTestCode(selectRow.TestCode, out var testCode) == true)
                {
                    //testlist info
                    var testListInfo =  await GetTestList(selectRow.ProductNo, selectRow.TestCode, stepVersion);
                  
                    //log
                    if(testListInfo?.TestListFile is not null)
                    {
                        if (Int32.TryParse(selectRow.TestDateTime?.Year.ToString(), out var year) == true)
                        {
                            using (var scope = _scopeFactory.CreateScope())
                            {
                                var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                                using (var context = GetDBContext<CPXV2Log>(provider, year))
                                {
                                    if (context is not null)
                                    {
                                        var testResult = context.HIST_TestResults.Where(x => x.No == selectRow.No)?.First();
                                        result = testResult.ToTestResult(testListInfo);
                                    }
                                }
                            }
                        }
                    }                   
                }
            }       

            await Task.CompletedTask;
            return result;
        }

        public bool TryParseTestCode(string testCode, out int outValue)
        {
            bool result = false;
            outValue = -1;

            //search testlist
            using (var scope = _scopeFactory.CreateScope())
            {
                var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                using (var context = GetDBContext<CPXV2>(provider, 1))
                {
                    if (context is not null)
                    {
                        var selectTestCode = context.STAT_TestCodes.Where(x => x.TestCode == testCode)?.FirstOrDefault();
                        if(selectTestCode is not null)
                        {
                            outValue = selectTestCode.No;
                            result = true;
                        }
                    }
                }
            }

            return result;
        }

        //Get DBContext
        private T? GetDBContext<T>(DbContextProvider provider, int dbID) where T : DbContext
        {
            var contextName = typeof(T).Name;

            if(provider.DBDictionary.TryGetValue(dbID, out var findDB) == true)
            {
                return provider?.GetDBContext<T>(findDB.DBID);
            }

            LogXnet.WriteLine($"GetDBContext Error DBID:{dbID}", LogXLabel.Error);
            return null;
        }    
    }
}