using System.Collections.Generic;
using System.Linq;
using WingInterfaceLibrary.Enum;

namespace WingAIDiagnosisService.Manage
{
    public class LiverDiagnosis : BaseDiagnosis
    {
        private AILiverLabelEnum? _mimanLabel;
        private DiagnosisPerImageModel _mimanDiagnosisImage = null;
        public LiverDiagnosis(List<DiagnosisPerImageModel> recordResult, DiagnosisOrganEnum organ) : base(recordResult, organ)
        {
        }

        #region Private 

        private AIDetectedObject CheckFocus(AIDetectedObject message)
        {
            if (message.Label == (int)AILiverLabelEnum.BIRads1)
            {
                return message;
            }
            if (IsMiMan(message.Label))
            {
                return message;
            }
            return CheckEchoPattern(message);
        }

        private AIDetectedObject CheckEchoPattern(AIDetectedObject message)
        {
            if (!message.Descriptions.Any(d => d.Type == DiagnosisDescription.LesionSize && !string.IsNullOrWhiteSpace(d.Value)))
            {
                return null;
            }
            var descriptionList = message.Descriptions.Where(d => d.Type == DiagnosisDescription.EchoPattern && !string.IsNullOrWhiteSpace(d.Value));
            if (descriptionList == null || !descriptionList.Any())
            {
                return null;
            }
            var anechoicList = descriptionList.Where(d => d.Value == "Anechoic");
            var hypoechoicList = descriptionList.Where(d => d.Value == "Hypoechoic");
            var hyperechoicList = descriptionList.Where(d => d.Value == "Hyperechoic");
            var strongechoicList = descriptionList.Where(d => d.Value == "Strongechoic");

            var validEchoPatternList = new List<AIDiagnosisDescription>();
            if (message.Label == (int)AILiverLabelEnum.Hyperechoic)
            {
                if (strongechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(strongechoicList.ToList());
                }
            }
            if (message.Label == (int)AILiverLabelEnum.HHE)
            {
                if (hyperechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(hyperechoicList.ToList());
                }
                else if (hypoechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(hypoechoicList.ToList());
                }
            }
            if (message.Label == (int)AILiverLabelEnum.CYST)
            {
                if (anechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(anechoicList.ToList());
                }
            }
            if (message.Label == (int)AILiverLabelEnum.PossibleCancer)
            {
                if (hyperechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(hyperechoicList.ToList());
                }
                else if (hypoechoicList?.Any() == true)
                {
                    validEchoPatternList.AddRange(hypoechoicList.ToList());
                }
            }
            if (validEchoPatternList.Any())
            {
                message.Descriptions.RemoveAll(x => x.Type == DiagnosisDescription.EchoPattern);
                message.Descriptions.AddRange(validEchoPatternList);
                return message;
            }
            return null;
        }

        private bool IsMiMan(int label)
        {
            switch (label)
            {
                case (int)AILiverLabelEnum.FattyLiver:
                case (int)AILiverLabelEnum.DiffuseLesions:
                case (int)AILiverLabelEnum.Cirrhosis:
                case (int)AILiverLabelEnum.PCLD:
                    return true;
            }
            return false;
        }

        private bool IsUnifiedMiMan(int label)
        {
            return IsMiMan(label) || label == (int)AILiverLabelEnum.BIRads1;
        }

        private bool IsMalignant(int label)
        {
            switch (label)
            {
                case (int)AILiverLabelEnum.PossibleCancer:
                    return true;
            }
            return false;
        }

        private List<int> ExistingLabels(List<DiagnosisPerImageModel> results)
        {
            var existingLabels = new List<int> { (int)AILiverLabelEnum.BIRads1 };
            existingLabels.AddRange(results.SelectMany(x => x.GetLabels()));
            return existingLabels.Distinct().ToList();
        }

