using Aurora;
using Aurora.Api;
using Aurora.Api.Devices;
using Aurora.Api.Services;
using Aurora.View;
using AuroraACS;
using AuroraIO;
using AuroraLaser;
using AuroraLaser.Ekspla;
using AuroraLaser.Trumpf;
using AuroraLaserScanner;
using AuroraLBAD;
using AuroraLBAD.Services;
using AuroraOCT;
using CoreUnit.Control.UserControl.Canvas;
using CoreUnit.Scanner.UserControl.ScannerCanvas;
using DB;
using GUI;
using Hermes;
using ILSOS_PrismaticScanner.Device;
using ILSOS_PrismaticScanner.Device.IO;
using Matrox.MatroxImagingLibrary;
using OpenCvSharp.Dnn;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using VisionCommon;
using WeldingCommon;
using WeldingCommon.Alarm;
using WeldingCommon.Data;
using WeldingCommon.Devices.ACS;  // 26.04.06 
using WeldingCommon.Sequences;
using WeldingCommon.Settings;
using WeldingCommon.Utils;
using WeldingCommon.Views;
using static AuroraIO.AJINEXTEK.AjinIO.IOModuleInfo;
using static AuroraIO.Vendor.PAIX.PAIXIO;
using static CoreUnit.Scanner.UserControl.ScannerCanvas.ScannerParam;
using static ILSOS_PrismaticScanner.Device.PLCControllerPrismaticScanner;

namespace ILSOS_PrismaticScanner.Sequences
{
    public class SeqComponentTeachingRun
    {
        static readonly Logger Log = new Logger("SeqComponentTeachingRun");

        const string SEQ_ENTER = "[SeqComponentTeachingRun] SEQ_ENTER";   // inputParam 으로 받자.
        const string SEQ_CHECK_INIT_CONDITION = "[SeqComponentTeachingRun] Check Init Condition";  // Check Init Condition

        const string SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ = "[SeqComponentTeachingRun] Set Sequence Param (UploadWeldingList Seq)";
        const string SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ = "[SeqComponentTeachingRun] Process (UploadWeldingList Seq)";
        const string SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ = "[SeqComponentTeachingRun] Get Sequence Result (UploadWeldingList Seq)";
        const string SEQ_SET_BLOW_ON = "[SeqComponentTeachingRun] Set Blow On";
        const string SEQ_SET_BLOW_OFF = "[SeqComponentTeachingRun] Set Blow Off";

        const string SEQ_SAVE_RESULT_DATA = "[SeqComponentTeachingRun] Save Result Data";

        const string SEQ_COMPLETE = "[SeqComponentTeachingRun] SEQ_COMPLETE";         // 완료

        const string SEQ_UPDATE_COMPONENT_WELDING_PARAMETERS = "[SeqComponentTeachingRun] Update Component Welding Parameters";
        const string SEQ_START_WELDING = "[SeqComponentTeachingRun] Start All Welding";
        const string SEQ_DO_COMPONENT_WELDING = "[SeqComponentTeachingRun] Do Component Welding";
        const string SEQ_CHECK_END_LIST = "[SeqComponentTeachingRun] Check End List";
        const string SEQ_END_WELDING = "[SeqComponentTeachingRun] End All Welding";

        #region 260408 NDY  노드 추가
        // Builder()에 노드 추가
        //const string SEQ_MOVE_STAGE_ORIGIN = "[SeqComponentTeachingRun] Move Stage To Origin";
        //const string SEQ_ENCODER_RESET = "[SeqComponentTeachingRun] Encoder Reset";
        #endregion

        const int timeoutSeconds = 10;
        static class ContextKey
        {
            public const string KEY_SEQUENCE_RESULT = "KEY_SEQUENCE_RESULT_SeqComponentTeachingRun";
            public const string KEY_SEQUENCE_START_TIME = "KEY_SEQUENCE_START_TIME_SeqComponentTeachingRun";
        }

        private SeqTeachingRun_InitParam _InitParam;

        private static Scanner _Scanner;
        private static PAIX_PrismaticScanner _IO;

        // 필드 선언 추가 (다른 필드들 옆에)
        // 변경 전
        //private ScannerACS _ACS;


        // 변경 후
        private IScannerACS _ACS;  // 26.04.06 NDY - MOTF용 ACS Stage X 제어
        private static ACSMotor _AxisX; // 26.04.08 NDY - MOTF용 Stage X 축 

        private Laser _Laser;
        private ILaser _LaserDevice;
        private LaserTruFiber _LaserTruFiber;
        private LaserPowerCalParam _LaserPowerCalParam;
        private PLCControllerPrismaticScanner _plc;

        private SystemParameter _SystemParameter;
        private ScannerCanvasUserCtrl _ScannerCanvasUserCtrl; //스캐너 동작관련 객체 선언

        private static SequenceSetting _SequenceSetting;

        private eListNo _WeldingScannerListNo;


