using System;
using System.Runtime.Serialization;

using AI.Common;

namespace AutoBlineCalculationLib
{
    /// <summary>
    /// B线评分类别
    /// </summary>
    public enum EnumBlineScoreType
    {

        /// <summary>
        /// 空
        /// </summary>
        Null = 0,

        /// <summary>
        /// 孤立B线
        /// </summary>
        IsolatedBLine = 1,

        /// <summary>
        /// 融合B线 
        /// </summary>
        FusionBLine = 2,

        /// <summary>
        /// 肺实变
        /// </summary>
        LungConsolidation = 3,
    }

    /// <summary>
    /// B线评分相关信息
    /// </summary>
    public struct BLineScoringInfo
    {
        private EnumBlineScoreType _type;
        private IUltrasoundImageRegion _ultrasoundImageRegion;

        /// <summary>
        /// B线评分类别
        /// </summary>
        public EnumBlineScoreType Type
        {
            get => _type;
            set => _type = value;
        }

        public IUltrasoundImageRegion UltrasoundImageRegion
        {
            get => _ultrasoundImageRegion;
            set => _ultrasoundImageRegion = value;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="type"></param>
        /// <param name="ultrasoundImageRegion"></param>
        public BLineScoringInfo(EnumBlineScoreType type, IUltrasoundImageRegion ultrasoundImageRegion)
        {
            _type = type;
            _ultrasoundImageRegion = ultrasoundImageRegion;
        }

        public static readonly BLineScoringInfo Empty = new BLineScoringInfo(EnumBlineScoreType.Null, null);

        public bool Equals(BLineScoringInfo other)
        {
            return Equals(this, other);
        }

        public static bool Equals(BLineScoringInfo one, BLineScoringInfo other)
        {
            if (one.Type != other.Type || one.UltrasoundImageRegion != other.UltrasoundImageRegion)
            {
                return false;
            }
            return true;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is BLineScoringInfo))
            {
                return false;
            }
            BLineScoringInfo other = (BLineScoringInfo)obj;
            return Equals(this, other);
        }

        public static bool operator ==(BLineScoringInfo one, BLineScoringInfo other)
        {
            return Equals(one, other);
        }

        public static bool operator !=(BLineScoringInfo one, BLineScoringInfo other)
        {
            return !Equals(one, other);
        }
    }

    /// <summary>
    /// B线模型分割类别
    /// </summary>
    public enum EnumBlineRecognizedObjectType
    {
        /// <summary>
        /// 空
        /// </summary>
        Null = 0,

        /// <summary>
        /// 胸膜线 
        /// </summary>
        Pline = 1,

        /// <summary>
        /// B线
        /// </summary>
        Bline = 2,

        /// <summary>
        /// A线
        /// </summary>
        Aline = 3,

        /// <summary>
        /// 肺实变
        /// </summary>
        LungConsolidation = 4,
    }

    /// <summary>
    /// B线模型识别到的目标的相关信息
    /// </summary>
    public struct BlineRecognizedObjectInfo
    {
        private EnumBlineRecognizedObjectType _type;
        private float _confidence;
        private Point2D[] _contour;

        /// <summary>
        /// 被识别到的目标的类别
        /// </summary>
        public EnumBlineRecognizedObjectType Type
        {
            get => _type;
            set => _type = value;
        }

        /// <summary>
        /// 识别正确的可能性
        /// </summary>
        public float Confidence
        {
            get => _confidence;
            set => _confidence = value;
        }

        /// <summary>
        /// 该目标的轮廓
        /// </summary>
        public Point2D[] Contour
        {
            get => _contour;
            set => _contour = value;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="type"></param>
        /// <param name="confidence"></param>
        /// <param name="contour"></param>
        public BlineRecognizedObjectInfo(EnumBlineRecognizedObjectType type, float confidence, Point2D[] contour)
        {
            _type = type;
            _confidence = confidence;
            _contour = contour;
        }

        public static readonly BlineRecognizedObjectInfo Empty = new BlineRecognizedObjectInfo(EnumBlineRecognizedObjectType.Null, 0, Array.Empty<Point2D>());

        public bool Equals(BlineRecognizedObjectInfo other)
        {
            return Equals(this, other);
        }

        public static bool Equals(BlineRecognizedObjectInfo one, BlineRecognizedObjectInfo other)
        {
            if (one.Type != other.Type || one.Confidence != other.Confidence)
            {
                return false;
            }
            if (one.Contour == null && other.Contour == null)
            {
                return true;
            }
            if ((one.Contour == null && other.Contour != null) || (one.Contour != null && other.Contour == null))
            {
                return false;
            }
            if (one.Contour.Length != other.Contour.Length)
            {
                return false;
            }
            for (int ni = 0; ni < one.Contour.Length; ni++)
            {
                if (one.Contour[ni] != other.Contour[ni])
                {
                    return false;
                }
            }
            return true;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is BlineRecognizedObjectInfo))
            {
                return false;
            }
            BlineRecognizedObjectInfo other = (BlineRecognizedObjectInfo)obj;
            return Equals(this, other);
        }

        public static bool operator ==(BlineRecognizedObjectInfo one, BlineRecognizedObjectInfo other)
        {
            return Equals(one, other);
        }

        public static bool operator !=(BlineRecognizedObjectInfo one, BlineRecognizedObjectInfo other)
        {
            return !Equals(one, other);
        }
    }

    /// <summary>
    /// 感兴趣区域相关信息
    /// </summary>
    public struct RegionOfInterestInfo
    {
        #region private
        private float _regionOfInterestScore;
        private IUltrasoundImageRegion _ultrasoundRegionOfInterest;
        #endregion

        /// <summary>
        /// 单帧图像中感兴趣区域得分
        /// </summary>
        public float RegionOfInterestScore
        {
            get => _regionOfInterestScore;
            set => _regionOfInterestScore = value;
        }

        public IUltrasoundImageRegion UltrasoundRegionOfInterest
        {
            get => _ultrasoundRegionOfInterest;
            set => _ultrasoundRegionOfInterest = value;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ultrasoundRegionOfInterest"></param>
        /// <param name="ultrasoundRegionOfInterest"></param>
        public RegionOfInterestInfo(float regionOfInterestScore, IUltrasoundImageRegion ultrasoundRegionOfInterest)
        {
            _regionOfInterestScore = regionOfInterestScore;
            _ultrasoundRegionOfInterest = ultrasoundRegionOfInterest;
        }

        public static readonly RegionOfInterestInfo Empty = new RegionOfInterestInfo(0, null);

        public bool Equals(RegionOfInterestInfo other)
        {
            return Equals(this, other);
        }

        public static bool Equals(RegionOfInterestInfo one, RegionOfInterestInfo other)
        {
            if (one.RegionOfInterestScore != other.RegionOfInterestScore || one.UltrasoundRegionOfInterest != other.UltrasoundRegionOfInterest)
            {
                return false;
            }
            return true;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is RegionOfInterestInfo))
            {
                return false;
            }
            RegionOfInterestInfo other = (RegionOfInterestInfo)obj;
            return Equals(this, other);
        }

        public static bool operator ==(RegionOfInterestInfo one, RegionOfInterestInfo other)
        {
            return Equals(one, other);
        }

        public static bool operator !=(RegionOfInterestInfo one, RegionOfInterestInfo other)
        {
            return !Equals(one, other);
        }
    }



