using System.Collections.Generic;
using Aurora.Api;
using VisionCommon;
using System.Threading;
using VisionSequence.Pattern;
using VisionCommonUI;
using VisionCommonUI.Resources;
using Hermes;
using System.Linq;

namespace VisionSequence.Setup {
    /// <summary>
    /// 제자리 반복도 측정 셋업 시퀀스 요청 파라미터
    /// </summary>
    public class SetupSeqParams_VisionRepeat {
        /// <summary>FOV 키 정보</summary>
        public FovInfo FovInfo { get; set; }
        /// <summary>메인 화면 타입</summary>
        public eDisplayType DisplayType { get; set; }
        /// <summary>반복 횟수</summary>
        public int RepeatCount { get; set; }
        /// <summary>패턴 정보</summary>
        public PatternInfo PatternInfo { get; set; }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="fovInfo">FOV 키 정보</param>
        /// <param name="patternInfo">패턴 정보</param>
        /// <param name="repeatCount">반복 횟수</param>
        /// <param name="displayType">메인 화면 타입</param>
        public SetupSeqParams_VisionRepeat(FovInfo fovInfo, PatternInfo patternInfo,
            int repeatCount = 0,
            eDisplayType displayType = eDisplayType.VisionRepeat) {

            this.FovInfo = fovInfo;
            this.DisplayType = displayType;
            this.RepeatCount = repeatCount;
            this.PatternInfo = patternInfo;
        }
    }

    /// <summary>
    /// 제자리 반복도 측정 셋업 시퀀스 결과 파라미터
    /// </summary>
    public class SetupSeqResultParams_VisionRepeat {
        /// <summary>이미지 좌표</summary>
        public List<ImagePoint> ImagePoints { get; set; }
        /// <summary>자재 좌표</summary>
        public List<StaticPoint> StaticPoints { get; set; }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="imagePoints">이미지 좌표</param>
        /// <param name="staticPoints">자재 좌표</param>
        public SetupSeqResultParams_VisionRepeat(List<ImagePoint> imagePoints, List<StaticPoint> staticPoints) {
            this.ImagePoints = imagePoints;
            this.StaticPoints = staticPoints;
        }
    }

    /// <summary>
    /// 제자리 반복도 측정
    /// </summary>
    public class SetupSeq_VisionRepeat {
        const string KEY_PATTERN_FOUND = "KEY_PATTERN_FOUND";
        const string KEY_CURRENT_STEP = "KEY_PLAN_CURRENT_STEP";

        private readonly Logger LOG = new Logger("VisionRepeatSeq");
        private SetupSeqParams_VisionRepeat _Params;
        private FovRecipe _FovRecipe;
        private FovInfo _FovInfo;
        private CsvManager _CsvManager = new CsvManager();
        private ImageManager _ImageManager = new ImageManager();

        private List<ImagePoint> _ImagePoints = new List<ImagePoint>();
        private List<StaticPoint> _StaticPoints = new List<StaticPoint>();

        #region Sequence Id
        private const string SEQ_ID_INIT = "INIT";
        private const string SEQ_ID_CHECK_PATTERN = "CHECK_PATTERN";
        private const string SEQ_ID_UNDEFINED_PATTERN_NG = "SEQ_ID_UNDEFINED_PATTERN_NG";
        private const string SEQ_ID_PREPARE = "PREPARE";
        private const string SEQ_ID_CLEAR = "CLEAR";
        private const string SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS = "SET_GRAB_FIND_PROC_SEQ_PARAMS";
        private const string SEQ_ID_GRAB_FIND_PROC_SEQ = "GRAB_FIND_PROC_SEQ";
        private const string SEQ_ID_SAVE_IMAGE = "SEQ_ID_SAVE_IMAGE";
        private const string SEQ_ID_APPLY_DATA = "ApplyData";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

        /// <summary>
        /// 생성자
        /// </summary>
        public SetupSeq_VisionRepeat() {
        }