        /// <summary>根据诊断结果返回弥漫病灶类型</summary>
        /// <param name="results"></param>
        /// <returns></returns>
        private void GetMiManLabel(List<DiagnosisPerImageModel> results)
        {
            var terminalDataLabels = new Dictionary<string, AILiverLabelEnum>();
            var diagnosisImages = new Dictionary<AILiverLabelEnum, DiagnosisPerImageModel>();
            foreach (var item in results)
            {
                if (terminalDataLabels.ContainsKey(item.RemedicalCode))
                {
                    continue;//同一个图像文件，AI只会有一个弥漫结果
                }
                //每个图都会有一个弥漫或者未见异常的结果
                var label = item.GetLabels().FirstOrDefault(x => IsMiMan(x));
                if (label > 0)
                {
                    var labelEnum = (AILiverLabelEnum)label;
                    terminalDataLabels.Add(item.RemedicalCode, labelEnum);
                    if (!diagnosisImages.ContainsKey(labelEnum))
                    {
                        diagnosisImages.Add(labelEnum, item);
                    }
                }
                else
                {
                    terminalDataLabels.Add(item.RemedicalCode, AILiverLabelEnum.BIRads1);
                }
            }
            if (terminalDataLabels.Any())
            {
                //弥漫严重程度为：肝硬化7 > 肝弥漫性病变6 > 多囊肝8 > 脂肪肝5 > 肝脏未见明显异常0
                var labelSorts = new[] { 1, 0, 0, 0, 0, 2, 4, 5, 3 };
                var mimanLabel = terminalDataLabels.Select(x => x.Value)
                    .GroupBy(x => x)
                    .Select(x => new { Label = x.Key, Count = x.Count() })
                    .OrderByDescending(x => x.Count)
                    .ThenByDescending(x => labelSorts[(int)x.Label])
                    .FirstOrDefault().Label;
                _mimanLabel = mimanLabel;
                if (diagnosisImages.ContainsKey(mimanLabel))
                {
                    _mimanDiagnosisImage = diagnosisImages[mimanLabel];
                }
            }
        }

        /// <summary>确定病例弥漫性病灶类型</summary>
        private void ConfirmMiManLabel()
        {
            var imageResults = RecordDiagnosisResult.Where(x => x.DataType == DataType.VinnoVidSingle || x.DataType == DataType.ThirdVidSingle)?.ToList() ?? new List<DiagnosisPerImageModel>();
            var movieResults = RecordDiagnosisResult.Where(x => x.DataType == DataType.VinnoVidMovie || x.DataType == DataType.ThirdVidMovie)?.ToList() ?? new List<DiagnosisPerImageModel>();
            if (movieResults.Any())
            {
                GetMiManLabel(movieResults);
            }
            else
            {
                GetMiManLabel(imageResults);
            }
        }

        /// <summary>将病例的弥漫病灶统一起来，检查肝癌和脂肪肝的互斥情况</summary>
        private void UnifiedMiManLabel()
        {
            if (_mimanLabel == null)
            {
                return;
            }
            var hasMalignant = ExistingLabels(RecordDiagnosisResult).Any(x => IsMalignant(x));
            foreach (var diagnosisResult in RecordDiagnosisResult)
            {
                foreach (var organResult in diagnosisResult.DiagResultsForEachOrgan)
                {
                    var objects = organResult.DetectedObjects;
                    if (objects.Any(x => IsMiMan(x.Label)))
                    {
                        foreach (var item in objects)
                        {
                            if (IsMiMan(item.Label) && item.Label != (int)_mimanLabel)
                            {
                                item.Label = (int)_mimanLabel;
                            }
                        }
                    }
                    else if (objects.Any(x => x.Label > 0))
                    {
                        objects.Add(new AIDetectedObject
                        {
                            Label = (int)_mimanLabel,
                            Descriptions = new List<AIDiagnosisDescription>()
                        });
                    }
                    else
                    {
                        foreach (var item in objects)
                        {
                            if (item.Label != (int)_mimanLabel)
                            {
                                item.Label = (int)_mimanLabel;
                            }
                        }
                    }
                    if (hasMalignant)
                    {
                        objects = objects.Where(x => x.Label != (int)AILiverLabelEnum.FattyLiver)?.ToList() ?? new List<AIDetectedObject>();
                    }

                    organResult.DetectedObjects = objects;
                }
            }
        }

