using Newtonsoft.Json;
using SystemX.Core.DB;
using Web.Tra.Model;
using SystemX.Core.Utils;

public static class ObjectExtend
{
    public static Overview ToOverview(this IEnumerable<SearchData> data)
    {
        return new Overview
        {
            TestDate = data.Max(x => x.Summary.TestDT.Date),
            StationName = data.Last().Summary.StationName,
            Host = data.Last().Summary.HostID,
            Section = data.Last().Summary.Section,
            ModelName = data.Last().TestInfo?.PROD_Group?.ModelName,
            TestType = data.Last().Summary.TestType,
            ProductNo = data.Last().Summary.ProdNo_C,
            TestCode = data.Last().Summary.Testcode,
            ParentNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.ProdNo_P,
            TestListFileNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.TestListFileNo,
            TestListVariantNo = data.GroupBy(x => x.Summary.TestListCntID).Last().Last().Summary.TestListVariantNo,
            FileCode = data.Last().Summary.ProdCode,
            FileVersion = data.Last().Summary.Version,
            StepVersion = data.Last().Summary.StepVersion,
            FirstTestTime = data.GroupBy(x => x.Summary.TestListCntID).Last().Min(y => y.Summary.TestDT).ToString("HH:mm:ss"),
            FinalTestTime = data.GroupBy(x => x.Summary.TestListCntID).Last().Max(y => y.Summary.TestDT).ToString("HH:mm:ss"),
            Total = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(),
            OK = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(y => y.Summary.Result.ToLower().Equals("ok")),
            NG = data.GroupBy(x => (x.Summary.TestListCntID, x.Summary.TestDT.Date)).Last().Count(y => !y.Summary.Result.ToLower().Equals("ok")),
            TestListCntID = data.Last().Summary.TestListCntID
        };
    }

    public static Overview ToOverviewMerged(this IEnumerable<SearchData> data)
    {        
        return new Overview
        {
            TestDate = data.Max(x => x.Summary.TestDT.Date),         
            ModelName = data.Last().TestInfo?.PROD_Group?.ModelName,
            TestType = data.Last().Summary.TestType,
            ProductNo = data.Last().Summary.ProdNo_C,
            TestCode = data.Last().Summary.Testcode,
            ParentNo = data.Last().Summary.ProdNo_P,
            TestListFileNo = data.Last().Summary.TestListFileNo,
            TestListVariantNo = data.Last().Summary.TestListVariantNo,
            FileCode = data.Last().Summary.ProdCode,
            FileVersion = data.Last().Summary.Version,
            StepVersion = data.Last().Summary.StepVersion,
            FirstTestTime = data.Min(y => y.Summary.TestDT).ToString("HH:mm:ss"),
            FinalTestTime = data.Max(y => y.Summary.TestDT).ToString("HH:mm:ss"),
            Total = data.Count(),
            OK = data.Count(y => y.Summary.Result.ToLower().Equals("ok")),
            NG = data.Count(y => !y.Summary.Result.ToLower().Equals("ok")),        
        };
    }

    public static Overview ToDetailOverview(this IEnumerable<SearchData> data)
    {
        return data.ToOverview();
    }

    public static TestHistory ToTestHistory(this SearchData data)
    {
        return new TestHistory
        {
            No = data.Summary.No,
            TestDateTime = data.Summary.TestDT,
            StationName = data.Summary.StationName,
            Host = data.Summary.HostID,
            Section = data.Summary.Section,
            ProductID = data.Summary.ProductID,
            TestType = data.Summary.TestType,
            ProductNo = data.Summary.ProdNo_C,
            TestCode = data.Summary.Testcode,
            ParentNo = data.Summary.ProdNo_P,
            FileCode = data.Summary.ProdCode,
            FileVersion = data.Summary.Version,
            StepVersion = Convert.ToInt32(data.Summary.StepVersion),
            Duration = data.Summary.Duration,
            TestResult = data.Summary.Result,
            TestListReqID = data.Summary.TestListCntID,

            TestListFileName = data.Summary.TestListFileName,
            TestListFileNo = data.Summary.TestListFileNo.ToString(),
            TestListVariantNo = data.Summary.TestListVariantNo.ToString()
        };
    }

    public static TestResult ToTestResult(this HIST_TestResult histTestResult, TestList testList = null)
    {
        TestResult testResult = new TestResult();
        testResult.TestList = testList;
        
        //decompress
        var decompStr = histTestResult?.LogData.GzipDecompress();
        var logData = JsonConvert.DeserializeObject<List<DecompressTestResult>>(decompStr);

        testResult.DecompressTestResult = logData;

        //parse
        var parse = logData.Select(x=>x.ParseTestResult(testList)).Where(x=> x is not null && string.IsNullOrEmpty(x.MeasuredValue) == false).ToList();
        testResult.ParseTestResult = parse;

        return testResult;
    }