        public SequenceBuilder Builder() {
            SequenceBuilder sb = new SequenceBuilder(1000);
            SetActions(sb);
            sb.OnStopped(OnStopped);
            sb.OnForceError(OnForceError);

            sb.Flows(
                  sb.Init
                > sb[SEQ_ID_INIT]
                > sb[SEQ_ID_CHECK_PATTERN]
                > sb[SEQ_ID_PREPARE]
                > sb[SEQ_ID_CLEAR]
                > sb[SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS]
                > sb[SEQ_ID_GRAB_FIND_PROC_SEQ]
                > sb[SEQ_ID_SAVE_IMAGE]
                > sb[SEQ_ID_APPLY_DATA]
                );

            sb.Flows(
                sb[SEQ_ID_CHECK_PATTERN]
                > sb[SEQ_ID_UNDEFINED_PATTERN_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );

            sb.Flows(
                  sb[SEQ_ID_APPLY_DATA]
                > sb[SEQ_ID_CLEAR]
                );

            sb.Flows(
                 sb[SEQ_ID_APPLY_DATA]
               > sb[SEQ_ID_SEQ_COMPLETE]
               > sb.Final
               );

#if SEQ_DRAW
            sb.Draw($"{GetType().Name}.pdf");
#endif

            return sb;
        }

        private void SetActions(SequenceBuilder sb) {
            SequenceBuilder grabFindProcSeqBuilder = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), "GrabFindProcSeq");

            sb.AddAction(SEQ_ID_INIT, Init);
            sb.AddDecision(SEQ_ID_CHECK_PATTERN, CheckPattern);
            sb.AddAction(SEQ_ID_UNDEFINED_PATTERN_NG, UndefinedPatternNG);
            sb.AddAction(SEQ_ID_PREPARE, Prepare);
            sb.AddAction(SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS, SetGrabFindProcSeqParams);
            sb.AddSubsequence(SEQ_ID_GRAB_FIND_PROC_SEQ, grabFindProcSeqBuilder);
            sb.AddAction(SEQ_ID_SAVE_IMAGE, SaveImage);
            sb.AddDecision(SEQ_ID_APPLY_DATA, ApplyData);
            sb.AddAction(SEQ_ID_CLEAR, Clear);
            sb.AddAction(SEQ_ID_SEQ_COMPLETE, SeqComplete);
        }

        private SequenceActionResult Init(SequenceContext context, string id, SequenceActionResult param) {
            if (param.Param != null) {
                _Params = param.Param as SetupSeqParams_VisionRepeat;
            }

            _FovRecipe = VisionRecipeManager.GetFovRecipe(_Params.FovInfo);
            _FovInfo = _Params.FovInfo;

            context.PutValue(KEY_CURRENT_STEP, 0);
            _ImagePoints.Clear();
            _StaticPoints.Clear();

            return SequenceAction.Ok();
        }

        private string CheckPattern(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param) {
            var visionRepeatRecipe = VisionRecipeManager.GetVisionRepeatRecipe(_Params.FovInfo);
            if (visionRepeatRecipe.PatternId == -1) {
                return SEQ_ID_UNDEFINED_PATTERN_NG;
            }

            return SEQ_ID_PREPARE;
        }

        private SequenceActionResult UndefinedPatternNG(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            string errMsg = "Undefined PatternID Available";
            LOG.E(errMsg);

            return SequenceAction.Ok();
        }

        private SequenceActionResult Prepare(SequenceContext context, string id, SequenceActionResult param) {
            if (_FovRecipe != null)
                return SequenceAction.Ok();
            else
                return SequenceAction.Error();
        }

        private SequenceActionResult SetGrabFindProcSeqParams(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            var visionRepeatRecipe = VisionRecipeManager.GetVisionRepeatRecipe(_Params.FovInfo);
            eSeqMode seqMode = eSeqMode.Manual;     // 그랩을 Skip하지 않기 위함.

            return SequenceAction.Ok(new GrabFindProcSeqParams(_Params.FovInfo, _Params.PatternInfo, _Params.DisplayType, seqMode));
        }


        private SequenceActionResult SaveImage(
           SequenceContext context,
           string id,
           SequenceActionResult param) {

            if (VisionSettingManager.VisionSetting.SaveSetUpImage) {
                var display = CameraDisplayManager.GetDisplay(_FovInfo, _Params.DisplayType);
                object image = display.GetImageObject();

                if (image != null) {
                    _ImageManager.SaveImageInternal(_FovInfo, eSaveDataType.VisionRepeat, image);
                }
            }

            var patternResult = param.Param as PatternResult;

            return SequenceAction.Ok(patternResult);
        }

