using Aurora.Api;
using VisionCalibrator;
using VisionCommon;
using System.Collections.Generic;

namespace VisionSequence.Pattern {
    /// <summary>
    /// 패턴 검출 시퀀스 파라미터
    /// </summary>
    public class FindSeqParams : GrabFindProcSeqParams {
        /// <summary>패턴 검출을 위한 이미지</summary>
        public object GrabImage { get; set; }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="grabImage">패턴 검출을 위한 이미지</param>
        /// <param name="fovInfo">FOV 키 정보</param>
        /// <param name="patternInfo">패턴 정보</param>
        /// <param name="displayType">메인 화면 타입</param>
        /// <param name="seqMode">매뉴얼 시퀀스 플래그</param>
        public FindSeqParams(
            object grabImage,
            FovInfo fovInfo,
            PatternInfo patternInfo,
            eDisplayType displayType = eDisplayType.Main_1,
            eSeqMode seqMode = eSeqMode.Auto) : base(fovInfo, patternInfo, displayType, seqMode) {

            this.GrabImage = grabImage;
        }
    }

    /// <summary>
    /// 패턴 검출 시퀀스
    /// </summary>
    public class FindSeq : SubSeqBase {
        private readonly Logger LOG = new Logger(typeof(FindSeq).Name);

        private ICameraDisplay _CameraDisplay;
        private FindSeqParams _Params;
        private FovRecipe _FovRecipe;
        private PatternAgentBase _PatternAgent;
        private Calibrator _Calibrator;
        private CameraAgentBase _CameraAgent;
        private ImageManager _ImageManager = new ImageManager();

        private string _SeqName;

        #region Sequence Id
        private const string SEQ_ID_INIT = "INIT";
        private const string SEQ_ID_HAS_FIXTURE = "HAS_FIXTURE";
        private const string SEQ_ID_FIND_FIXTURE = "FIND_FIXTURE";
        private const string SEQ_ID_FIND = "FIND";
        private const string SEQ_ID_FIND_OK = "FIND_OK";
        private const string SEQ_ID_FIND_NG = "FIND_NG";
        //private const string SEQ_ID_SCORE_NG = "SCORE_NG";
        private const string SEQ_ID_UPDATE_UI = "UPDATE_UI";
        private const string SEQ_ID_SAVE_IMAGE = "SAVE_IMAGE";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

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

        private void SetActions(SequenceBuilder sb) {
            sb.AddAction(SEQ_ID_INIT, Init);
            sb.AddDecision(SEQ_ID_HAS_FIXTURE, HasFixture);
            sb.AddAction(SEQ_ID_FIND_FIXTURE, FindFixture);
            sb.AddDecision(SEQ_ID_FIND, Find);
            sb.AddAction(SEQ_ID_FIND_OK, Find_OK);
            sb.AddAction(SEQ_ID_FIND_NG, Find_NG);
            //sb.AddAction(SEQ_ID_SCORE_NG, Score_NG);
            sb.AddAction(SEQ_ID_UPDATE_UI, UpdateUI);
            sb.AddAction(SEQ_ID_SAVE_IMAGE, SaveImage);
            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_HAS_FIXTURE])
                .Flows(sb[SEQ_ID_HAS_FIXTURE] > sb[SEQ_ID_FIND_FIXTURE] > sb[SEQ_ID_FIND])
                .Flows(sb[SEQ_ID_HAS_FIXTURE] > sb[SEQ_ID_FIND]);

            sb.Flows(
                  sb[SEQ_ID_FIND]
                > sb[SEQ_ID_FIND_OK]
                > sb[SEQ_ID_UPDATE_UI]
                );

            sb.Flows(
                  sb[SEQ_ID_FIND]
                > sb[SEQ_ID_FIND_NG]
                > sb[SEQ_ID_UPDATE_UI]
                //> sb.ForceError   // null로 끝내지 않고, 상위에 PatternResult를 넘겨주기로 함.
                );

            sb.Flows(
                  sb[SEQ_ID_UPDATE_UI]
                > sb[SEQ_ID_SAVE_IMAGE]
                > 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 FindSeqParams;
            }
            else {
                LOG.E($"_Params is null!");
                return null;
            }

            _FovRecipe = VisionRecipeManager.GetFovRecipe(_Params.FovInfo);

            SetPatternAgent();
            SetCalibrator();
            SetCameraAgent();
            SetDisplay();

