using Aurora.Api;
using VisionCommon;
using VisionSequence.Pattern;
using Hermes;
using System.Collections.Generic;
using VisionCommonUI;
using VisionCommonUI.Resources;
using VisionSequence.Aligner;
using VisionInspector;
using System;

namespace VisionSequence.Inspector {
    /// <summary>
    /// 선폭 검사 시퀀스 파라미터
    /// </summary>
    public class InspSeqParams_LineWidth {
        /// <summary>FOV 키 정보</summary>
        public FovInfo FovInfo { get; set; }
        /// <summary>메인 화면 타입</summary>
        public eDisplayType DisplayType { get; set; }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="fovInfo">FOV 키 정보</param>
        /// <param name="displayType">메인 화면 타입</param>
        public InspSeqParams_LineWidth(
            FovInfo fovInfo,
            eDisplayType displayType = eDisplayType.Main_1) {

            this.FovInfo = fovInfo;
            this.DisplayType = displayType;
        }
    }

    /// <summary>
    /// 수평, 수직 각각에서 두 라인 간에 선폭 검사 (서브시퀀스로 호출해서 사용)
    /// </summary>
    public class InspSeq_LineWidth : SubSeqBase {
        private readonly Logger LOG = new Logger(typeof(InspSeq_LineWidth).Name);
        private InspSeqParams_LineWidth _Params;
        private CsvManager _CsvManager = new CsvManager();
        //private ImageManager _ImageManager = new ImageManager();
        private PatternAgentBase _PatternAgent;
        private AttachInspector _AttachInspector;

        private SubSysInfo _SubSysInfo;
        private FovRecipe _FovRecipe;

        private CaliperResult _CaliperResult_H;     // 수평라인 선폭 측정 결과
        private CaliperResult _CaliperResult_W;     // 수직라인 선폭 측정 결과

        private AttachInspResult _AttachInspResult;

        private string _SeqName;

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

        private const string SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_H = "SET_GRAB_FIND_PROC_SEQ_PARAMS_H";
        private const string SEQ_ID_GRAB_FIND_PROC_SEQ_H = "GRAB_FIND_PROC_SEQ_H";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_H = "CHECK_MEASURE_FOUND_H";
        private const string SEQ_ID_SET_MEASURE_H = "SET_MEASURE_H";

        private const string SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_W = "SET_GRAB_FIND_PROC_SEQ_PARAMS_W";
        private const string SEQ_ID_GRAB_FIND_PROC_SEQ_W = "GRAB_FIND_PROC_SEQ_W";
        private const string SEQ_ID_CHECK_MEASURE_FOUND_W = "CHECK_MEASURE_FOUND_W";
        private const string SEQ_ID_SET_MEASURE_W = "SET_MEASURE_W";

        private const string SEQ_ID_NOT_FOUND_NG = "NOT_FOUND_NG";
        private const string SEQ_ID_CHECK_STATUS = "CHECK_STATUS";
        private const string SEQ_ID_SPEC_OVER_NG = "SPEC_OVER_NG";

        private const string SEQ_ID_UPDATE_UI = "UPDATE_UI";
        private const string SEQ_ID_SAVE_CSV = "SAVE_CSV";
        //private const string SEQ_ID_SAVE_SCREENSHOT = "SAVE_SCREENSHOT";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

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

        private void SetActions(SequenceBuilder sb) {
            SequenceBuilder grabFindProcSeqBuilder_Fixture = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder grabFindProcSeqBuilder_H = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);
            SequenceBuilder grabFindProcSeqBuilder_W = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);

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