        private List<IDrawObject> _SelectedObjectList;
        private Queue<List<IDrawObject>> _DivideObjectsQueue;
        private List<IDrawObject> _TargetObjects;
        private static DateTime _SequenceCompleteTime; // 시퀸스 시간
        private static TimeSpan _MeasurementSpanTime; //측정 시간
        private static TimeSpan _ScannerSaveLogTime;
        private static DateTime _partialWeldingStartTime;
        private static List<IDrawObject> _FlattenRecipes;
        private static int _CountWeldingObject; // 트럼프 레시피에서 부분 용접 할 Ojbect의 개수
        private static int _CurrentobjectIndex;
        private static int _BeforeObjectIndex;
        private static int _BeforeProgramNo; // 이전 트럼프 레이저 용접 번호
        private static int _BeforeParameterNo; //

        private static int _CenterBeamPower;
        private static int _RingBeamPower;
        private static bool _LaserPowerControlByRatio = false;
        private static int _CenterRingRatio; // Center Ring의 파워 비율
        private static double _LaserPowerRatio; // Laser에서 출력 파워 비율
        public SequenceBuilder Builder()
        {
            var sb = new SequenceBuilder(1000, true);
            ////var sb = new SequenceBuilder(1000, false);        // With log

            sb.AddAction(SEQ_ENTER, Sequence_Enter);
            sb.AddAction(SEQ_CHECK_INIT_CONDITION, CheckInitCondition); //분기
            sb.AddAction(SEQ_SET_BLOW_ON, SetBlowOn);
            #region  26.04.08 추가된 노드 NDY  
            // 26.04.08 필드 좌표 0,0으로 스테이지 이동 시퀸스 + EncoderReset 호출 
            //sb.AddAction(SEQ_MOVE_STAGE_ORIGIN, MoveStageToOrigin);
            //sb.AddAction(SEQ_ENCODER_RESET, EncoderReset);
            #endregion

            sb.AddAction(SEQ_START_WELDING, StartWelding);
            sb.AddDecision(SEQ_CHECK_END_LIST, CheckEndList);
            sb.AddAction(SEQ_UPDATE_COMPONENT_WELDING_PARAMETERS, UpdateComponentWeldingParameters);
            sb.AddAction(SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ, SetUploadWeldingList_SeqParams);
            sb.AddSubsequence(SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ, CommonSequenceManager.GetSeqBuilder_SeqUploadWeldingList());
            sb.AddAction(SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ, GetUploadWeldingList_SeqResult);
            sb.AddAction(SEQ_DO_COMPONENT_WELDING, DoComponentWelding);
            sb.AddAction(SEQ_END_WELDING, EndWelding);
            sb.AddAction(SEQ_SET_BLOW_OFF, SetBlowOff);
            sb.AddAction(SEQ_SAVE_RESULT_DATA, SaveResultData);      // 해당 공정의 정보를 기록 함.
            sb.AddAction(SEQ_COMPLETE, Complete);


            // 기존 흐름에서 SET_BLOW_ON → START_WELDING 사이에 끼워넣기
            #region 기존 흐름 26.04.08
            sb.Flows(sb.Init > sb[SEQ_ENTER] > sb[SEQ_CHECK_INIT_CONDITION] > sb[SEQ_SET_BLOW_ON]
                    > sb[SEQ_START_WELDING] > sb[SEQ_CHECK_END_LIST]);
            #endregion
            #region 2개 노드 추가한 흐름 26.04.08
            //sb.Flows(sb.Init > sb[SEQ_ENTER] > sb[SEQ_CHECK_INIT_CONDITION] > sb[SEQ_SET_BLOW_ON]
            //        > sb[SEQ_MOVE_STAGE_ORIGIN]   // ← 추가
            //        > sb[SEQ_ENCODER_RESET]       // ← 추가
            //        > sb[SEQ_START_WELDING] > sb[SEQ_CHECK_END_LIST]);
            #endregion

            // 아래 두 흐름은 기존 그대로 유지
            sb.Flows(sb[SEQ_CHECK_END_LIST] > sb[SEQ_UPDATE_COMPONENT_WELDING_PARAMETERS]
                    > sb[SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ] > sb[SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ] > sb[SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ]
                    > sb[SEQ_DO_COMPONENT_WELDING] > sb[SEQ_CHECK_END_LIST]);
            sb.Flows(sb[SEQ_CHECK_END_LIST] > sb[SEQ_END_WELDING] > sb[SEQ_SET_BLOW_OFF]
                    > sb[SEQ_SAVE_RESULT_DATA] > sb[SEQ_COMPLETE] > sb.Final);

            sb.OnStopped(OnStopped);
            sb.OnForceError(OnForceError);


            //sb.Draw("SeqComponentTeachingRun.pdf");

            return sb;
        }
        #region 26.04.08 NDY
        private SequenceActionResult EncoderReset(SequenceContext context, string id, SequenceActionResult param)
        {
            if (_ACS == null)
            {
                Log.W("[EncoderReset] ACS null - 스킵");
                return SequenceAction.Ok();
            }

            if (!_Scanner.Config.UseMarkingOnTheFly)
            {
                Log.W("[EncoderReset] MOTF 비활성화 - 스킵");
                return SequenceAction.Ok();
            }

            Log.I("[EncoderReset] 시작");

            // SeqUploadWeldingList.MarkingOnTheFlyOn 패턴
            _Scanner.SetFlyX(_Scanner.Config.MarkingOnTheFlyEncoderResolutionX);
            Log.I($"[EncoderReset] SetFlyX: {_Scanner.Config.MarkingOnTheFlyEncoderResolutionX}");

            _Scanner.WaitForEncoderX(_Scanner.Config.MarkingStartEncoderPositionX);
            Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.MarkingStartEncoderPositionX}");