        /// <summary>查询横截面最大的图</summary>
        /// <param name="label"></param>
        /// <returns></returns>
        private DiagnosisPerImageModel GetMaxLesionSizeImage(AILiverLabelEnum label)
        {
            double maxLesionSize = 0;
            DiagnosisPerImageModel resultData = null;
            foreach (var diagResult in RecordDiagnosisResult)
            {
                //result 这张图要不要
                if (!diagResult.GetLabels().Contains((int)label))
                {
                    continue;
                }
                var isChosed = false;
                foreach (var organResult in diagResult.DiagResultsForEachOrgan)
                {
                    if (isChosed)
                    {
                        break;
                    }
                    foreach (var detectedObjectInfo in organResult.DetectedObjects)
                    {
                        if (detectedObjectInfo.Label == (int)label)
                        {
                            var currLesionSize = GetMaxLesionSize(detectedObjectInfo);
                            if (currLesionSize > maxLesionSize)
                            {
                                //要
                                isChosed = true;
                                maxLesionSize = currLesionSize;
                                resultData = diagResult;
                                break;
                            }
                        }
                    }
                }
            }
            return resultData;
        }

        /// <summary>局灶性选图</summary>
        /// <returns></returns>
        private List<DiagnosisPerImageModel> GetFocusImages()
        {
            var labels = new List<AILiverLabelEnum>
            {
                AILiverLabelEnum.PossibleCancer,
                AILiverLabelEnum.CYST,
                AILiverLabelEnum.HHE,
                AILiverLabelEnum.Hyperechoic,
            };
            var focusImages = new List<AIFocusImageModel>();
            foreach (var label in labels)
            {
                var diagnosisImage = GetMaxLesionSizeImage(label);
                if (diagnosisImage != null)//!focusImages.Any(x => x.DiagnosisImage.TerminalDataId == diagnosisImage.TerminalDataId && x.DiagnosisImage.AIDiagResult.Index == diagnosisImage.AIDiagResult.Index)
                {
                    focusImages.Add(new AIFocusImageModel { Label = label, DiagnosisImage = diagnosisImage });
                }
            }

            var resultData = new List<DiagnosisPerImageModel>();
            var mimanChosed = false;
            foreach (var diagResult in focusImages)
            {
                if (resultData.Any(x => x.RemedicalCode == diagResult.DiagnosisImage.RemedicalCode && x.Index == diagResult.DiagnosisImage.Index))
                {
                    continue;
                }
                var otherLabels = focusImages.Where(x => x.DiagnosisImage.RemedicalCode != diagResult.DiagnosisImage.RemedicalCode || x.DiagnosisImage.Index != diagResult.DiagnosisImage.Index)
                    .Select(x => x.Label).ToList();
                var organResultList = new List<AIDiagnosisResultPerOrgan>();
                foreach (var organResult in diagResult.DiagnosisImage.DiagResultsForEachOrgan)
                {
                    var detectedObjects = organResult.DetectedObjects.Where(x => !otherLabels.Contains((AILiverLabelEnum)x.Label))?.ToList() ?? new List<AIDetectedObject>();
                    if (mimanChosed)
                    {
                        detectedObjects = detectedObjects.Where(x => !IsMiMan(x.Label))?.ToList() ?? new List<AIDetectedObject>();
                    }
                    if (detectedObjects != null && detectedObjects.Any())
                    {
                        organResult.DetectedObjects = detectedObjects.ToList();
                        organResultList.Add(organResult);
                        if (detectedObjects.Any(x => IsMiMan(x.Label)))
                        {
                            mimanChosed = true;
                        }
                    }
                }
                diagResult.DiagnosisImage.DiagResultsForEachOrgan = organResultList;
                resultData.Add(diagResult.DiagnosisImage);
            }
            return resultData;
        }

        #endregion

