using Aurora.Api;
using VisionCommon;
using System;

namespace VisionSequence.Aligner {
    /// <summary>
    /// 패턴 검출 결과 아이템
    /// </summary>
    public class PatternResultItem : ICloneable {
        /// <summary>검출 시간</summary>
        public string Time { get; set; }
        /// <summary>FOV ID</summary>
        public string FovId { get; set; }
        /// <summary>패턴 ID</summary>
        public string PatternId { get; set; }
        /// <summary>패턴 이름</summary>
        public string PatternName { get; set; }
        /// <summary>패턴 타입</summary>
        public string PatternType { get; set; }
        /// <summary>패턴 검출 이미지 좌표 X</summary>
        public double IX { get; set; }
        /// <summary>패턴 검출 이미지 좌표 Y</summary>
        public double IY { get; set; }
        /// <summary>패턴 검출 자재 좌표 X</summary>
        public double SX { get; set; }
        /// <summary>패턴 검출 자재 좌표 Y</summary>
        public double SY { get; set; }
        /// <summary>패턴 검출 각도</summary>
        public double Angle { get; set; }
        /// <summary>패턴 검출 점수</summary>
        public double Score { get; set; }
        /// <summary>패턴 검출 수행 시간</summary>
        public double TactTime { get; set; }
        /// <summary>패턴 검출 상태</summary>
        public string Status { get; set; }

        /// <summary>
        /// 파라미터 복제(PatternResultItem)
        /// </summary>
        /// <returns>PatternResultItem</returns>
        public object Clone() {
            return new PatternResultItem() {
                Time = this.Time,
                FovId = this.FovId,
                PatternId = this.PatternId,
                PatternName = this.PatternName,
                PatternType = this.PatternType,
                IX = this.IX,
                IY = this.IY,
                SX = this.SX,
                SY = this.SY,
                Angle = this.Angle,
                Score = this.Score,
                TactTime = this.TactTime,
                Status = this.Status
            };
        }
    }

    /// <summary>
    /// 패턴 검출 결과 아이템 매니저
    /// </summary>
    public class PatternResultItemManager : ItemManagerBase {
        private static readonly object _Lock = new object();
        private static readonly Logger _VisionLog = new Logger("PatternResult", VisionKeys.LogKey);

        /// <summary>
        /// 패턴 검출 결과를 패턴 검출 아이템으로 변환한다.
        /// </summary>
        /// <param name="subSysInfo">서브 시스템 키 정보</param>
        /// <param name="patternResult">패턴 검출 결과</param>
        /// <returns>패턴 검출 아이템</returns>
        public static PatternResultItem GetPatternResultItem(SubSysInfo subSysInfo, PatternResult patternResult) {
            double ix = 0;
            double iy = 0;
            double sx = 0;
            double sy = 0;
            double angle = 0;
            double score = 0;

            foreach (BaseResult result in patternResult.Results) {
                SetBaseResultParams(patternResult, result, ref ix, ref iy, ref sx, ref sy, ref angle, ref score);
                break;
            }

            lock (_Lock) {
                return new PatternResultItem() {
                    Time = GetTimeStamp(subSysInfo, patternResult),
                    FovId = patternResult.FovId.ToString(),
                    PatternId = $"{patternResult.PatternIndex.PatternId}_{patternResult.PatternIndex.PatternSubId}",
                    PatternName = patternResult.PatternName,
                    PatternType = GetSimpePatternType(patternResult.PatternType),
                    IX = ix,
                    IY = iy,
                    SX = CoordUnitValueConverter.GetCoordUnitValue(sx),
                    SY = CoordUnitValueConverter.GetCoordUnitValue(sy),
                    Angle = angle,
                    Score = score,
                    TactTime = patternResult.TactTimeInMilliSec,
                    Status = GetSimpleStatus(patternResult.Status)
                };
            }
        }

        private static void SetBaseResultParams(
            PatternResult patternResult, BaseResult result,
            ref double ix, ref double iy, ref double sx, ref double sy, ref double angle, ref double score) {

            try {
                _VisionLog.W("[START]");
                _VisionLog.I($"PatternName : {patternResult.PatternName}");
                _VisionLog.I($"PatternType : {patternResult.PatternType}");
                _VisionLog.I($"PatternId : {patternResult.PatternIndex.PatternId}_{patternResult.PatternIndex.PatternSubId}");

                if (patternResult.Status != eFoundStatus.NotFound) {
                    ix = result.ImagePosition.X;
                    iy = result.ImagePosition.Y;
                    sx = result.MaterialPosition.X;
                    sy = result.MaterialPosition.Y;

                    _VisionLog.I($"I({ix:F1}, {iy:F1})");
                    _VisionLog.I($"W({sx:F3}, {sy:F3})");

                    switch (patternResult.PatternType) {
                        case ePatternType.ImageModelFinder:
                            angle = result.Angle.Degree;
                            _VisionLog.I($"Angle : {angle}");
                            score = (result as ModelFinderResult).Score;
                            _VisionLog.I($"Score : {score}");
                            break;
                        case ePatternType.PatternMatching:
                            angle = result.Angle.Degree;
                            _VisionLog.I($"Angle : {angle}");
                            score = (result as PatternMatchingResult).Score;
                            _VisionLog.I($"Score : {score}");
                            break;
                        case ePatternType.ShapeModelFinder:
                            // Shape -> Angle (X)
                            score = (result as ModelFinderResult).Score;    // Shape는 ModelFinder로 캐스팅.
                            _VisionLog.I($"Score : {score}");
                            break;
                        case ePatternType.LineFinder:
                            angle = result.Angle.Degree;
                            _VisionLog.I($"Angle : {angle}");
                            // Line -> Score (X)
                            break;
                    }

                    _VisionLog.I($"TactTimeInMilliSec : {patternResult.TactTimeInMilliSec} ms");
                }
                _VisionLog.I($"Status : {patternResult.Status}");
                _VisionLog.W("[END]");
            }
            catch (Exception) {
            }
        }

        private static string GetSimpePatternType(ePatternType patternType) {
            switch (patternType) {
                case ePatternType.ImageModelFinder:
                    return "Model";
                case ePatternType.PatternMatching:
                    return "Patten";
                case ePatternType.ShapeModelFinder:
                    return "Shape";
                case ePatternType.LineFinder:
                    return "Line";
                case ePatternType.EdgeFinder:
                    return "Edge";
            }
            return patternType.ToString();
        }

        private static string GetSimpleStatus(eFoundStatus status) {
            if (status == eFoundStatus.FoundOK) {
                return "OK";
            }
            else {
                return "NG";
            }
        }
    }
}