            _Scanner.StoreEncoder(0);
            _Scanner.SaveAndRestartTimer();

            Log.I("[EncoderReset] 완료 - Stage(0) = Scanner(0) 동기화");
            return SequenceAction.Ok();
        }
        //SeqTeachingPosMoveStageA패턴 참고 - 기존 GUN 프로젝트 시퀸스 
        private SequenceActionResult MoveStageToOrigin(SequenceContext context, string id, SequenceActionResult param)
        {
            if (_AxisX == null)
            {
                Log.W("[MoveStageToOrigin] AxisX2 null - 스킵");
                return SequenceAction.Ok();
            }

            Log.I("[MoveStageToOrigin] Stage X → 0 이동 시작");

            // SeqTeachingPosMoveStageA.MoveXYStage 패턴
            _AxisX.SetTargetPos(0, TargetPosType.ABS);
            _AxisX.SetMoveVelocityImm(AuroraACS.Speed.M);
            _AxisX.AccelerationImm(AuroraACS.Speed.M);
            _AxisX.DecelerationImm(AuroraACS.Speed.M);
            _AxisX.JerkImm(AuroraACS.Speed.M);
            _AxisX.Move();

            var res = context.RetryUntilSuccess(
                () => _AxisX.IsReachedTargetPosition(0),
                30 * 1000, 20, true);

            if (res == E2.TIMEOUT) { Log.E("[MoveStageToOrigin] TIMEOUT"); return null; }
            if (res == E2.CANCELLED) { Log.E("[MoveStageToOrigin] CANCELLED"); return null; }

            Log.I("[MoveStageToOrigin] Stage X = 0 도달 완료");
            return SequenceAction.Ok();

        }
        #endregion
        private SequenceActionResult Sequence_Enter(SequenceContext context, string id, SequenceActionResult param)
        {
            Log.I("===== SeqTeachingRun Sequence_Enter 진입 ====="); // 임시 추가
            Log.I("SeqTeachingRun Start");

            _InitParam = param.Param as SeqTeachingRun_InitParam;
            _SystemParameter = context.GetSetting<SystemParameter>(CommonSettingIds.SystemParameter);

            //_Laser = context.GetLaser();
            //_Laser.GetLaserDevice(ref _LaserDevice);
            //_LaserTruFiber = _LaserDevice as LaserTruFiber;

            //if (_plc == null)
            //    _plc = context.Devices[DeviceIds.PLCDevice] as PLCControllerPrismaticScanner;

            // Laser 시퀀스 Running. 안 넣어줘도 됨.
            //_LaserTruFiber.SetIsSeqRunning(true);

            _LaserPowerCalParam = context.GetSetting<LaserPowerCalParam>(CommonSettingIds.LaserPowerCalParam);//우선 AuroraRecipe로 상속받아서 함수 사용하도록 함
            //laserPowerCalParam 초기화(CSV 파일 불러오기)
            _LaserPowerCalParam.Initialize(_LaserPowerCalParam.PowerCalibrationCenterBeamCSVFile, _LaserPowerCalParam.PowerCalibrationRingBeamCSVFile);

            _SequenceSetting = context.Settings[CommonSettingIds.Sequence] as SequenceSetting;
            InitDev(context);
            if (!CheckDeviceReady(context))
            { //Check Device
                AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_DeviceNotReady);
                Log.E("The devices are not active.");
                return null;
            }