    private static ParseTestResult ParseTestResult(this DecompressTestResult logData, TestList testList = null)
    {        
        var selectData = testList.TestListFile.Where(x => x.StepID == logData.StepID)?.FirstOrDefault();
        if (selectData is not null)
        {
            var parseTestResult = new ParseTestResult
            {
                StepNo = logData.StepID,
                Position = (long)selectData?.Position,
                Variant = selectData?.Variant,
                Gate = selectData?.Gate,
                MO = selectData?.StepDesc,
                Function = selectData?.UseFunction,
                Min = logData?.GlobalMin,
                MeasuredValue = logData.MeasuredValue,
                Max = logData.GlobalMax,
                Dimension = selectData?.Dim,
                Result = logData.Result,
                Duration = logData.SpentTime
            };

            //min,max
            if (selectData.IsGlobal == true)
            {
                parseTestResult.Min = logData.GlobalMin;
                parseTestResult.Max = logData.GlobalMax;
            }
            else
            {
                parseTestResult.Min = selectData.SpecMin;
                parseTestResult.Max = selectData.SpecMax;
            }

            //meas val
            if (string.IsNullOrEmpty(logData.Message) == false)
            {
                parseTestResult.MeasuredValue = logData.Message;
            }
            else if (string.IsNullOrEmpty(logData.MeasValStr) == false)
            {
                parseTestResult.MeasuredValue = logData.MeasValStr;
            }
            else if (string.IsNullOrEmpty(parseTestResult.Min) == true &&
                string.IsNullOrEmpty(parseTestResult.Max) == true &&
                logData.MeasVal == 0)
            {
                parseTestResult.MeasuredValue = logData.MeasVal.ToString("F1");
            }
            else
            {
                parseTestResult.MeasuredValue = logData.MeasVal.ToString();
            }

            return parseTestResult;
        }
      
        return null;
    }

    public static TestSummary ToTestSummary(this List<TestResult> testResults)
    {
        TestSummary testSummary = new TestSummary();
        testSummary.ParseTestSummary = new List<ParseTestSummary>();
     
        if(testResults?.Count > 0)
        {
            var parseTestResults = testResults.SelectMany(x => x.ParseTestResult??=new()).ToList();
            var rowGroup = parseTestResults.GroupBy(x => x.StepNo).ToList().OrderBy(x => x.Key);
            foreach(var rows in rowGroup)
            {
                var summary = new ParseTestSummary
                {
                    StepNo = rows.First().StepNo,
                    Variant = rows.First().Variant,
                    Gate = rows.First().Gate,
                    MO = rows.First().MO,
                    Function = rows.First().Function,
                    Min = rows.First().Min,
                    Average = rows.First().MeasuredValue,
                    Max = rows.First().Max,
                    Dimension = rows.First().Dimension,
                    Total = rows.Count(),
                    OK = rows.Count(x => x.Result.ToLower().Equals("ok") || x.Result.ToLower().Equals("none")),
                    NG = rows.Count(x => !(x.Result.ToLower().Equals("ok") || x.Result.ToLower().Equals("none"))),
                };

                //calculate dim
                if (rows.FirstOrDefault().Dimension.ToLower() == "dez" || rows.FirstOrDefault().Dimension.ToLower() == "v" ||
                    rows.FirstOrDefault().Dimension.ToLower() == "float" || rows.FirstOrDefault().Dimension.ToLower() == "int")
                {
                    summary.Average = rows.Average(x => Convert.ToDouble(x.MeasuredValue)).ToString();
                }
                else
                {
                    if (summary.Average == "0.0")
                        summary.Average = string.Empty;
                }

                testSummary.ParseTestSummary.Add(summary);
            }
        }

        return testSummary;
    }

    public static TestSummaryInformation GetTestSummaryInformation(this List<TestHistory> testHistories)
    {
        return new TestSummaryInformation
        {           
            StartTime = (DateTime)testHistories.Min(x => x.TestDateTime),
            EndTime = (DateTime)testHistories.Max(x => x.TestDateTime),
            StationName = testHistories.GroupBy(x=>x.StationName)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().StationName,
            HostID = testHistories.GroupBy(x => x.Host)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().Host,
            SectionID = testHistories.GroupBy(x => x.Section)?.Count() > 1 ? string.Empty : testHistories.FirstOrDefault().Section,
            TestType = testHistories.FirstOrDefault().TestType,
            ProductNo = testHistories.FirstOrDefault().ProductNo,
            TestCode = testHistories.FirstOrDefault().TestCode,
            ParentNo = testHistories.FirstOrDefault().ParentNo,
            TestListFileNo = Convert.ToInt32(testHistories.FirstOrDefault().TestListFileNo),
            TestListVariantNo = Convert.ToInt32(testHistories.FirstOrDefault().TestListVariantNo),
            ProductionCode = testHistories.FirstOrDefault().FileCode,
            FileVersion = testHistories.FirstOrDefault().FileVersion,
            StepVersion = testHistories.FirstOrDefault().StepVersion,
            TestRequestsID = testHistories.FirstOrDefault().TestListReqID,
        };
    }
}