        private string ApplyData(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param) {
            ImagePoint imagePoint = new ImagePoint();
            StaticPoint staticPoint = new StaticPoint();

            var patternResult = param.Param as PatternResult;
            if (patternResult.Status == eFoundStatus.FoundOK) //하나 이상일 경우 OK
            {
                context.PutValue<bool>(KEY_PATTERN_FOUND, true);
                var result = patternResult.Results.ToList()[0];

                imagePoint = result.ImagePosition.Clone() as ImagePoint;
                staticPoint = result.MaterialPosition.Clone() as StaticPoint;

                _ImagePoints.Add(imagePoint);
                _StaticPoints.Add(staticPoint);

                int curr = 1 + context.GetValue<int>(KEY_CURRENT_STEP);
                context.PutValue(KEY_CURRENT_STEP, curr);

                UpdateVisionRepeatLogs(curr, result);

                if (context.GetValue<int>(KEY_CURRENT_STEP) == _Params.RepeatCount) {
                    return SEQ_ID_SEQ_COMPLETE;
                }
                Thread.Sleep(300);
                return SEQ_ID_CLEAR;
            }
            else {
                context.PutValue<bool>(KEY_PATTERN_FOUND, false);
                return SEQ_ID_SEQ_COMPLETE;
            }
        }

        private void UpdateVisionRepeatLogs(int step, BaseResult result) {
            var visionRepeatRecipe = VisionRecipeManager.GetVisionRepeatRecipe(_Params.FovInfo);

            if (_Params.PatternInfo.PatternType == ePatternType.ShapeModelFinder) {
                var shapeResult = result as ShapeModelFinderResult;
                var imagePosition = shapeResult.ImagePosition.Clone();
                var materialPosition = shapeResult.MaterialPosition.Clone();

                var log = new VisionRepeatLog(
                    step, imagePosition.X, imagePosition.Y,
                    materialPosition.X, materialPosition.Y, shapeResult.Angle.Degree,
                    shapeResult.Width, shapeResult.Height, shapeResult.Radius);

                VisionEnv.AuroraEnv.EventPublisher.Publish(new EventMessage(
                _Params.FovInfo.GetKey(), VisionEventId.UPDATE_VISION_REPEAT_LOG, log));

                _CsvManager.SaveCsv(_FovInfo.ToSubSysInfo(), VisionRepeatResultItemManager.GetVisionRepeatLog(_FovInfo.ToSubSysInfo(), log), eSaveDataType.VisionRepeat);
            }

            else {
                var baseResult = result.Clone();
                var log = new VisionRepeatLog(
                    step, baseResult.ImagePosition.X, baseResult.ImagePosition.Y,
                    baseResult.MaterialPosition.X, baseResult.MaterialPosition.Y,
                    baseResult.Angle.Degree);

                VisionEnv.AuroraEnv.EventPublisher.Publish(new EventMessage(
                _Params.FovInfo.GetKey(), VisionEventId.UPDATE_VISION_REPEAT_LOG, log));

                _CsvManager.SaveCsv(_FovInfo.ToSubSysInfo(), VisionRepeatResultItemManager.GetVisionRepeatLog(_FovInfo.ToSubSysInfo(), log), eSaveDataType.VisionRepeat);
            }
        }

        private SequenceActionResult Clear(
           SequenceContext context,
           string id,
           SequenceActionResult param) {

            GrabFindSeqUtil.Clear(_Params.FovInfo.ToSubSysInfo());

            return SequenceAction.Ok();
        }

        private SequenceActionResult SeqComplete(
           SequenceContext context,
           string id,
           SequenceActionResult param) {

            return SequenceAction.Ok(new SetupSeqResultParams_VisionRepeat(_ImagePoints, _StaticPoints));
        }

        void OnStopped(
            SequenceContext context) {
            LOG.I($"{context.SequenceId} - STOP Handler");
            HandleAbnormalFinish(context);
        }

        void OnForceError(
            SequenceContext context, string id) {
            LOG.I($"{context.SequenceId} - FORCE ERROR Handler");
            HandleAbnormalFinish(context);
        }

        void HandleAbnormalFinish(
            SequenceContext context) {
        }
    }
}