            if (InitSequenceVariable(context) == false)
            {
                AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_InitVariableError);
                return null;
            }


            return SequenceAction.Ok();
        }
        private void InitDev(SequenceContext context)
        {
            //Device Init
            _Scanner = context.GetLaserScanner();
            //_IO = context.Devices[CommonDeviceIds.IODevice] as PAIX_PrismaticScanner;

            // 26.04.06 NDY 추가: ACS 디바이스 취득 (null-safe)
            // 변수 맵 수신 후 MOTFStart() 호출에 사용
            // 변경 전
            //try { _ACS = context.Devices[DeviceIds.ACS] as ScannerACS; }
            // 변경 후
            try { _ACS = context.Devices[DeviceIds.ACS] as IScannerACS; }
            catch { _ACS = null; Log.W("ACS 디바이스 취득 실패 (null 처리)"); }

            //26.04.08 NDY 추가 _AxisX 가져오기 
            try { _AxisX = context.Devices[CommonDeviceIds.AxisX2] as ACSMotor; }
            catch { _AxisX = null; Log.W("AxisX2 취득 실패"); }
        }
        private bool CheckDeviceReady(SequenceContext context)
        {
            //List<string> deviceListToCheck = new List<string>() { CommonDeviceIds.Scanner, CommonDeviceIds.IODevice };  // 26.04.15 주석처리 아래 로 테스트
            List<string> deviceListToCheck = new List<string>() { CommonDeviceIds.Scanner };
            //List<string> deviceListToCheck = new List<string>() { CommonDeviceIds.Scanner, CommonDeviceIds.IODevice,DeviceIds.ACS }; 변수 맵 수신 후 ACS 주석 해제 위에 주석 처리 
            bool isAllDeviceActivated = true;
            foreach (string item in deviceListToCheck)
            {
                if (!context.Devices[item].IsActivated)
                {
                    isAllDeviceActivated = isAllDeviceActivated && false;
                }
            }

            return isAllDeviceActivated;
        }
        private bool InitSequenceVariable(SequenceContext context)
        {
            var mainPage = CommonHelper.GetMainPage();
            _ScannerCanvasUserCtrl = mainPage.ScannerCanvasCtrlTeaching;

            _WeldingScannerListNo = eListNo.LIST1;

            _SelectedObjectList = FindObjects();

            return true;
        }

        private List<IDrawObject> FindObjects()
        {
            if (_InitParam.IsUseExternalObjects)
            {
                return _InitParam.ExternalObjects;
            }
            else if (_InitParam.IsObjectSelectAll)
            {
                return _ScannerCanvasUserCtrl.Model.ActiveLayer.Objects;
            }
            else
            {
                return _ScannerCanvasUserCtrl.Canvas.Model.SelectedObjects;
            }

        }

        private SequenceActionResult CheckInitCondition(SequenceContext context, string id, SequenceActionResult param)
        {
            if (!CheckCondition())
            {
                AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_CheckInitCondition);
                Log.E("Condition is not in state to start sequence.");
                context.PutValue(ContextKey.KEY_SEQUENCE_RESULT, false);
                return null;
            }

            _CurrentobjectIndex = 0;
            _BeforeObjectIndex = 0;
            _CountWeldingObject = 0;
            _BeforeParameterNo = -1;
            _BeforeProgramNo = -1;
            _ScannerSaveLogTime = TimeSpan.Zero;

            _FlattenRecipes = new List<IDrawObject>(); // 레시피 초기화
            UnpackRecipes(_SelectedObjectList);
            var startTime = DateTime.Now;
            context.PutValue(ContextKey.KEY_SEQUENCE_START_TIME, startTime);

            Log.D("ComponentTeachingRun Sequence CheckInitCondition");
            return SequenceAction.Ok();
        }
        private bool CheckCondition()
        {
            if (CheckCondition_Interlock())
            {
                if (InitializeDeviceStatus())
                {
                    return true;
                }
            }
            return false;
        }

        private bool CheckCondition_Interlock()
        {
            //// PLC, Data, IO 등 Interlock checking
            bool boolian = AlarmManager.HasAlarmLevelHigh();
            if (boolian)
            {
                Log.E($"Clear Heavy Alarms For Welding!");
                MessageUtil.ShowWarningToast(string.Format("Clear Heavy Alarms For Welding!"));
                return false;
            }
            boolian = AlarmManager.IsPlcDoorOpen();
            if (boolian)
            {
                Log.E($"PLC Door Opened!! Can't Weld Now.");
                MessageUtil.ShowWarningToast(string.Format("Close Door ! Clear PLC DoorInterlock!"));
                return false;
            }

            boolian = AlarmManager.IsPlcEmoAlarm();
            if (boolian)
            {
                Log.E($"PLC EMO Pushed!! Can't Weld Now.");
                MessageUtil.ShowWarningToast(string.Format("Clear PLC EMO Status!"));
                return false;
            }
            return true;
        }

        private bool InitializeDeviceStatus()
        {
            //Vision Correction File 선택
            _Scanner.SelectCorrectionTable(2);
            return true;
        }

        private SequenceActionResult SetBlowOn(SequenceContext context, string id, SequenceActionResult param)
        {
            if (_InitParam.UseBlow == false)
            {
                return SequenceAction.Ok();
            }

            int intervalTime = _InitParam.IntervalTimeBlowOn;
            //_IO._iOUnit.WriteDoBit(Convert.ToInt32(ePDOAddress.SeamWeldingN2BlowSol), true);
            Thread.Sleep(intervalTime);

            Log.D(string.Format($"[ComponentTeachingRun] Blow ON Complete"));

            return SequenceAction.Ok();
        }

        private void SaveScannerRecordFileForamt()
        {
            if (_Scanner.Config.UseRecordSignal)
            {
                DateTime startTime = DateTime.Now;
                _Scanner.SaveStackRecord("Normal");
                _ScannerSaveLogTime += DateTime.Now.Subtract(startTime);
            }
        }

        private SequenceActionResult StartWelding(SequenceContext context, string id, SequenceActionResult param)
        {
            Log.D(string.Format($"[ComponentTeachingRun] Start Component Welding"));
            _SequenceCompleteTime = DateTime.Now;
            // Laser 판넬 On
            //_IO.WriteDoBit(PAIX_PrismaticScanner.ePrismaticDOAddress.CCCAPLaserOnLampOn, true);

            _DivideObjectsQueue = SplitBySerialize(_FlattenRecipes);
            Log.I($"Divided DrawObjects List Count[{_DivideObjectsQueue.Count}]");

            return SequenceAction.Ok();
        }

        // 펼쳐진 객체(_FlattenRecipes)를 여러개의 스캔 파라미터에 따라 여러개로 나눈다
        public static Queue<List<IDrawObject>> SplitBySerialize(List<IDrawObject> source)
        {
            var result = new Queue<List<IDrawObject>>();
            if (source == null || source.Count == 0)
                return result;

            List<IDrawObject> current = null;
            int? currentId = null;

            foreach (var item in source)
            {
                if (current == null || currentId.Value != item.ScannerParamID)
                {
                    current = new List<IDrawObject>();
                    result.Enqueue(current);
                    currentId = item.ScannerParamID;
                }

                current.Add(item);
            }

            return result;
        }

        private string CheckEndList(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param)
        {
            if (_DivideObjectsQueue.Count == 0)
                return SEQ_END_WELDING;

            // 파일 저장 변수 초기화
            if (_Scanner.Config.UseRecordSignal)
            {
                DateTime startTime = DateTime.Now;
                _Scanner.InitializeRecord();
                _ScannerSaveLogTime += DateTime.Now.Subtract(startTime);
            }

            return SEQ_UPDATE_COMPONENT_WELDING_PARAMETERS;

        }

        private SequenceActionResult UpdateComponentWeldingParameters(SequenceContext context, string id, SequenceActionResult param)
        {
            _partialWeldingStartTime = DateTime.Now;
            //var currentDivideObject = _DivideObjectsQueue.Peek();
            //int paramIndex = currentDivideObject[0].ScannerParamID - 1;
            //Log.I($"Remain Divided DrawObjects Count[{currentDivideObject.Count}] / ParameterNo[{paramIndex + 1}]");

            //int SlotNo = _plc.ReadWord(eWordInput.PLC_CURRENT_SLOT_NO).data;
            //if (SlotNo <= 0)
            //    SlotNo = 1;
            //// 결과 Data 를 업데이트 함.
            //var power = Status.GetProcessingWeldingData().UploadProcessDatas.Where(data => data.DataName == $"Power_{SlotNo}_{_SequenceSetting.LastPageNo}").FirstOrDefault();

            //#region 26.04.08 NDY 캘리브레이션 노드 추가 테스트를 위해서 잠시 예외처리 코드 추가 
            //if (power != null)
            //    power.Value = ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower1
            //                + ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower2;
            //#endregion
            //// 26.04.08 NDY 주석처리 - power null 예외 방지 (위 null 체크로 대체)
            ////power.Value = ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower1 + ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower2;


            //var velocity = Status.GetProcessingWeldingData().UploadProcessDatas.Where(data => data.DataName == $"Velocity_{SlotNo}_{_SequenceSetting.LastPageNo}").FirstOrDefault();
            //#region 26.04.08 NDY velocity null에 대한 예외 처리
            //if (velocity != null)
            //    velocity.Value = ScannerCanvasUserCtrl.ScannerParams[paramIndex].MarkSpeed;
            //#endregion
            //// 26.04.08 NDY 주석처리 - velocity null 예외 방지 (위 null 체크로 대체)
            ////velocity.Value = ScannerCanvasUserCtrl.ScannerParams[paramIndex].MarkSpeed;


            //// 26.04.08 NDY - FDC 데이터 상신 -기존 코드 주석처리 
            ////_plc.UploadReportDatas(Status.GetProcessingWeldingData().UploadProcessDatas);
            //// 26.04.08 NDY - FDC 상신도 데이터 있을 때만 - 테스트 목적 예외 처리 추가 
            //if (Status.GetProcessingWeldingData().UploadProcessDatas.Count > 0)
            //    _plc.UploadReportDatas(Status.GetProcessingWeldingData().UploadProcessDatas);

            //_CenterBeamPower = (int)ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower1;
            //_RingBeamPower = (int)ScannerCanvasUserCtrl.ScannerParams[paramIndex].LaserPower2;
            //_CenterRingRatio = 0;

            //if (_CenterBeamPower == 0 && _RingBeamPower == 0)
            //    _CenterRingRatio = 100;
            //else
            //    _CenterRingRatio = (int)Math.Round((double)(100 * _CenterBeamPower) / (double)(_CenterBeamPower + _RingBeamPower), 0); // Discrete 한 값이라서 Ring은 오차 발생

            ////if (_Laser.Config.TruFiberType == eTruFiberType.TruFiberP)
            ////{
            //    _CenterBeamPower = _LaserPowerCalParam.CalibrateWattToWatt(_CenterBeamPower, (uint)LaserPowerCalParam.beamMode.Center);
            //    _RingBeamPower = _LaserPowerCalParam.CalibrateWattToWatt(_RingBeamPower, (uint)LaserPowerCalParam.beamMode.Ring);
            ////}
            //// Ready 상태 변경 확인(Complete 상태에서 Laser Ready로 변환되기까지 시간이 걸림)
            //// 여기서는 왜 IW03과 Center를 비교하는 것인지.... 아직 값을 써주지 않았으므로 레이저 출사 가능 여부만 확인하면 되지 않을까.
            //var res = context.RetryUntilSuccess(_Laser.GetLaserReady, timeoutSeconds * 1000, 1);

            //if (res == E2.TIMEOUT)
            //{
            //    Log.E(string.Format($"[Page Change Req] Laser Program Ready Timeout When LaserReady"));
            //    return null;
            //}
            //Log.D(string.Format($"[Page Change Req] Laser Program Ready OK"));

            //// Laser Program Parameters 설정(Laser Ready 상태는 용접 직전에 확인)
            //List<(int, int, bool)> datas = new List<(int, int, bool)>();
            //datas.Add((csWriteNodeNo.IW03, _CenterBeamPower, true));
            //datas.Add((csWriteNodeNo.IW04, _RingBeamPower, true));
            //datas.Add((csWriteNodeNo.IW05, _CenterRingRatio, true));

            //// 업데이트 될 경우, 프로그램 전환을 위한 프로그램 종료 시퀸스 진행됨.
            //if (_LaserTruFiber.UpdatesDatasIfChanged(datas))
            //{

            //    // 프로그램이 종료 될 때까지 대기.
            //    res = context.RetryUntilSuccess(_LaserTruFiber.GetProgramCompleted, timeoutSeconds * 1000, 10);

            //    if (res == E2.TIMEOUT)
            //    {
            //        Log.E(string.Format($"[Page Change Req] Laser Program Completed Timeout When Parameter Changes"));
            //        return null;
            //    }
            //    Log.D(string.Format($"[Page Change Req] Laser Program Completed OK When Data Updated"));
            //}

            return SequenceAction.Ok();
        }
        private SequenceActionResult SetUploadWeldingList_SeqParams(SequenceContext context, string id, SequenceActionResult param)
        {
            Status.SetWorkingPosition(eWorkingPosition.UPLOADING_WELD_LIST);

            // TeachingRun에는 용접 시퀀스만 정의해서 Auto Run에서도 사용하므로 Offset 넣어줘야 함
            SeqUploadWeldingList_InitParam seqParams = new SeqUploadWeldingList_InitParam()
            {
                NeedSetLaserTiming = _InitParam.NeedSetLaserTiming,
                IncludeListStartEnd = true,
                CellMeasureCenterOffsetX = _SystemParameter.CellPosMeasureCenterOffsetX + _InitParam.CellCenterOffsetX,
                CellMeasureCenterOffsetY = _SystemParameter.CellPosMeasureCenterOffsetY + _InitParam.CellCenterOffsetY,
                SelectedDrawObjectList = _DivideObjectsQueue.Peek(),
                WeldingScannerListNo = _WeldingScannerListNo,
            };

            var _PageNo = _SequenceSetting.LastPageNo;

            Log.W($"page {_PageNo}({Status.GetProcessingWeldingData().CellId}) : Cell Offset Value Check ; X : {_SystemParameter.CellPosMeasureCenterOffsetX} + {_InitParam.CellCenterOffsetX} ; Y : {_SystemParameter.CellPosMeasureCenterOffsetY} + {_InitParam.CellCenterOffsetY}");

            Log.D(string.Format($"[ComponentTeachingRun] Set UploadWelindList Seq Param"));

            return SequenceAction.Ok(seqParams);
        }

        private SequenceActionResult GetUploadWeldingList_SeqResult(SequenceContext context, string id, SequenceActionResult param)
        {
            Log.D(string.Format($"[ComponentTeachingRun] Get UploadWelindList Seq Param"));

            var resultOutParam = param.Param as SeqUploadWeldingList_OutParam;
            if (resultOutParam.Success == false)
            {
                Log.E(string.Format($"[ComponentTeachingRun] Failed UploadWeldingList Sequence"));
                return null;
            }

            return SequenceAction.Ok();
        }


        private SequenceActionResult DoComponentWelding(SequenceContext context, string id, SequenceActionResult param)
        {
            _DivideObjectsQueue.Dequeue();
            Log.I("UploadWeldingList Complete");
            Log.D(string.Format($"[ComponentTeachingRun] Component Welding Start idx :({_BeforeObjectIndex} ~ {_BeforeObjectIndex + _CountWeldingObject - 1})"));

            #region PSTART_DYN 사용시 참고
            //// PSTART_DYN에서는 레이저가 활성화되었는지 확인하여야 함. 하지만, PSTART_STATICALLY에서는 굳이 확인할 필요 없음. (이전에 확인해줄 것이므로)
            // var res = context.RetryUntilSuccess(_LaserTruFiber.GetProgramActive, timeoutSeconds * 1000, 1);
            //if (res == E2.TIMEOUT)
            //{
            //    Log.E(string.Format($"[ComponentTeachingRun] Laser Program Active Timeout"));
            //    return null;
            //}
            #endregion

            //Log.D(string.Format($"[ComponentTeachingRun] Check LaserReadyResponse"));
            //// 만일 프로그램이 정상적으로 종료 및 변경 원할 경우, 레이저 스레드에서 Ready 상태로 만들어주고 있을 것임.
            //// Ready 상태 변경 확인
            //var res = context.RetryUntilSuccess(LaserReadyResponse, timeoutSeconds * 1000, 10);
            //if (res == E2.TIMEOUT)
            //{
            //    Log.E(string.Format($"[ComponentTeachingRun] Laser Program Ready Timeout When LaserReadyResponse"));
            //    return null;
            //}
            //Log.D(string.Format($"[ComponentTeachingRun] Laser Program Ready OK When ReadyResponse"));

            //Status.SetWorkingPosition(eWorkingPosition.EXECUTING_WELD);

            Log.I($"Welding List Space : {_Scanner.GetListSpace()}");
            DateTime weldingTime = DateTime.Now;
            _Scanner.ExecuteList(_WeldingScannerListNo);


            // ── 26.04.06 NDY 추가: ACS Stage X 이동 ──────────────
            // MOTF: Scanner List 실행과 동시에 Stage X 이동 시작
            // Stage X 엔코더가 트리거 → WaitForEncoderX 조건 도달 시 갈바노 마킹
            // TODO: 변수 맵 수신 후 _ACS.MOTFStart()로 교체
            // _ACS?.MOTFStart();
            // ────────────────────────────────────────────────────



            _Scanner.WaitForListTaskCompleted(_SystemParameter.WeldLinesTaskTimeOut);

            // ── 26.04.06 NDY 추가: ACS 완료 대기 ─────────────────
            // TODO: 변수 맵 수신 후 활성화
            // while (!_ACS.CheckMOTFComp()) { Thread.Sleep(10); }
            // ────────────────────────────────────────────────────

            _MeasurementSpanTime = DateTime.Now.Subtract(weldingTime);
            Log.D(string.Format($"[ComponentTeachingRun] Component Welding Complete Time : {_MeasurementSpanTime.TotalMilliseconds}"));

            #region PSTART_DYN 사용시 참고
            //// 굳이 확인할 필요가 없을 듯 함.PSTAT_STATICALLY 활용시.
            //res = context.RetryUntilSuccess(_LaserTruFiber.GetProgramCompleted, timeoutSeconds * 1000, 1);

            //if (res == E2.TIMEOUT)
            //{
            //    Log.E(string.Format($"[ComponentTeachingRun] Laser Program Complete Timeout"));
            //    return null;
            //}
            #endregion

            Log.D(string.Format($"[ComponentTeachingRun] Laser Program Complete OK"));


            if (_Scanner.Config.UseRecordSignal)
            {
                DateTime startTime = DateTime.Now;
                _Scanner.StackRecord();
                _ScannerSaveLogTime += DateTime.Now.Subtract(startTime);
            }

            // excel 파일 작성
            SaveScannerRecordFileForamt();
            Log.D(string.Format($"[ComponentTeachingRun] SaveScannerRecordFileForamt Time : {_ScannerSaveLogTime.TotalMilliseconds}"));

            var PartialTactTime = DateTime.Now.Subtract(_partialWeldingStartTime);
            Log.D(string.Format($"[TactTime] Complete Partial Component Weld : {PartialTactTime.TotalMilliseconds}"));

            _ScannerCanvasUserCtrl.TimeLabelUpdate(_MeasurementSpanTime.TotalMilliseconds, PartialTactTime.TotalMilliseconds);

            //// 용접 끝난 후, 초기화 시킴
            //var UploadDatas = Status.GetProcessingWeldingData().UploadProcessDatas;
            //foreach (var data in UploadDatas)
            //    data.Clear();
            //_plc.UploadReportDatas(UploadDatas);

            return SequenceAction.Ok();
        }

        private SequenceActionResult EndWelding(SequenceContext context, string id, SequenceActionResult param)
        {
            _MeasurementSpanTime = DateTime.Now.Subtract(_SequenceCompleteTime);
            Log.D(string.Format($"[TactTime] Complete All Component Weld : {_MeasurementSpanTime.TotalMilliseconds}"));


            //Anlog 출력 0으로 변경, efunctiontype을 command로 변경해주면 list가 아니라 직접 변경됨
            _Scanner.WriteDA((uint)eAnalogPortOut.DA1, 0, eFunctionType.COMMAND);
            _Scanner.WriteDA((uint)eAnalogPortOut.DA2, 0, eFunctionType.COMMAND);
            _Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);

            // Laser 판넬 Off
            //_IO.WriteDoBit(PAIX_PrismaticScanner.ePrismaticDOAddress.CCCAPLaserOnLampOn, false);

            var mesurementTime = DateTime.Now;

            //용접 완료 후 CorrectionFile Vision으로 원복
            _Scanner.SelectCorrectionTable(1);

            _MeasurementSpanTime = DateTime.Now.Subtract(mesurementTime);
            Log.D(string.Format($"[ComponentTeachingRun] Change SelectCorrectionTable Time : {_MeasurementSpanTime.TotalMilliseconds}"));

            return SequenceAction.Ok();
        }

        private SequenceActionResult SetBlowOff(SequenceContext context, string id, SequenceActionResult param)
        {
            if (_InitParam.UseBlow == false)
            {
                return SequenceAction.Ok();
            }

            int intervalTime = _InitParam.IntervalTimeBlowOff;
            Thread.Sleep(intervalTime);

            //_IO._iOUnit.WriteDoBit(Convert.ToInt32(ePDOAddress.SeamWeldingN2BlowSol), false);

            Log.D(string.Format($"[ComponentTeachingRun] Blow OFF Complete"));

            return SequenceAction.Ok();
        }

        private SequenceActionResult SaveResultData(SequenceContext context, string id, SequenceActionResult param)
        {
            context.PutValue(ContextKey.KEY_SEQUENCE_RESULT, true);
            return SequenceAction.Ok();
        }

        private SequenceActionResult Complete(SequenceContext context, string id, SequenceActionResult param)
        {
            context.TryGetValue(ContextKey.KEY_SEQUENCE_RESULT, out bool seqResult);
            SeqTeachingRun_OutParam result = new SeqTeachingRun_OutParam() { Success = seqResult };

            if (seqResult == false)
            {
                AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_ResultFailed);
            }

            Log.D("ComponentTeachingRun Sequence Complete");
            return SequenceAction.Ok(result);
        }

        private static void UnpackRecipes(List<IDrawObject> recipes)
        {
            // Recipe를 재귀적으로 탐색해서 List로 재구성하는 함수
            if (recipes == null)
                return;

            for (int i = 0; i < recipes.Count; i++)
            {
                if (recipes[i] is Group)
                {
                    Group subGroup = recipes[i] as Group;
                    List<IDrawObject> subrecipes = subGroup.SubObjects as List<IDrawObject>;
                    UnpackRecipes(subrecipes);
                }
                else
                {
                    _FlattenRecipes.Add(recipes[i]);
                }
            }
        }


        private void OnForceError(SequenceContext context, string arg2)
        {
            // Scanner Log 저장
            SaveScannerRecordFileForamt();

            //List 실행 종료
            _Scanner.StopExecution();

            //Anlog 출력 0으로 변경, efunctiontype을 command로 변경해주면 list가 아니라 직접 변경됨
            _Scanner.WriteDA((uint)eAnalogPortOut.DA1, 0, eFunctionType.COMMAND);
            _Scanner.WriteDA((uint)eAnalogPortOut.DA2, 0, eFunctionType.COMMAND);

            // TruFiber레이저 Ready로 변경
            ForceLaserReady();

            //Scanner 원점 복귀
            // 복귀 시 Scanner Busy 상태일 수 있으므로 진행중인 작업이 끝날 때까지 대기
            Thread.Sleep(10);
            _Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);
            Thread.Sleep(10);

            Log.I("SequenceAction Ok : OnForceError");
        }

        private void OnStopped(SequenceContext context)
        {
            // Scanner Log 저장
            SaveScannerRecordFileForamt();

            //List 실행 종료
            _Scanner.StopExecution();

            //Anlog 출력 0으로 변경, efunctiontype을 command로 변경해주면 list가 아니라 직접 변경됨
            _Scanner.WriteDA((uint)eAnalogPortOut.DA1, 0, eFunctionType.COMMAND);
            _Scanner.WriteDA((uint)eAnalogPortOut.DA2, 0, eFunctionType.COMMAND);

            // TruFiber레이저 Ready로 변경
            ForceLaserReady();

            //Scanner 원점 복귀
            // 복귀 시 Scanner Busy 상태일 수 있으므로 진행중인 작업이 끝날 때까지 대기
            Thread.Sleep(10);
            _Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);
            Thread.Sleep(10);

            // Laser 판넬 Off
            //_IO.WriteDoBit(PAIX_PrismaticScanner.ePrismaticDOAddress.CCCAPLaserOnLampOn, false);

            Log.I("SequenceAction Ok : OnStopped");
        }



        private void ForceLaserReady()
        {
            // 트럼프 레이저에서 PStartDyn, Prog_Stop을 감시하여 강제로 Ready 상태로 만드는 함수
            if (_Laser.IsSimul)
            {
                return;
            }

            //// PSTART_STATICAL 에서는 필요 없어보임.
            //_LaserTruFiber.SetProgEnd();

            // Laser 판넬 Off
            //_IO.WriteDoBit(PAIX_PrismaticScanner.ePrismaticDOAddress.CCCAPLaserOnLampOn, false);

            Log.I("SequenceAction Ok : Set Laser Ready");

        }

    }

    // TODO: UseStream 으로 TeachingRun 을 할 필요가 있을까?? 확인 필요
    public class SeqComponentTeachingRun_InitParam : InitParam
    {
        public bool IsObjectSelectAll { get; set; }     // All == true, Selected Object == false

        public bool UseStream { get; set; }

        public bool UseBlow { get; set; }
        public int IntervalTimeBlowOn { get; set; }
        public int IntervalTimeBlowOff { get; set; }

        public bool NeedSetLaserTiming { get; set; }      // For SubSequence, SeqUploadWeldingList

    }

    public class SeqComponentTeachingRun_OutParam : OutParam
    {

    }
}