using Azure.Core;
using Microsoft.EntityFrameworkCore;
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 detailOverview = request
                .Where(x => x.Summary.HostID == row.Host &&
                        x.Summary.Section == row.Section &&
                        x.Summary.Testcode == row.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);

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

        public async Task<List<Overview>> GetDetailOverviewMerged(List<SearchData> request, IOverviewModel row)
        {
            var detailOverview = request
                .Where(x => x.Summary.Testcode == row.TestCode &&
                        x.Summary.ProdNo_C == row.ProductNo &&
                        x.Summary.ProdNo_P == row.ParentNo)
                .GroupBy(x => (
                    DateOnly.FromDateTime(x.Summary.TestDT.Date),
                    x.Summary.StepVersion
                ))
                .Select(x => x.ToOverviewMerged())
                .OrderBy(x => x.TestDate);

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

        public async Task<List<TestHistory>> GetTestHistory(List<SearchData> request, IOverviewModel row)
        {
            var testHistory = request
                .Where(x => x.Summary.TestDT.Date == row.TestDate.Value.Date &&
                        x.Summary.HostID == row.Host &&
                        x.Summary.Section == row.Section &&
                        x.Summary.ProdNo_C == row.ProductNo &&
                        x.Summary.ProdNo_P == row.ParentNo &&
                        x.Summary.TestListCntID == row.TestListCntID)
                .Select(x=>x.ToTestHistory())
                .OrderBy(x => x.No);
            await Task.CompletedTask;
            return testHistory.ToList();
        }

        public async Task<List<TestHistory>> GetTestHistoryMerged(List<SearchData> request, IOverviewModel row)
        {
            var testHistory = request
                .Where(x => x.Summary.TestDT.Date == row.TestDate.Value.Date &&
                        x.Summary.Testcode == row.TestCode&&                        
                        x.Summary.ProdNo_C == row.ProductNo &&
                        x.Summary.ProdNo_P == row.ParentNo)
                .Select(x => x.ToTestHistory())
                .OrderBy(x => (x.TestListReqID, x.No));
            await Task.CompletedTask;
            return testHistory.ToList();
        }

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

            var selectRow = row as TestHistory;
            if(selectRow is not null)
            {
                int year = selectRow.TestDate.Value.Year;

                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();
                            var decompressTestResult = testResult.ToTestResult();

                            result.DecompressTestResult = decompressTestResult;
                        }
                    }
                }

                result.No = selectRow.No;
            }           

            await Task.CompletedTask;
            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;
        }    
    }
}