        /// <summary>筛选有效的AI诊断记录</summary>
        /// <param name="allResult"></param>
        /// <returns></returns>
        public override void CheckDiagResultIndex()
        {
            var validResult = new List<DiagnosisPerImageModel>();
            foreach (var diagResult in RecordDiagnosisResult)
            {
                var organResultList = new List<AIDiagnosisResultPerOrgan>();
                foreach (var organResult in diagResult.DiagResultsForEachOrgan)
                {
                    var valid = CheckResultValid(organResult);
                    if (valid != null)
                    {
                        organResultList.Add(valid);
                    }
                }
                if (organResultList.Any())
                {
                    diagResult.DiagResultsForEachOrgan = organResultList;
                    validResult.Add(diagResult);
                }
            }
            RecordDiagnosisResult = validResult;
            ConfirmMiManLabel();
            UnifiedMiManLabel();
        }

        /// <summary>筛选报告可用诊断结果</summary>
        /// <param name="validResults"></param>
        /// <returns></returns>
        public override List<DiagnosisPerImageModel> GetReportResults()
        {
            if (!RecordDiagnosisResult.Any())
            {
                return RecordDiagnosisResult;
            }

            if (!HasSick())
            {
                //未见异常
                RecordDiagnosisResult = new List<DiagnosisPerImageModel> { RecordDiagnosisResult.FirstOrDefault() };
            }
            else
            {
                var reportResults = GetFocusImages();
                if (!reportResults.Any() && _mimanDiagnosisImage != null)
                {
                    //只有弥漫的情况
                    reportResults = new List<DiagnosisPerImageModel> { _mimanDiagnosisImage };
                }
                RecordDiagnosisResult = reportResults;
            }
            InitialAIImage();
            return RecordDiagnosisResult;
        }

        /// <summary>判断并返回有效的诊断描述</summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public override AIDiagnosisResultPerOrgan CheckResultValid(AIDiagnosisResultPerOrgan message)
        {
            if (message.Organ != DiagnosisOrganEnum.Liver)
            {
                return null;
            }
            var result = message;
            var validDetectedObjects = new List<AIDetectedObject>();
            foreach (var obj in message.DetectedObjects)
            {
                var obj_new = CheckFocus(obj);
                if (obj_new != null)
                {
                    validDetectedObjects.Add(obj_new);
                }
            }
            if (validDetectedObjects.Any())
            {
                result.DetectedObjects = validDetectedObjects;
                return result;
            }
            return null;
        }

        /// <summary>判断AI诊断结果</summary>
        /// <returns></returns>
        public override DiagnosisConclusion GetAIStatus()
        {
            var status = DiagnosisConclusion.Unrecognized;
            bool existMalignant = false;
            bool existBenign = false;
            if (RecordDiagnosisResult != null && RecordDiagnosisResult.Any())
            {
                foreach (var diagResult in RecordDiagnosisResult)
                {
                    if (existMalignant && existBenign)
                        break;
                    if (diagResult.PriorityScore > 0 && diagResult.DiagResultsForEachOrgan != null)
                    {
                        foreach (var organ in diagResult.DiagResultsForEachOrgan)
                        {
                            if (organ.DetectedObjects != null)
                            {
                                if (!existMalignant)
                                {
                                    if (organ.DetectedObjects.Any(a => IsMalignant(a.Label)))
                                    {
                                        existMalignant = true;
                                    }
                                }

                                if (!existBenign)
                                {
                                    if (organ.DetectedObjects.Any(a => a.Label >= 1 && a.Label != (int)AILiverLabelEnum.PossibleCancer))
                                    {
                                        existBenign = true;
                                    }
                                }
                            }
                        }

                        if (existMalignant)
                        {
                            status = existBenign ? DiagnosisConclusion.BenignAndMalignant : DiagnosisConclusion.Malignant;
                        }
                        else
                        {
                            status = existBenign ? DiagnosisConclusion.Benign : DiagnosisConclusion.NoObviousLesion;
                        }
                    }
                }
            }
            return status;
        }

        /// <summary>
        /// 是否恶性病灶
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        protected override bool IsMalignant(AIDetectedObject detectedObject)
        {
            return detectedObject.Label == (int)AILiverLabelEnum.PossibleCancer;
        }


    }

    public class AIFocusImageModel
    {
        public AILiverLabelEnum Label { get; set; }
        public DiagnosisPerImageModel DiagnosisImage { get; set; }
    }
}