using Aurora.Api;
using Aurora.Api.Devices;
using VisionCommon;
using VisionAligner;
using VisionCalibrator;
using VisionSequence.Pattern;
using VisionSequence.Inspector;
using Hermes;
using System.Collections.Generic;
using System.Linq;
using VisionInspector;
using VisionCommonUI;
using System;
using VisionCommonUI.Resources;

namespace VisionSequence.Aligner {
    /// <summary>
    /// C2_F4_MV 얼라인 시퀀스 파라미터
    /// </summary>
    public class AlignSeqParams_C2_F4_MV : SeqParamsBase {
        /// <summary>얼라인 키 정보</summary>
        public AlignInfo AlignInfo { get; set; }
        /// <summary>FOV별로 이동시킬 절대위치</summary>
        public Dictionary<eFovId, Position> FovPositions { get; set; }
        /// <summary>메인 화면 타입</summary>
        public eDisplayType DisplayType { get; set; }

        /// <summary>
        /// C2_F4_MV 얼라인 시퀀스 파라미터를 얻어온다.
        /// </summary>
        /// <param name="alignInfo">얼라인 키 정보</param>
        /// <param name="fovPositions">FOV별로 이동시킬 절대위치. null일 경우, 자동으로 Adapter에 정의된 티칭위치로 이동</param>
        /// <param name="displayType">메인 화면 타입</param>
        /// <param name="seqMode">시퀀스 모드</param>
        public AlignSeqParams_C2_F4_MV(
            AlignInfo alignInfo,
            Dictionary<eFovId, Position> fovPositions = null,
            eDisplayType displayType = eDisplayType.Main_1,
            eSeqMode seqMode = eSeqMode.Auto) : base(seqMode) {

            this.AlignInfo = alignInfo;
            this.FovPositions = fovPositions;
            this.DisplayType = displayType;
        }
    }

    /// <summary>
    /// CAM 2대 / FOV 4개 / 포지션 이동 (O) / 4 Point Align / 4 MeasurePatterns to 4 ReferencePatterns
    /// </summary>
    public class AlignSeq_C2_F4_MV : SubSeqBase {
        private readonly Logger LOG = new Logger(typeof(AlignSeq_C2_F4_MV).Name);

        private AlignSeqParams_C2_F4_MV _Params;
        private AlignRecipe _AlignRecipe;
        private SubSysInfo _SubSysInfo;
        private VisionAligner.Aligner _Aligner;
        private Calibrator _Calibrator;

        private Dictionary<eFovId, FovInfo> _FovInfos = new Dictionary<eFovId, FovInfo>();
        private Dictionary<eFovId, BaseResult> _MeasureResults = new Dictionary<eFovId, BaseResult>();
        private Dictionary<eFovId, BaseResult> _ReferenceResults = new Dictionary<eFovId, BaseResult>();

        private string _SeqName;
        private bool _IsForceOk = false;

        #region Sequence Id
        private const string SEQ_ID_INIT = "INIT";
        private const string SEQ_ID_CLEAR = "CLEAR";

        private const string SEQ_ID_SET_REFERENCE = "SET_REFERENCE";

        // FOV1, FOV2 동시 동작
        private const string SEQ_ID_FORK_1_2 = "FORK_1_2";
        private const string SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_1 = "SET_FIND_MEASURE_SEQ_PARAMS_1";
        private const string SEQ_ID_FIND_MEASURE_SEQ_1 = "FIND_MEASURE_SEQ_1";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_1 = "CHECK_MEASURE_FOUND_1";
        private const string SEQ_ID_SET_MEASURE_1 = "SET_MEASURE_1";

        private const string SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_2 = "SET_FIND_MEASURE_SEQ_PARAMS_2";
        private const string SEQ_ID_FIND_MEASURE_SEQ_2 = "FIND_MEASURE_SEQ_2";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_2 = "CHECK_MEASURE_FOUND_2";
        private const string SEQ_ID_SET_MEASURE_2 = "SET_MEASURE_2";
        private const string SEQ_ID_JOIN_1_2 = "JOIN_1_2";

        private const string SEQ_ID_MARK_NG = "MARK_NG";

        // FOV1, FOV2 패턴 거리 검사
        private const string SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2 = "CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2";
        private const string SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2 = "SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2";
        private const string SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_1_2 = "PATTERN_DISTANCE_INSP_SEQ_1_2";
        private const string SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_1_2 = "CHECK_PATTERN_DISTANCE_INSP_1_2";