            sb.AddAction(SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_H, SetGrabFindProcSeqParams);
            sb.AddSubsequence(SEQ_ID_GRAB_FIND_PROC_SEQ_H, grabFindProcSeqBuilder_H);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_H, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_H, SetMeasure);

            sb.AddAction(SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_W, SetGrabFindProcSeqParams);
            sb.AddSubsequence(SEQ_ID_GRAB_FIND_PROC_SEQ_W, grabFindProcSeqBuilder_W);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND_W, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE_W, SetMeasure);

            sb.AddAction(SEQ_ID_NOT_FOUND_NG, NotFoundNG);
            sb.AddDecision(SEQ_ID_CHECK_STATUS, CheckStatus);
            sb.AddAction(SEQ_ID_SPEC_OVER_NG, SpecOverNG);

            sb.AddAction(SEQ_ID_UPDATE_UI, UpdateUI);
            sb.AddAction(SEQ_ID_SAVE_CSV, SaveCsv);
            //sb.AddAction(SEQ_ID_SAVE_SCREENSHOT, SaveScreenShot);
            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_GRAB_FIND_PROC_SEQ_PARAMS_H]
                > sb[SEQ_ID_GRAB_FIND_PROC_SEQ_H]
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_H]
                > sb[SEQ_ID_SET_MEASURE_H]

                > sb[SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_W]
                > sb[SEQ_ID_GRAB_FIND_PROC_SEQ_W]
                > sb[SEQ_ID_CHECK_MEASURE_FOUND_W]
                > sb[SEQ_ID_SET_MEASURE_W]

                > sb[SEQ_ID_CHECK_STATUS]
                > sb[SEQ_ID_UPDATE_UI]
                > sb[SEQ_ID_SAVE_CSV]
                //> sb[SEQ_ID_SAVE_SCREENSHOT]

                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_H]
                > sb[SEQ_ID_NOT_FOUND_NG]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND_W]
                > sb[SEQ_ID_NOT_FOUND_NG]
                );
            sb.Flows(
                  sb[SEQ_ID_NOT_FOUND_NG]
                > sb[SEQ_ID_UPDATE_UI]
                > sb[SEQ_ID_SAVE_CSV]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_STATUS]
                > sb[SEQ_ID_SPEC_OVER_NG]
                );
            sb.Flows(
                  sb[SEQ_ID_SPEC_OVER_NG]
                > sb[SEQ_ID_UPDATE_UI]
                > sb[SEQ_ID_SAVE_CSV]
                > 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 InspSeqParams_LineWidth;
            }
            else {
                MessageBoxUtil.ShowMessageBoxError(
                    string.Format(StrTokens.MSG_E_ParamIsNull));
                return SequenceAction.Error(E1.ARGUMENT);
            }

            _SubSysInfo = _Params.FovInfo.ToSubSysInfo();
            _FovRecipe = VisionRecipeManager.GetFovRecipe(_Params.FovInfo);
            _PatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
            _AttachInspector = new AttachInspector(_SubSysInfo);

            return SequenceAction.Ok();
        }

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

            var cameraDisplay = CameraDisplayManager.GetDisplay(_Params.FovInfo, _Params.DisplayType);
            cameraDisplay.ClearAllGraphics();
            GrabFindSeqUtil.Clear(_Params.FovInfo);

            _CaliperResult_H = null;
            _CaliperResult_W = null;
            _AttachInspResult = null;

            return SequenceAction.Ok();
        }

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

            ProcPatternInfo procPatternInfo = null;
            switch (id) {
                case SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_H:
                    procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_Params.FovInfo, "Inspect", eProcPatternId.ProcPattern1);
                    break;
                case SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS_W:
                    procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_Params.FovInfo, "Inspect", eProcPatternId.ProcPattern2);
                    break;
            }

            var patternInfo = _PatternAgent.GetPatternInfo(_Params.FovInfo, procPatternInfo.PatternId);
            patternInfo.PatternName = procPatternInfo.PatternName;

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

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

            var patternResult = param.Param as PatternResult;

            switch (id) {
                case SEQ_ID_CHECK_MEASURE_FOUND_H:
                    if (patternResult.Status == eFoundStatus.FoundOK) {
                        return SEQ_ID_SET_MEASURE_H;
                    }
                    break;
                case SEQ_ID_CHECK_MEASURE_FOUND_W:
                    if (patternResult.Status == eFoundStatus.FoundOK) {
                        return SEQ_ID_SET_MEASURE_W;
                    }
                    break;
            }
            return SEQ_ID_NOT_FOUND_NG;
        }

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

            LOG.E("Not Found NG!!");

            var attachInspRecipe = VisionRecipeManager.GetAttachInspRecipe(_SubSysInfo);
            var attachInspParam = attachInspRecipe.AttachInspParams[(int)_Params.FovInfo.FovId];
            var measureW = (_CaliperResult_W != null) ? _CaliperResult_W.WidthMm : 0;
            var measureH = (_CaliperResult_H != null) ? _CaliperResult_H.WidthMm : 0;

            // NG - Attach Insp Result
            _AttachInspResult = new AttachInspResult(
                _Params.DisplayType,
                _Params.FovInfo.FovId,
                measureW,
                attachInspParam.SpecW,
                measureH,
                attachInspParam.SpecH,
                InspStatus.NG);

            return SequenceAction.Ok();
        }

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

            var patternResult = param.Param as PatternResult;

            switch (id) {
                case SEQ_ID_SET_MEASURE_H:
                    foreach (var result in patternResult.Results) {
                        _CaliperResult_H = (result as CaliperResult)?.Clone();
                        break;
                    }
                    break;
                case SEQ_ID_SET_MEASURE_W:
                    foreach (var result in patternResult.Results) {
                        _CaliperResult_W = (result as CaliperResult)?.Clone();
                        break;
                    }
                    break;
            }

            return SequenceAction.Ok();
        }

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

            _AttachInspResult = _AttachInspector.InspectDistances(
                _Params.FovInfo,
                _Params.DisplayType,
                _CaliperResult_H,
                _CaliperResult_W);

            if (_AttachInspResult.InspStatus == InspStatus.OK) {
                return SEQ_ID_UPDATE_UI;
            }
            else {
                return SEQ_ID_SPEC_OVER_NG;
            }
        }

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

            LOG.E("Spec Over NG!!");

            return SequenceAction.Ok();
        }

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

            VisionEnv.AuroraEnv.EventPublisher.Publish(
                new EventMessage(_SubSysInfo.GetKey(), VisionEventId.UPDATE_ATTACH_INSP_RESULT, _AttachInspResult));

            return SequenceAction.Ok();
        }

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

            _CsvManager.SaveCsv(_SubSysInfo, AttachInspResultItemManager.GetAttachInspResultItem(_SubSysInfo, _AttachInspResult), eSaveDataType.AttachInsp);

            return SequenceAction.Ok();
        }

        //private SequenceActionResult SaveScreenShot(
        //    SequenceContext context,
        //    string id,
        //    SequenceActionResult param) {

        //    if (EquipAdapter.Instance.EquipMode.IsNotDryrunAndTransferMode()) {
        //        var patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_LINE_WIDTH_RESULT, _Params.FovInfo.GetKey(), _Params.ProcPatternInfo.PatternId));
        //        var materialInfo = context.GetValue<MaterialInfo>(VisionContextKeys.CNTXT_KEY_MATERIAL_INFO);

        //        if (IsFoundStatusNG(patternResult.Status) || VisionSettingManager.VisionSetting.SaveOkSceenShotImage) {
        //            _ImageManager.SaveScreenShot(
        //            _Params.FovInfo, patternResult.Status.ToString(), materialInfo, _Params.DisplayType,
        //            AttachInspResultItemManager.GetTimeStamp(_SubSysInfo, patternResult));
        //        }
        //    }

        //    return SequenceAction.Ok();
        //}

        //private bool IsFoundStatusNG(InspStatus status) {
        //    switch (status) {
        //        case InspStatus.NONE:
        //        case InspStatus.NG:
        //            return true;
        //        default:
        //            return false;
        //    }
        //}

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

            context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_ATTACH_INSP_RESULT, _Params.FovInfo.GetKey()), _AttachInspResult);

            return SequenceAction.Ok(_AttachInspResult);
        }

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

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

        void HandleAbnormalFinish(SequenceContext context) {
        }
    }
}