/// <summary>
/// 单幅图像的B线计算结果
/// </summary>
[DataContract]
    public struct BlineScoringResults
    {
        #region field
        private int _blineScore;
        private BLineScoringInfo[] _blineScoringInfo;
        private BlineRecognizedObjectInfo[] _recognizedObjects;
        private RegionOfInterestInfo _regionOfInterestInfo;
    #endregion

    #region public funcs
    /// <summary>
    ///  单幅图像中B线的评分
    /// </summary>
    public int BlineScore { get => _blineScore; set => _blineScore = value; }

        /// <summary>
        ///  单幅图像中B线计算的目标
        /// </summary>
        public BLineScoringInfo[] BlineScoringInfo
        {
            get => _blineScoringInfo;
            set => _blineScoringInfo = value;
        }

        /// <summary>
        /// B线模型分割目标
        /// </summary>
        public BlineRecognizedObjectInfo[] RecognizedObjects
        {
            get => _recognizedObjects;
            set => _recognizedObjects = value;
        }

        public RegionOfInterestInfo RegionOfInterestInfo
        {
            get => _regionOfInterestInfo;
            set => _regionOfInterestInfo = value;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="blineScore"></param>
        /// <param name="blineScoringInfo"></param>
        /// <param name="recognizedObjects"></param>
        public BlineScoringResults(int blineScore, BLineScoringInfo[] blineScoringInfo, BlineRecognizedObjectInfo[] recognizedObjects, RegionOfInterestInfo regionOfInterestInfo)
        {
            _blineScore = blineScore;
            _blineScoringInfo = blineScoringInfo;
            _recognizedObjects = recognizedObjects;
            _regionOfInterestInfo = regionOfInterestInfo;
        }

        public static readonly BlineScoringResults Empty = new BlineScoringResults(0, Array.Empty<BLineScoringInfo>(), Array.Empty<BlineRecognizedObjectInfo>(), RegionOfInterestInfo.Empty);

        public bool Equals(BlineScoringResults other)
        {
            return Equals(this, other);
        }

        public static bool Equals(BlineScoringResults one, BlineScoringResults other)
        {
            if (one.BlineScore != other.BlineScore)
            {
                return false;
            }
            // BlineScoringInfo
            if (one.BlineScoringInfo == null && other.BlineScoringInfo == null)
            {
                return true;
            }
            if ((one.BlineScoringInfo != null && other.BlineScoringInfo == null) || (one.BlineScoringInfo == null && other.BlineScoringInfo != null))
            {
                return false;
            }
            if (one.BlineScoringInfo.Length != other.BlineScoringInfo.Length)
            {
                return false;
            }
            return true;
            // RecognizedObjects
            if (one.RecognizedObjects == null && other.RecognizedObjects == null)
            {
                return true;
            }
            if ((one.RecognizedObjects != null && other.RecognizedObjects == null) || (one.RecognizedObjects == null && other.RecognizedObjects != null))
            {
                return false;
            }
            if (one.RecognizedObjects.Length != other.RecognizedObjects.Length)
            {
                return false;
            }
            for (int ni = 0; ni < one.RecognizedObjects.Length; ni++)
            {
                if (one.RecognizedObjects[ni] != other.RecognizedObjects[ni])
                {
                    return false;
                }
            }
            return true;
            // RegionOfInterestInfo
            if (one.RegionOfInterestInfo == null && other.RegionOfInterestInfo == null)
            {
                return true;
            }
            if ((one.RegionOfInterestInfo != null && other.RegionOfInterestInfo == null) || (one.RegionOfInterestInfo == null && other.RegionOfInterestInfo != null))
            {
                return false;
            }
            return true;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || !(obj is BlineScoringResults))
            {
                return false;
            }
            BlineScoringResults other = (BlineScoringResults)obj;
            return Equals(this, other);
        }

        public static bool operator ==(BlineScoringResults one, BlineScoringResults other)
        {
            return Equals(one, other);
        }

        public static bool operator !=(BlineScoringResults one, BlineScoringResults other)
        {
            return !Equals(one, other);
        }
        #endregion
    }
}