        private const string SEQ_ID_DISTANCE_NG = "DISTANCE_NG";

        // FOV3, FOV4 동시 동작
        private const string SEQ_ID_MOVE_FOV_POS_3_4 = "MOVE_FOV_POS_3_4";
        private const string SEQ_ID_FORK_3_4 = "FORK_3_4";
        private const string SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_3 = "SET_FIND_MEASURE_SEQ_PARAMS_3";
        private const string SEQ_ID_FIND_MEASURE_SEQ_3 = "FIND_MEASURE_SEQ_3";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_3 = "CHECK_MEASURE_FOUND_3";
        private const string SEQ_ID_SET_MEASURE_3 = "SET_MEASURE_3";

        private const string SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_4 = "SET_FIND_MEASURE_SEQ_PARAMS_4";
        private const string SEQ_ID_FIND_MEASURE_SEQ_4 = "FIND_MEASURE_SEQ_4";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_4 = "CHECK_MEASURE_FOUND_4";
        private const string SEQ_ID_SET_MEASURE_4 = "SET_MEASURE_4";
        private const string SEQ_ID_JOIN_3_4 = "JOIN_3_4";

        // FOV3, FOV4 패턴 거리 검사
        private const string SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4 = "CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4";
        private const string SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4 = "SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4";
        private const string SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_3_4 = "PATTERN_DISTANCE_INSP_SEQ_3_4";
        private const string SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_3_4 = "CHECK_PATTERN_DISTANCE_INSP_3_4";

        private const string SEQ_ID_ALIGN = "ALIGN";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

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

        private void SetActions(SequenceBuilder sb) {
            SequenceBuilder grabFindProcSeqBuilder_1 = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder grabFindProcSeqBuilder_2 = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder grabFindProcSeqBuilder_3 = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder grabFindProcSeqBuilder_4 = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder patternDistanceInspSeqBuilder_1_2 = SubSeqManager.CreateSubSeqBuilder(new InspSeq_PatternDistance(), typeof(InspSeq_PatternDistance).Name);
            SequenceBuilder patternDistanceInspSeqBuilder_3_4 = SubSeqManager.CreateSubSeqBuilder(new InspSeq_PatternDistance(), typeof(InspSeq_PatternDistance).Name);

            sb.AddAction(SEQ_ID_INIT, Init);
            sb.AddAction(SEQ_ID_CLEAR, Clear);

            sb.AddAction(SEQ_ID_SET_REFERENCE, SetReference);

            // FOV1, FOV2 동시 동작
            sb.AddFork(SEQ_ID_FORK_1_2);
            sb.AddAction(SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_1, SetFindMeasureSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_MEASURE_SEQ_1, grabFindProcSeqBuilder_1);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_1, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_1, SetMeasure);

            sb.AddAction(SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_2, SetFindMeasureSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_MEASURE_SEQ_2, grabFindProcSeqBuilder_2);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_2, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_2, SetMeasure);
            sb.AddJoin(SEQ_ID_JOIN_1_2);

            sb.AddAction(SEQ_ID_MARK_NG, MarkNG);

            // FOV1, FOV2 패턴 거리 검사
            sb.AddDecision(SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2, CheckPatternDistanceInspEnabled);
            sb.AddAction(SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2, SetPatternDistanceInspSeqParams);
            sb.AddSubsequence(SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_1_2, patternDistanceInspSeqBuilder_1_2);
            sb.AddDecision(SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_1_2, CheckPatternDistanceInspStatus);

            sb.AddAction(SEQ_ID_DISTANCE_NG, DistanceNG);