            return SequenceAction.Ok();
        }

        private void SetPatternAgent() {
            var patternIndex = _Params.PatternInfo.GetPatternIndex();
            if (patternIndex is FovPatternIndex) {
                _PatternAgent = FovPatternAgentManager.GetAgent(_Params.FovInfo.ToSubSysInfo());
            }
            else if (patternIndex is CamPatternIndex) {
                var camPatternIndex = patternIndex as CamPatternIndex;
                _PatternAgent = CamPatternAgentManager.GetAgent(camPatternIndex.CamId);
            }
        }

        private void SetCalibrator() {
            _Calibrator = CalibratorManager.GetCalibrator(_Params.FovInfo);
        }

        private void SetCameraAgent() {
            _CameraAgent = CameraAgentManager.GetCameraAgent(_Params.FovInfo);
        }

        private void SetDisplay() {
            _CameraDisplay = CameraDisplayManager.GetDisplay(_Params.FovInfo, _Params.DisplayType);
        }

        private string HasFixture(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {
            if (_Params.PatternInfo.FixtureSetting.Enabled) {
                return SEQ_ID_FIND_FIXTURE;
            }

            return SEQ_ID_FIND;
        }

        private SequenceActionResult FindFixture(
            SequenceContext context,
            string id,
            SequenceActionResult param) {
            var fixturePatternIndex = FixtureSetting.GetFixturePatternIndex(
                _Params.PatternInfo.GetPatternIndex(),
                _Params.PatternInfo.FixtureSetting.Pattern1);
            var fixturePatternInfo = _PatternAgent.GetPatternInfo(fixturePatternIndex);

            var patternResult = _PatternAgent.Find(fixturePatternInfo, _Params.GrabImage, _CameraDisplay);
            GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref patternResult);
            _PatternAgent.Draw(fixturePatternInfo, patternResult, _CameraDisplay, isFixturePattern: true);

            if (patternResult.Status == eFoundStatus.FoundOK) {
                LOG.I($"Fixture PatternResult : {patternResult}");
                LOG.I($"FixtureResult : {patternResult.MoreInfo as FixtureResult}");

                return SequenceAction.Ok(patternResult);
            }

            LOG.E($"Fxiture Pattern Not Found! : {fixturePatternInfo}");
            return null;
        }

        private string Find(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {
            PatternResult patternResult;

            if (_Params.PatternInfo.FixtureSetting.Enabled) {
                if (param.Param == null || (param.Param as PatternResult) == null) {
                    LOG.E($"Fixture PatternResult is null");
                    return null;
                }

                var fixturePatternResult = param.Param as PatternResult;
                var fixtureResult = fixturePatternResult.MoreInfo as FixtureResult;
                patternResult = _PatternAgent.Find(
                    _Params.PatternInfo, _Params.GrabImage, _CameraDisplay, fixtureResult);
                GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref patternResult);
                _PatternAgent.Draw(
                    _Params.PatternInfo,
                    patternResult,
                    _CameraDisplay);
                //_CameraDisplay.DrawRefCross();
            }
            else {
                patternResult = _PatternAgent.Find(
                    _Params.PatternInfo, _Params.GrabImage, _CameraDisplay);
                GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref patternResult);
                _PatternAgent.Draw(_Params.PatternInfo, patternResult, _CameraDisplay, isFixturePattern: false);
            }

            patternResult.PatternName = _Params.PatternInfo.PatternName;
            patternResult.PatternType = _Params.PatternInfo.PatternType;
            patternResult.FovId = _Params.FovInfo.FovId;

            context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_RESULT, _Params.FovInfo.GetKey()), patternResult);

            if (patternResult.Status == eFoundStatus.FoundOK) {
                LOG.I($"PatternResult : {patternResult}");

                return SEQ_ID_FIND_OK;
            }
            else {
                return SEQ_ID_FIND_NG;
            }
        }

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

            return SequenceAction.Ok();
        }

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

            return SequenceAction.Ok();
        }

        //private SequenceActionResult Score_NG(
        //    SequenceContext context,
        //    string id,
        //    SequenceActionResult param) {
        //
        //    var patternResult = GrabFindSeqUtil.GetMainPatternResult(_Params.FovInfo);
        //
        //    return null;
        //}

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

            if (_Params.SeqMode == eSeqMode.Auto) {
                var patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_RESULT, _Params.FovInfo.GetKey()));
                VisionEnv.AuroraEnv.EventPublisher.Publish(new EventMessage(
                    _Params.FovInfo.GetKey(), VisionEventId.UPDATE_PATTERN_RESULT, patternResult));
            }

            return SequenceAction.Ok();
        }

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

            if (_Params.SeqMode == eSeqMode.Auto) {
                var patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_RESULT, _Params.FovInfo.GetKey()));
                var materialInfo = context.GetValue<MaterialInfo>(VisionContextKeys.CNTXT_KEY_MATERIAL_INFO);

                if (patternResult.Status == eFoundStatus.FoundOK) {
                    if (VisionSettingManager.VisionSetting.SaveOkImage == false) {
                        return SequenceAction.Ok();
                    }
                }
                _ImageManager.SaveImage(_Params.FovInfo, _Params.GrabImage, patternResult.Status.ToString(), materialInfo);
            }

            return SequenceAction.Ok();
        }

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

            var patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_RESULT, _Params.FovInfo.GetKey()));
            return SequenceAction.Ok(patternResult);  // Param : patternResult
        }

        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) {
        }
    }
}