            // FOV3, FOV4 동시 동작
            sb.AddAction(SEQ_ID_MOVE_FOV_POS_3_4, MoveFovPos);
            sb.AddFork(SEQ_ID_FORK_3_4);
            sb.AddAction(SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_3, SetFindMeasureSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_MEASURE_SEQ_3, grabFindProcSeqBuilder_3);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_3, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_3, SetMeasure);

            sb.AddAction(SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_4, SetFindMeasureSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_MEASURE_SEQ_4, grabFindProcSeqBuilder_4);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_4, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_4, SetMeasure);
            sb.AddJoin(SEQ_ID_JOIN_3_4);

            // FOV3, FOV4 패턴 거리 검사
            sb.AddDecision(SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4, CheckPatternDistanceInspEnabled);
            sb.AddAction(SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4, SetPatternDistanceInspSeqParams);
            sb.AddSubsequence(SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_3_4, patternDistanceInspSeqBuilder_3_4);
            sb.AddDecision(SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_3_4, CheckPatternDistanceInspStatus);

            sb.AddAction(SEQ_ID_ALIGN, Align);
            sb.AddAction(SEQ_ID_SEQ_COMPLETE, SeqComplete);
        }

        public override SequenceBuilder Builder(string seqName) {
            _SeqName = seqName;

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

            sb.Flows(
                  sb.Init
                > sb[SEQ_ID_INIT]
                > sb[SEQ_ID_CLEAR]
                > sb[SEQ_ID_SET_REFERENCE]

                > sb[SEQ_ID_FORK_1_2]
                > sb[SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_1]
                > sb[SEQ_ID_FIND_MEASURE_SEQ_1]     // FOV1 패턴 찾기
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_1]
                > sb[SEQ_ID_SET_MEASURE_1]
                > sb[SEQ_ID_JOIN_1_2]

                > sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2]
                > sb[SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2]   // FOV1, FOV2 패턴 거리 검사
                > sb[SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_1_2]
                > sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_1_2]

                > sb[SEQ_ID_MOVE_FOV_POS_3_4]       // FOV3, FOV4 측정위치로 이동
                > sb[SEQ_ID_FORK_3_4]
                > sb[SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_3]
                > sb[SEQ_ID_FIND_MEASURE_SEQ_3]     // FOV3 패턴 찾기
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_3]
                > sb[SEQ_ID_SET_MEASURE_3]
                > sb[SEQ_ID_JOIN_3_4]

                > sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4]
                > sb[SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4]   // FOV3, FOV4 패턴 거리 검사
                > sb[SEQ_ID_PATTERN_DISTANCE_INSP_SEQ_3_4]
                > sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_3_4]

                > sb[SEQ_ID_ALIGN]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_FORK_1_2]
                > sb[SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_2]
                > sb[SEQ_ID_FIND_MEASURE_SEQ_2]     // FOV2 패턴 찾기
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_2]
                > sb[SEQ_ID_SET_MEASURE_2]
                > sb[SEQ_ID_JOIN_1_2]
                );
            sb.Flows(
                  sb[SEQ_ID_FORK_3_4]
                > sb[SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_4]
                > sb[SEQ_ID_FIND_MEASURE_SEQ_4]     // FOV4 패턴 찾기
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_4]
                > sb[SEQ_ID_SET_MEASURE_4]
                > sb[SEQ_ID_JOIN_3_4]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_1]      // FOV1 마크 NG
                > sb[SEQ_ID_MARK_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_1]      // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_2]      // FOV2 마크 NG
                > sb[SEQ_ID_MARK_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_2]      // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_3]      // FOV3 마크 NG
                > sb[SEQ_ID_MARK_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_3]      // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_4]      // FOV4 마크 NG
                > sb[SEQ_ID_MARK_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_4]      // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2]    // FOV1, FOV2 패턴 거리 검사 Skip후 FOV3, FOV4 위치로 이동
                > sb[SEQ_ID_MOVE_FOV_POS_3_4]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2]    // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4]    // FOV3, FOV4 패턴 거리 검사 Skip후 Align
                > sb[SEQ_ID_ALIGN]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4]    // Node Error
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_1_2]     // FOV1, FOV2 패턴 거리 검사 NG
                > sb[SEQ_ID_DISTANCE_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_3_4]     // FOV3, FOV4 패턴 거리 검사 NG
                > sb[SEQ_ID_DISTANCE_NG]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_SEQ_COMPLETE]
                > sb.Final
                );

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

            return sb;
        }

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

            if (param.Param != null) {
                _Params = param.Param as AlignSeqParams_C2_F4_MV;
            }
            else {
                LOG.E($"Param is null.");
                return null;
            }

            _IsForceOk = false;
            _AlignRecipe = VisionRecipeManager.GetAlignRecipe(_Params.AlignInfo);
            _SubSysInfo = _Params.AlignInfo.ToSubSysInfo();
            _Aligner = AlignAgentManager.GetAlignAgent(_Params.AlignInfo);

            SetFovInfos();
            _Calibrator = CalibratorManager.GetCalibrator(_FovInfos[eFovId.Fov1]);

            return SequenceAction.Ok();
        }

        private void SetFovInfos() {
            foreach (FovInfo fovInfo in VisionRecipeManager.GetFovInfos(_SubSysInfo)) {
                if (!_FovInfos.ContainsKey(fovInfo.FovId)) {
                    _FovInfos.Add(fovInfo.FovId, fovInfo);
                }
            }
        }

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

            _MeasureResults.Clear();
            _ReferenceResults.Clear();

            return SequenceAction.Ok();
        }

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

            foreach (var fovInfoPair in _FovInfos) {
                eFovId fovId = fovInfoPair.Key;
                var refMaterialPos = VisionRecipeManager.GetRefPoint(_SubSysInfo, fovId);
                _ReferenceResults.Add(
                    fovId,
                    new BaseResult() { MaterialPosition = refMaterialPos.Clone() as StaticPoint });
            }

            return SequenceAction.Ok();
        }

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

            eFovId curFovId = eFovId.None;
            switch (id) {
                case SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_1:
                    curFovId = eFovId.Fov1;
                    break;
                case SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_2:
                    curFovId = eFovId.Fov2;
                    break;
                case SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_3:
                    curFovId = eFovId.Fov3;
                    break;
                case SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS_4:
                    curFovId = eFovId.Fov4;
                    break;
            }

            var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfos[curFovId], _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern1);
            var fovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfos[curFovId]);
            PatternIndex patternIndex = null;
            var patternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
            if (procPatternInfo.IsFovPattern) {
                patternIndex = new FovPatternIndex(_FovInfos[curFovId], fovRecipe.FovName, procPatternInfo.PatternId);
            }
            else {
                patternAgent = CamPatternAgentManager.GetAgent(fovRecipe.CamRecipe.CamId);
                patternIndex = new CamPatternIndex(fovRecipe.CamRecipe.CamId, procPatternInfo.PatternId);
            }
            PatternInfo patternInfo = patternAgent.GetPatternInfo(patternIndex);
            patternInfo.PatternName = procPatternInfo.PatternName;

            return SequenceAction.Ok(new GrabFindProcSeqParams(_FovInfos[curFovId], patternInfo, _Params.DisplayType, _Params.SeqMode));
        }

        private string CheckFound(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {

            var patternResult = param.Param as PatternResult;

            if (patternResult.Status != eFoundStatus.NotFound) {
                if (patternResult.Status == eFoundStatus.ForceOK) {
                    _IsForceOk = true;
                }

                switch (patternResult.FovId) {
                    case eFovId.Fov1:
                        return SEQ_ID_SET_MEASURE_1;
                    case eFovId.Fov2:
                        return SEQ_ID_SET_MEASURE_2;
                    case eFovId.Fov3:
                        return SEQ_ID_SET_MEASURE_3;
                    case eFovId.Fov4:
                        return SEQ_ID_SET_MEASURE_4;
                }
            }
            else {
                return SEQ_ID_MARK_NG;
            }

            LOG.FuncE("CheckFound Node Error!!");
            return SEQ_ID_SEQ_COMPLETE;
        }

        private SequenceActionResult SetMeasure(
            SequenceContext context,
            string id,
            SequenceActionResult param) {   // Param : PatternResult

            try {
                var patternResult = param.Param as PatternResult;
                var baseResults = patternResult.Results.ToList();
                _MeasureResults.Add(patternResult.FovId, baseResults[0]);
            }
            catch (Exception e) {
                LOG.FuncE(e.Message);
            }

            return SequenceAction.Ok();
        }

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

            context.PutValue<AlignResult>(
                string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()),
                new AlignResult() {
                    AlignName = _AlignRecipe.AlignName,
                    Status = AlignStatus.NOT_FOUND,
                    AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm,
                });

            return SequenceAction.Ok();
        }

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

            eFovId curFovId = eFovId.Fov3;     // FOV3, FOV4 동일 위치

            if (EquipAdapter.Instance.EquipMode.IsSimulMode()) {
                return SequenceAction.Ok();
            }

            int res = E1.GENERIC;
            if (_Params.FovPositions != null && _Params.FovPositions.ContainsKey(curFovId)) {
                // 파라미터로 넘겨받은 절대위치로 이동
                res = EquipAdapter.Instance.TeachingMotionManager.AbsMove(_FovInfos[curFovId], _Params.FovPositions[curFovId]);
            }
            else {
                // Adapter에 정의된 티칭위치로 이동
                res = EquipAdapter.Instance.TeachingMotionManager.MovePosition(_FovInfos[curFovId], ePositionType.Teaching);
            }

            if (res == E1.OK) {
                ApplyGrabDelay(_SubSysInfo);
                return SequenceAction.Ok();
            }
            else {
                return SequenceAction.Error(E2.ABORTED);
            }
        }

        #region 패턴 간에 거리 검사
        private string CheckPatternDistanceInspEnabled(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {

            switch (id) {
                case SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_1_2:
                    if (_AlignRecipe.InspParams.PatternDistanceParam.Enabled) {
                        return SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2;
                    }
                    else {
                        return SEQ_ID_MOVE_FOV_POS_3_4;
                    }
                case SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_ENABLED_3_4:
                    if (_AlignRecipe.InspParams.PatternDistanceParam.Enabled) {
                        return SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4;
                    }
                    else {
                        return SEQ_ID_ALIGN;
                    }
            }

            LOG.FuncE("CheckPatternDistanceInspEnabled Node Error!!");
            return SEQ_ID_SEQ_COMPLETE;
        }

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

            var measureResult = new Dictionary<eFovId, BaseResult>();
            switch (id) {
                case SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_1_2:
                    measureResult.Add(eFovId.Fov1, _MeasureResults[eFovId.Fov1]);
                    measureResult.Add(eFovId.Fov2, _MeasureResults[eFovId.Fov2]);
                    break;
                case SEQ_ID_SET_PATTERN_DISTANCE_INSP_SEQ_PARAMS_3_4:
                    measureResult = _MeasureResults;
                    break;
            }

            return SequenceAction.Ok(
                new InspSeqParams_PatternDistance(_Params.AlignInfo, measureResult));
        }

        private string CheckPatternDistanceInspStatus(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {   // Param : List<PatternDistanceResult>

            var patternDistanceResults = param.Param as List<PatternDistanceResult>;

            foreach (PatternDistanceResult result in patternDistanceResults) {
                if (result.InspStatus == InspStatus.NG) {
                    return SEQ_ID_DISTANCE_NG;
                }
                else {
                    continue;
                }
            }

            if (id == SEQ_ID_CHECK_PATTERN_DISTANCE_INSP_STATUS_1_2) {
                return SEQ_ID_MOVE_FOV_POS_3_4;     // FOV3, FOV4 위치로 이동
            }
            else {
                return SEQ_ID_ALIGN;
            }
        }

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

            context.PutValue<AlignResult>(
                string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()),
                new AlignResult() {
                    AlignName = _AlignRecipe.AlignName,
                    Status = AlignStatus.DISTANCE_NG,
                    AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm,
                });

            return SequenceAction.Ok();
        }
        #endregion

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

            var meaPoints = new List<DoublePoint>();
            var refPoints = new List<DoublePoint>();
            _MeasureResults = _MeasureResults.OrderBy(obj => obj.Key).ToDictionary(obj => obj.Key, obj => obj.Value);

            foreach (var meaResultPair in _MeasureResults) {
                meaPoints.Add((meaResultPair.Value as BaseResult).MaterialPosition);

                foreach (var refResultPair in _ReferenceResults) {
                    if (refResultPair.Key == meaResultPair.Key) {
                        refPoints.Add((refResultPair.Value as BaseResult).MaterialPosition);
                        break;
                    }
                }
            }

            if (IsFixedLineIntersections(_Params.AlignInfo)) {
                meaPoints = LineFittingManager.GetFixedMeasurePoints(_SubSysInfo);
                LineFittingManager.DrawFixedLinesAndIntersects(_SubSysInfo, eDisplayType.Main_1);
            }

            var flipY = (int)_Calibrator.GetFlipY();
            var alignResult = _Aligner.Align(meaPoints, refPoints, flipY);

            if (alignResult == null) {
                return SequenceAction.Error();
            }
            else {
                context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()), alignResult);
            }

            return SequenceAction.Ok(alignResult);
        }

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

            AlignResult alignResult = context.GetValue<AlignResult>(string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()));
            if (alignResult == null) {
                return SequenceAction.Error();
            }

            alignResult.AlignName = _AlignRecipe.AlignName;
            if (_IsForceOk && alignResult.Status == AlignStatus.OK) {
                alignResult.Status = AlignStatus.F_OK;
            }

            if (_MeasureResults.Keys.Count > 0) {
                context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_LAST_MEASURE_FOV_ID, _Params.AlignInfo.GetKey()), _MeasureResults.Keys.ToList().Max());
            }

            return SequenceAction.Ok(alignResult);
        }

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

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

        void HandleAbnormalFinish(
            SequenceContext context) {
        }
    }
}