using Aurora;
using Aurora.Api;
using Aurora.Api.Manager;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Input;
using System.Windows.Threading;
using static AuroraTriggerBoard.Trigger;
using static AuroraTriggerBoard.TriggerConfig;

namespace AuroraTriggerBoard.SJT
{
    public class UCTriggerBoardViewModel : NotifyPropertyChangedBase
    {
        Aurora.Api.Logger Log = new Aurora.Api.Logger("Trigger Board");

        public ICommand CMD_ViewLoaded { get; }
        public ICommand CMD_ViewUnloaded { get; }
        public ICommand CMD_CheckTeachingMode { get; }
        public ICommand CMD_Setting { get; private set; }
        public ICommand CMD_TriggerStop { get; private set; }
        public ICommand CMD_TriggerStart { get; private set; }
        public ICommand CMD_SetStrobe { get; private set; }
        public ICommand CMD_GetEncoderCnt { get; private set; }
        public ICommand CMD_ResetEncoderCount { get; private set; }
        public ICommand CMD_SetEncoderCount { get; private set; }
        public ICommand CMD_ResetSystem { get; private set; }
        public ICommand CMD_GetAllParameter { get; private set; }

        private readonly DispatcherTimer MonitorTimer;
        internal AuroraTriggerBoard.Trigger _Trigger;
        private readonly IDeviceManager _DeviceManager;
        IAuroraEnvironment _auroraEnv;

        private string hW_Ver;

        public string HW_Ver { get => hW_Ver; set => SetProperty(ref hW_Ver, value); }

        private string sW_Ver;

        public string SW_Ver { get => sW_Ver; set => SetProperty(ref sW_Ver, value); }

        private string dLL_Ver;

        public string DLL_Ver { get => dLL_Ver; set => SetProperty(ref dLL_Ver, value); }

        //private int encoderInputByIndex;

        //public int EncoderInputByIndex { get => encoderInputByIndex; set => SetProperty(ref encoderInputByIndex, value); }

        //private int tableSettingIndex;

        //public int TableSettingIndex { get => tableSettingIndex; set => SetProperty(ref tableSettingIndex, value); }

        //private int encoderDirectionIndex;

        //public int EncoderDirectionIndex { get => encoderDirectionIndex; set => SetProperty(ref encoderDirectionIndex, value); }

        //private int generatorModeIndex;

        //public int GeneratorModeIndex { get => generatorModeIndex; set => SetProperty(ref generatorModeIndex, value); }

        //private int chOutputModeIndex;

        //public int ChOutputModeIndex { get => chOutputModeIndex; set => SetProperty(ref chOutputModeIndex, value); }

        private EncoderMode encoderInputByIndex;
        public EncoderMode EncoderInputByIndex { get => encoderInputByIndex; set => SetProperty(ref encoderInputByIndex, value); }

        private EncoderPositionMap tableSettingIndex;

        public EncoderPositionMap TableSettingIndex { get => tableSettingIndex; set => SetProperty(ref tableSettingIndex, value); }

        private EncoderDirection encoderDirectionIndex;

        public EncoderDirection EncoderDirectionIndex { get => encoderDirectionIndex; set => SetProperty(ref encoderDirectionIndex, value); }

        private TriggerGenMode generatorModeIndex;

        public TriggerGenMode GeneratorModeIndex { get => generatorModeIndex; set => SetProperty(ref generatorModeIndex, value); }

        private ChannelOutMode chOutputModeIndex;

        public ChannelOutMode ChOutputModeIndex { get => chOutputModeIndex; set => SetProperty(ref chOutputModeIndex, value); }

        public List<EncoderMode> EncModes { get; }
        public List<EncoderPositionMap> EncPosMaps { get; }
        public List<EncoderDirection> EncDirections { get; }
        public List<TriggerGenMode> TrigGenModes { get; }
        public List<ChannelOutMode> TrigChOutModes { get; }

        public bool IsFirst = false;

        private double timer_Set; public double Timer_Set { get => timer_Set; set => SetProperty(ref timer_Set, value); }

        private uint trigLimit_Set; public uint TrigLimit_Set { get => trigLimit_Set; set => SetProperty(ref trigLimit_Set, value); }

        //private bool? checkedChannel1;
        //private bool? checkedChannel2;
        //private bool? checkedChannel3;
        //private bool? checkedChannel4;
        //private bool? checkedChannel5;
        //private bool? checkedChannel6;
        //private bool? checkedChannel7;
        //private bool? checkedChannel8;
        //public bool? CheckedChannel1 { get => checkedChannel1; set => SetProperty(ref checkedChannel1, value); }
        //public bool? CheckedChannel2 { get => checkedChannel2; set => SetProperty(ref checkedChannel2, value); }
        //public bool? CheckedChannel3 { get => checkedChannel3; set => SetProperty(ref checkedChannel3, value); }
        //public bool? CheckedChannel4 { get => checkedChannel4; set => SetProperty(ref checkedChannel4, value); }
        //public bool? CheckedChannel5 { get => checkedChannel5; set => SetProperty(ref checkedChannel5, value); }
        //public bool? CheckedChannel6 { get => checkedChannel6; set => SetProperty(ref checkedChannel6, value); }
        //public bool? CheckedChannel7 { get => checkedChannel7; set => SetProperty(ref checkedChannel7, value); }
        //public bool? CheckedChannel8 { get => checkedChannel8; set => SetProperty(ref checkedChannel8, value); }

        //private double widthChannel1;
        //private double widthChannel2;
        //private double widthChannel3;
        //private double widthChannel4;
        //private double widthChannel5;
        //private double widthChannel6;
        //private double widthChannel7;
        //private double widthChannel8;
        //public double WidthChannel1 { get => widthChannel1; set => SetProperty(ref widthChannel1, value); }
        //public double WidthChannel2 { get => widthChannel2; set => SetProperty(ref widthChannel2, value); }
        //public double WidthChannel3 { get => widthChannel3; set => SetProperty(ref widthChannel3, value); }
        //public double WidthChannel4 { get => widthChannel4; set => SetProperty(ref widthChannel4, value); }
        //public double WidthChannel5 { get => widthChannel5; set => SetProperty(ref widthChannel5, value); }
        //public double WidthChannel6 { get => widthChannel6; set => SetProperty(ref widthChannel6, value); }
        //public double WidthChannel7 { get => widthChannel7; set => SetProperty(ref widthChannel7, value); }
        //public double WidthChannel8 { get => widthChannel8; set => SetProperty(ref widthChannel8, value); }

        //private double delayChannel1;
        //private double delayChannel2;
        //private double delayChannel3;
        //private double delayChannel4;
        //private double delayChannel5;
        //private double delayChannel6;
        //private double delayChannel7;
        //private double delayChannel8;

        //public double DelayChannel1 { get => delayChannel1; set => SetProperty(ref delayChannel1, value); }
        //public double DelayChannel2 { get => delayChannel2; set => SetProperty(ref delayChannel2, value); }
        //public double DelayChannel3 { get => delayChannel3; set => SetProperty(ref delayChannel3, value); }
        //public double DelayChannel4 { get => delayChannel4; set => SetProperty(ref delayChannel4, value); }
        //public double DelayChannel5 { get => delayChannel5; set => SetProperty(ref delayChannel5, value); }
        //public double DelayChannel6 { get => delayChannel6; set => SetProperty(ref delayChannel6, value); }
        //public double DelayChannel7 { get => delayChannel7; set => SetProperty(ref delayChannel7, value); }
        //public double DelayChannel8 { get => delayChannel8; set => SetProperty(ref delayChannel8, value); }

        private bool?[] checkedChannel = new bool?[8]; public bool?[] CheckedChannel { get => checkedChannel; set => SetProperty(ref checkedChannel, value); }


        private double[] widthChannel = new double[8]; public double[] WidthChannel { get => widthChannel; set => SetProperty(ref widthChannel, value); }


        private double[] delayChannel = new double[8]; public double[] DelayChannel { get => delayChannel; set => SetProperty(ref delayChannel, value); }


        private int _seqStartEnc; public int Seq_StartEnc { get => _seqStartEnc; set => SetProperty(ref _seqStartEnc, value); }
        private int _seqIntervalEnc; public int Seq_IntervalEnc { get => _seqIntervalEnc; set => SetProperty(ref _seqIntervalEnc, value); }
        private int _seqIterationCnt; public int Seq_IterationCnt{ get => _seqIterationCnt; set => SetProperty(ref _seqIterationCnt, value); }

        public UCTriggerBoardViewModel(IAuroraEnvironment env, string deviceId)
        {
            _Trigger = env.DeviceManager[deviceId] as AuroraTriggerBoard.Trigger;
            _DeviceManager = env.DeviceManager;
            _auroraEnv = env;

            EncModes = Enum.GetValues(typeof(EncoderMode)).Cast<EncoderMode>().ToList();
            EncPosMaps = Enum.GetValues(typeof(EncoderPositionMap)).Cast<EncoderPositionMap>().ToList();
            EncDirections = Enum.GetValues(typeof(EncoderDirection)).Cast<EncoderDirection>().ToList();
            TrigGenModes = Enum.GetValues(typeof(TriggerGenMode)).Cast<TriggerGenMode>().ToList();
            TrigChOutModes = Enum.GetValues(typeof(ChannelOutMode)).Cast<ChannelOutMode>().ToList();

            CMD_ViewLoaded = new DelegateCommand(Loaded);
            CMD_ViewUnloaded = new DelegateCommand(Unloaded);

            CMD_CheckTeachingMode = new DelegateCommand(PerformCMD_CheckTeachingMode);
            CMD_Setting = new DelegateCommand(PerformCMD_Setting);
            CMD_TriggerStop = new DelegateCommand(PerformCMD_TriggerStop);
            CMD_TriggerStart = new DelegateCommand(PerformCMD_TriggerStart);
            CMD_SetStrobe = new DelegateCommand(PerformCMD_SetStrobe);
            CMD_GetEncoderCnt = new DelegateCommand(PerformCMD_GetEncoderCnt);
            CMD_ResetEncoderCount = new DelegateCommand(PerformCMD_ResetEncoderCount);
            CMD_SetEncoderCount = new DelegateCommand(PerformCMD_SetEncoderCount);
            CMD_ResetSystem = new DelegateCommand(PerformCMD_ResetSystem);
            CMD_GetAllParameter = new DelegateCommand(PerformCMD_GetAllParameter);

            MonitorTimer = new DispatcherTimer();
            MonitorTimer.Tick += OnMonitoring;
            MonitorTimer.Interval = TimeSpan.FromMilliseconds(1000);

            IsFirst = true;

            var config = _DeviceManager.GetDeviceConfig(_Trigger.DeviceId) as TriggerConfig;
            Timer_Set = config.trigTimerSet;
            TrigLimit_Set = config.trigLimitSet;
            //CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
            //CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
            //CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
            //CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
            //CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
            //CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
            //CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
            //CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;
            //CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
            //CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
            //CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
            //CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
            //CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
            //CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
            //CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
            //CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;
            for (int i = 0; i < 8; i++) {
                CheckedChannel[i] = config.strobeChData.Count >= (i+1) ? config.strobeChData[i].strobeEnable : false;
                WidthChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeWidth : 0.0;
                DelayChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeStartDelay : 0.0;
            }

            TableSettingIndex = config.encposmaptype;
            EncoderInputByIndex = config.encinputmode;
            EncoderDirectionIndex = config.EncDir;
            GeneratorModeIndex = config.trigGenMode;
            ChOutputModeIndex = config.chOutMode;

            Seq_StartEnc = config.seqStartEnc;
            Seq_IntervalEnc = config.seqIntervalEnc;
            Seq_IterationCnt = config.seqIterationCnt;
        }

        private void Unloaded(object obj) => MonitorTimer.Stop();

        private void Loaded(object obj) => MonitorTimer.Start();

        private bool CheckVersionAndInitialize()
        {
            //_Trigger.ValueInit();

            _Trigger.GetHWVersion(out string hw_ver, out string sw_ver);
            _Trigger.GetDllVersion(out string dll_ver);

            HW_Ver = hw_ver;
            SW_Ver = sw_ver;
            DLL_Ver = dll_ver;

            // <Inkjet> 초기 세팅
            //Timer_Set = 10000;
            //TrigLimit_Set = 0;
            //CheckedChannel1 = false;
            //CheckedChannel2 = false;
            //CheckedChannel3 = false;
            //CheckedChannel4 = false;
            //CheckedChannel5 = false;
            //CheckedChannel6 = false;
            //CheckedChannel7 = false;
            //CheckedChannel8 = false;

            //TableSettingIndex = 0;
            //EncoderInputByIndex = 0;
            //EncoderDirectionIndex = 0;
            //GeneratorModeIndex = 2;
            //ChOutputModeIndex = 0;

            //_Trigger.GetTrigTimeFreq(out uint TimerFreq_10ns);
            //_Trigger.GetTrigTimeLimit(out uint TimeLimit);
            //Timer_Set = ((double)(TimerFreq_10ns)) / 100.0;
            //TrigLimit_Set = TimeLimit;
            //CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
            //CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
            //CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
            //CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
            //CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
            //CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
            //CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
            //CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;

            //TableSettingIndex = (int)config.encposmaptype;
            //EncoderInputByIndex = (int)config.encinputmode;
            //EncoderDirectionIndex = (int)config.EncDir;
            //GeneratorModeIndex = (int)config.trigGenMode;
            //ChOutputModeIndex = (int)config.chOutMode;

            //ushort rtn;
            ////uint[] Strobe_Ch_Para = new uint[17];
            //byte mask = 0x00;
            //double[] Width = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
            //double[] Delay = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

            //rtn = _Trigger.GetStrobe(0, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel1 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel1 = Width[0];

            //    DelayChannel1 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(1, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel2 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel2 = Width[0];

            //    DelayChannel2 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(2, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel3 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel3 = Width[0];

            //    DelayChannel3 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(3, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel4 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel4 = Width[0];

            //    DelayChannel4 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(4, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel5 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel5 = Width[0];

            //    DelayChannel5 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(5, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel6 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel6 = Width[0];

            //    DelayChannel6 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(6, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel7 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel7 = Width[0];

            //    DelayChannel7 = Delay[0];
            //}

            //rtn = _Trigger.GetStrobe(7, ref mask, ref Width, ref Delay);

            //if (rtn != 0) {
            //    Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
            //} else {
            //    CheckedChannel8 = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //    WidthChannel8 = Width[0];

            //    DelayChannel8 = Delay[0];
            //}
            //for (int i = 0; i < 0; i++) {
            //    rtn = _Trigger.GetStrobe((byte)i, ref mask, ref Width, ref Delay);

            //    if (rtn != 0) {
            //        Log.D($"Get Strobe Channel Parameter Fail Ch : {i+1} Err Code : {rtn:0x04}");
            //    } else {
            //        CheckedChannel[i] = (1 == ((mask >> 0) & 0x1)) ? true : false;

            //        WidthChannel[i] = Width[0];

            //        DelayChannel[i] = Delay[0];
            //    }
            //}

            //rtn = _Trigger.GetEncPosMapTableUse(out EncoderPositionMap encposmap);
            //if (rtn != 0) {
            //    Log.D($"Get Trig Encoder Enable Parameter Fail Err Code : {rtn:0x04}");
            //} else {
            //    TableSettingIndex = encposmap;
            //}

            //rtn = _Trigger.GetEncoderDirection(out EncoderDirection encdirection);
            //if (rtn != 0) {
            //    Log.D($"Get Trig Encoder Direction Parameter Fail Err Code : {rtn:0x04}");
            //} else {
            //    EncoderDirectionIndex = encdirection;
            //}

            //rtn = _Trigger.GetCntInType(out uint cnttype);
            //if (rtn != 0) {
            //    Log.D($"Get Trig Encoder Input Type Parameter Fail Err Code : {rtn:0x04}");
            //} else {
            //    EncoderInputByIndex = (EncoderMode)cnttype;
            //}

            //rtn = _Trigger.GetTrigMode(out TriggerGenMode _triggenmode, out ChannelOutMode _trigchoutmode);
            //if (rtn != 0) {
            //    Log.D($"Get Trig Mode Parameter Fail Err Code : {rtn:0x04}");
            //} else {
            //    GeneratorModeIndex = _triggenmode;
            //    ChOutputModeIndex = _trigchoutmode;
            //}

            //EncoderInputByIndex = (int)config.encinputmode;

            var config = _DeviceManager.GetDeviceConfig(_Trigger.DeviceId) as TriggerConfig;
            Timer_Set = config.trigTimerSet;
            TrigLimit_Set = config.trigLimitSet;
            for (int i = 0; i < 8; i++) {
                CheckedChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeEnable : false;
            }

            TableSettingIndex = config.encposmaptype;
            EncoderInputByIndex = config.encinputmode;
            EncoderDirectionIndex = config.EncDir;
            GeneratorModeIndex = config.trigGenMode;
            ChOutputModeIndex = config.chOutMode;

            Seq_StartEnc = config.seqStartEnc;
            Seq_IntervalEnc = config.seqIntervalEnc;
            Seq_IterationCnt = config.seqIterationCnt;

            // <HairPinTwister>
            return !(HW_Ver == null && SW_Ver == null);
        }

        private void OnMonitoring(object sender, EventArgs e)
        {
            if (_Trigger.IsActivated)
            {
                if (IsFirst == true)
                {
                    IsFirst = false;
                    CheckVersionAndInitialize();
                }
                /* <HairPinTwister> if (_Trigger.IsActivated) {
                if (_IsGetVersion == false) {
                    bool result = CheckVersionAndInitialize();
                    if (result) {
                        _IsGetVersion = true;
                    } else {
                        _IsGetVersion = false;
                    }
                }
            } else {
                _IsGetVersion = false;
*/
            }
        }

        private void PerformCMD_CheckTeachingMode(object obj)
        {
            string cmd_Param = obj as string;
            if (cmd_Param == "Normal")
            {
                TableSettingIndex = 0;
                EncoderInputByIndex = EncoderMode.Real;
                EncoderDirectionIndex = 0;
                //GeneratorModeIndex = 2;
                //ChOutputModeIndex = 0;
                GeneratorModeIndex = TriggerGenMode.Timer;
                ChOutputModeIndex = ChannelOutMode.Simple;
            }
            else   // cmd_Param == "Teaching"
            {
                TableSettingIndex = 0;
                EncoderInputByIndex = EncoderMode.Simulation;
                EncoderDirectionIndex = 0;
                //GeneratorModeIndex = 1;
                //ChOutputModeIndex = 0;
                GeneratorModeIndex = TriggerGenMode.Timer;
                ChOutputModeIndex = ChannelOutMode.Simple;
            }
        }

        private void PerformCMD_Setting(object obj)
        {
            //SetTriggerTableSetting()
            //int i = TableSettingIndex;
            EncoderPositionMap encposmap = TableSettingIndex;
            ushort rtn;
            //if (i == 0)
            if (encposmap == EncoderPositionMap.Normal) {
                rtn = _Trigger.DisableTrigCorrectTable();
                if (rtn == 0)
                {
                    Log.D("Encoder / Position 1:1 Match Setting OK");
                }
                else
                {
                    Log.D("Encoder / Position 1:1 Match Setting Fail");
                }
            }
            else
            {
                double[] Pos_Table = new double[256];
                ulong[] Enc_Table = new ulong[256];
                for (int J = 0; J < 256; J++)
                {
                    Pos_Table[J] = 0;
                    Enc_Table[J] = 0;
                }
                Pos_Table[0] = 0; Pos_Table[1] = 10000; Pos_Table[2] = 20000; Pos_Table[3] = 30000; Pos_Table[4] = 40000; Pos_Table[5] = 100000000;
                Enc_Table[0] = 0; Enc_Table[1] = 1010000; Enc_Table[2] = 1020000; ; Enc_Table[3] = 1030000; Enc_Table[4] = 1040000; Enc_Table[5] = 100000040000;

                rtn = _Trigger.SetTrigCorrectTable(Pos_Table, Enc_Table);

                if (rtn == 0)
                {
                    Log.D("Encoder / Position Calibration Mode Setting OK");
                }
                else
                {
                    Log.D("Encoder / Position Calibration Mode Setting Fail");
                }
            }
            ////
            ///

            //SetDropWatcherSetting()
            // 1. Set Input mode (Encoder or Automatic increase)
            rtn = _Trigger.SetEncoderDirection(EncoderDirectionIndex == 0 ? EncoderDirection.Forward : EncoderDirection.Backward);             // 0 : normal / 1 : reverse
            Log.D(string.Format("EncoderDirection Setting {0}, {1}", EncoderDirectionIndex == 0 ? "Normal" : "Reverse", rtn == 0 ? "OK" : "FAIL"));
            if(rtn !=0) return;

            // 2. Set Input Trigger Generation mode and Out mode
            TriggerGenMode GenMode = GeneratorModeIndex; // 0 -> Sequence, 1 -> Timer, 2 -> ExternalInput
            //switch (GeneratorModeIndex) {
            //    //case 0: GenMode = TriggerGenMode.Sequence; break;
            //    //case 1: GenMode = TriggerGenMode.Timer; break;
            //    //default: GenMode = TriggerGenMode.ExternalInput; break;
            //    case 0: GenMode = TriggerGenMode.Sequence; break;
            //    case 1: GenMode = TriggerGenMode.Direct; break;
            //    case 3: GenMode = TriggerGenMode.Timer; break;
            //    case 4: GenMode = TriggerGenMode.ExternalInput; break;
            //    default: GenMode = TriggerGenMode.Timer; break;
            //}

            ChannelOutMode OutMode = ChOutputModeIndex; // 0 - > Simple, 1 -> DirectMask;
                                    //OutMode = ChOutputModeIndex == 0 ? ChannelOutMode.Simple : ChannelOutMode.DirectMask;
            //switch (ChOutputModeIndex) {
            //    case 0: OutMode = ChannelOutMode.SeqBy1Trig; break;
            //    case 1: OutMode = ChannelOutMode.Simple; break;
            //    case 2: OutMode = ChannelOutMode.SequenceMask; break;
            //    default: OutMode = ChannelOutMode.Simple; break;
            //}

            rtn = _Trigger.SetTrigMode(GenMode, OutMode);
            Log.D(string.Format("4-2 Trig Generation Mode: {0}, Out Mode {1}, result {2}", GenMode, OutMode, rtn == 0 ? "OK" : "FAIL"));
            if(rtn != 0) return;

            rtn = _Trigger.SetTrigLimit(TrigLimit_Set);
            Log.D($"4-2 Trig Limit: {TrigLimit_Set}, result {rtn}");
            if (rtn != 0) return;

            // 3. Set parameter according to GenMode
            int i = 0;
            //switch ((int)GenMode)
            switch (GenMode) {
                //case 0: {     // Sequence mode
                case TriggerGenMode.Sequence: {
                        /*<HairPinTwister>
                                // 1. SetEncoderMode
                                ushort rtn = _Trigger.SetEncoderMode(EncoderMode.Real); // CntInType = 0
                                Log.D(string.Format("Set External Encoder(CntInType) {0}", rtn == 0 ? "OK" : "FAIL"));


                                // 2. SetTrigLimit
                                rtn = _Trigger.SetTrigLimit((uint)mode);                // SimulTrigLimit = 0
                                Log.D(string.Format("Set Trig Limit(SimulTrigLimit) {0}", rtn == 0 ? "OK" : "FAIL"));

                                */
                        byte NumberOfTrigSet = 2;                  // Max 254
                        TrigSeqSet[] TrigCmdSet = new TrigSeqSet[254];               // Max Sequence Set : 254

                        for (int k = 0; k < NumberOfTrigSet; k++)
                        {
                            TrigCmdSet[k].StartPosition = (1000000 * (int)i) - 100;
                            TrigCmdSet[k].Interval = 10.5;
                            TrigCmdSet[k].Iteration = 1000;
                            //TrigCmdSet[i].Out2_SeqMode_Sel = (byte)(k % 7);     // You can select 0~6 MaskSeqSet, if you don't use OutMode == 2 ignore this
                            //TrigCmdSet[i].WD_Set_Sel = (byte)(k % 8);           // Width Delay Set select
                        }

                        rtn = _Trigger.SetTriggerSet(NumberOfTrigSet, ref TrigCmdSet);
                        Log.D(string.Format("Set Normal Trig Mode (SetTrigSet) {0}", rtn == 0 ? "OK" : "FAIL"));
                    }
                    break;

                //case 3: { // Timer mode
                case TriggerGenMode.Timer: {

                        //double.TryParse(Timer_Set, out double timerPeriod_us);
                        rtn = _Trigger.SetTrigTimerSeq(Timer_Set);
                    Log.D(string.Format("Set Timer Trig Mode {0} {1}",
                                            rtn == 0 ? "OK" : "FAIL", rtn == 0 ? "" :
                                            rtn == 0x0101 ? "Setting Error" : "Run Error"));

                        //<HairPinTwister> 2. SetTrigLimit
                        /*
                        rtn = _Trigger.SetTrigLimit((uint)mode);                // SimulTrigLimit = 0
                        Log.D(string.Format("Set Trig Limit(SimulTrigLimit) {0}", rtn == 0 ? "OK" : "FAIL"));
                        */
                    }
                    break;

            }
            /*            NumberOfTrigSet = 20;                    // Max 254
            for (i = 0; i < NumberOfTrigSet; i++) {
            TrigCmdSet[i].TrigStart_Pos = 1000 - ( 1000 * i);
            TrigCmdSet[i].TrigInterbal = -101;
            TrigCmdSet[i].Iteration_Num = 10;
            }*/
            Log.D($"Trig Generation Mode: {GeneratorModeIndex.ToString()}, Parameter Setting {(rtn == 0 ? "OK" : "FAIL")}");
            if(rtn != 0) return;

            // 4. Set parameter according to OutMode

            //double Trig_Width_Delay_us[16];
            bool[][] StrobeEnable = new bool[8][];
            double[][] Trig_Width = new double[8][];
            double[][] Trig_Delay = new double[8][];
            for (i = 0; i < 8; i++)
            {
                StrobeEnable[i] = new bool[8];
                Trig_Width[i] = new double[8];
                Trig_Delay[i] = new double[8];
                for (int j = 0; j < 8; j++)
                {
                    StrobeEnable[i][j] = false;
                    Trig_Width[i][j] = 0;
                    Trig_Delay[i][j] = 0;
                }
            }

            byte Strobe_Ch = 0;

            //StrobeEnable[0][0] = (bool)CheckedChannel1;
            //Trig_Delay[0][0] = DelayChannel1;
            //Trig_Width[0][0] = WidthChannel1;
            //StrobeEnable[1][0] = (bool)CheckedChannel2;
            //Trig_Delay[1][0] = DelayChannel2;
            //Trig_Width[1][0] = WidthChannel2;
            //StrobeEnable[2][0] = (bool)CheckedChannel3;
            //Trig_Delay[2][0] = DelayChannel3;
            //Trig_Width[2][0] = WidthChannel3;
            //StrobeEnable[3][0] = (bool)CheckedChannel4;
            //Trig_Delay[3][0] = DelayChannel4;
            //Trig_Width[3][0] = WidthChannel4;
            //StrobeEnable[4][0] = (bool)CheckedChannel5;
            //Trig_Delay[4][0] = DelayChannel5;
            //Trig_Width[4][0] = WidthChannel5;
            //StrobeEnable[5][0] = (bool)CheckedChannel6;
            //Trig_Delay[5][0] = DelayChannel6;
            //Trig_Width[5][0] = WidthChannel6;
            //StrobeEnable[6][0] = (bool)CheckedChannel7;
            //Trig_Delay[6][0] = DelayChannel7;
            //Trig_Width[6][0] = WidthChannel7;
            //StrobeEnable[7][0] = (bool)CheckedChannel8;
            //Trig_Delay[7][0] = DelayChannel8;
            //Trig_Width[7][0] = WidthChannel8;
            for (i = 0; i < 8; i++) {
                StrobeEnable[i][0] = (bool)CheckedChannel[i];
                Trig_Delay[i][0] = DelayChannel[i];
                Trig_Width[i][0] = WidthChannel[i];
            }

            double[] Trig_Width_Delay_us = new double[16];
            //switch ((int)OutMode)
            switch (OutMode) {
                //case 0:     // Sequencial output by 1 trigger
                case ChannelOutMode.SeqBy1Trig:
                    uint Trig_Mask = 0;
                    for (int j = 0; j < /*SJT_STROBE_MAX_CH*/8; j++)
                    {
                        Strobe_Ch = (byte)j;
                        for (i = 0; i < /*SJT_STROBE_MAX_STEP*/8; i++)
                        {
                            if (StrobeEnable[Strobe_Ch][i]) Trig_Mask |= (uint)(0x1 << i);
                            else Trig_Mask &= (uint)(0xff ^ (0x1 << i));

                            Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
                            Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
                        }
                        _Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
                    }
                    break;


                //case 2:
                case ChannelOutMode.Simple:
                    byte[] MaskBitSet = new byte[8 * 8];

                    for (i = 0; i < 8; i++)
                        MaskBitSet[i] = 0;

                    for (i = 0; i < /*SJT_STROBE_MAX_CH*/8; i++)
                    {
                        for (int j = 0; j < /*SJT_STROBE_MAX_STEP*/8; j++)
                        {
                            if (true == StrobeEnable[i][j])
                            {
                                MaskBitSet[j] |= (byte)(0x1 << i);
                            }

                        }
                    }
                    rtn = _Trigger.SetMaskSet(ref MaskBitSet);
                    for (int j = 0; j < /*SJT_STROBE_MAX_CH*/8; j++)
                    {
                        Strobe_Ch = (byte)j;
                        Trig_Mask = 0;
                        for (i = 0; i < /*SJT_STROBE_MAX_STEP*/8; i++)
                        {
                            //if (m_bStrobe_En[Strobe_Ch][i])            StrobeSet_Ch[Strobe_Ch].Sequence_Mask |= (0x1 << i);
                            if (((MaskBitSet[i] >> j) & 0x1) == 1) Trig_Mask |= (uint)(0x1 << i);
                            else Trig_Mask &= (uint)(0xff ^ (0x1 << i));


                            Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
                            Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
                        }

                        _Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
                    }
                    break;
            }

            if (rtn == 0)
                Log.D("Trig Output Mode Parameter Setting OK");
            else
                Log.D("Trig Output Mode Parameter Setting Fail");
        }
        private void PerformCMD_TriggerStart(object obj)
        {
            ushort rtn = _Trigger.StartTrigger();

            Log.D(string.Format("SJT Trigger Start {0}", rtn == 0 ? "OK" : "FAIL"));
        }
        private void PerformCMD_TriggerStop(object obj)
        {
            ushort rtn = _Trigger.StopTrigger();

            Log.D(string.Format("SJT Trigger Stop {0}", rtn == 0 ? "OK" : "FAIL"));
        }

        private void PerformCMD_SetStrobe(object obj)
        {
            string ch = obj as string;
            int chIndex = 0;
            if (ch == "Ch1") { chIndex = 0; }
            else if (ch == "Ch2") { chIndex = 1; }
            else if (ch == "Ch3") { chIndex = 2; }
            else if (ch == "Ch4") { chIndex = 3; }
            else if (ch == "Ch5") { chIndex = 4; }
            else if (ch == "Ch6") { chIndex = 5; }
            else if (ch == "Ch7") { chIndex = 6; }
            else if (ch == "Ch8") { chIndex = 7; }
            else if (ch == "All") { chIndex = 8; }
            else { chIndex = 0; }

            if(chIndex == 8) {
                for(int i = 0; i < 8; i++) {
                    SetChStrobe(i);
                }
            } else {
                SetChStrobe(chIndex);
            }

            //<HaripinTwister>
            // // Trigger Out Mode - View(Index) 0: Simple => enum 3: DirectMask
            //ChannelOutMode OutMode = ChannelOutMode.DirectMask; // DirectMask Mode only - hardcoded
            // 4. Set OutMode related parameters
            //bool isParamSet = SetOutModeParameters(OutMode);
            //Log.D(string.Format("Out Mode: {0} Parameter Setting {1}", "Simple(Direct) Mask", isParamSet ? "OK" : "FAIL"));
        }

        private void SetChStrobe(int chIndex)
        {
            byte Strobe_Ch = (byte)chIndex;
            uint Trig_Mask = 0;

            bool[][] StrobeEnable = new bool[8][];
            double[][] Trig_Width = new double[8][];
            double[][] Trig_Delay = new double[8][];
            for (int i = 0; i < 8; i++)
            {
                StrobeEnable[i] = new bool[8];
                Trig_Width[i] = new double[8];
                Trig_Delay[i] = new double[8];

                for (int j = 0; j < 8; j++)
                {
                    StrobeEnable[i][j] = false;
                    Trig_Width[i][j] = 0;
                    Trig_Delay[i][j] = 0;
                }

            }

            //switch (chIndex)
            //{
            //    case 0:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel1;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel1;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel1;
            //        }
            //        break;
            //    case 1:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel2;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel2;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel2;
            //        }
            //        break;
            //    case 2:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel3;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel3;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel3;
            //        }
            //        break;
            //    case 3:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel4;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel4;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel4;
            //        }
            //        break;
            //    case 4:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel5;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel5;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel5;
            //        }
            //        break;
            //    case 5:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel6;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel6;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel6;
            //        }
            //        break;
            //    case 6:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel7;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel7;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel7;
            //        }
            //        break;
            //    case 7:
            //        {
            //            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel8;
            //            Trig_Width[Strobe_Ch][0] = WidthChannel8;
            //            Trig_Delay[Strobe_Ch][0] = DelayChannel8;
            //        }
            //        break;
            //}
            StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel[chIndex];
            Trig_Width[Strobe_Ch][0] = WidthChannel[chIndex];
            Trig_Delay[Strobe_Ch][0] = DelayChannel[chIndex];

            double[] Trig_Width_Delay_us = new double[16];
            for (int i = 0; i < 8; i++)
            {
                if (StrobeEnable[Strobe_Ch][i]) Trig_Mask |= (uint)(0x1 << i);
                else Trig_Mask &= (uint)(0xff ^ (0x1 << i));

                Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
                Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
            }

            _Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
        }
        private void PerformCMD_GetEncoderCnt(object obj)
        {
            long encoderCount;
            _Trigger.GetEncoderCount(out encoderCount);
            EncoderTriggerCount = encoderCount.ToString();
        }
        private void PerformCMD_ResetEncoderCount(object obj)
        {
            _Trigger.ResetEncoderCount();
        }
        private void PerformCMD_SetEncoderCount(object obj)
        {
            _Trigger.SetEncoderCount(Convert.ToInt32(EncoderTriggerCount));
        }
        private void PerformCMD_ResetSystem(object obj)
        {
            _Trigger.ResetSystem();
        }

        private void PerformCMD_GetAllParameter(object obj)
        {
            _Trigger.GetHWVersion(out string hw_ver, out string sw_ver);
            _Trigger.GetDllVersion(out string dll_ver);

            _Trigger.GetTrigTimeFreq(out uint TimerFreq_10ns);
            _Trigger.GetTrigTimeLimit(out uint TimeLimit);
            Timer_Set = ((double)(TimerFreq_10ns)) / 100.0;
            TrigLimit_Set = TimeLimit;

            ushort rtn;
            //uint[] Strobe_Ch_Para = new uint[17];
            byte mask = 0x00;
            double[] Width = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
            double[] Delay = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

            rtn = _Trigger.GetStrobe(0, ref mask, ref Width, ref Delay);

            for (int i = 0; i < 8; i++) {
                rtn = _Trigger.GetStrobe((byte)i, ref mask, ref Width, ref Delay);

                if (rtn != 0) {
                    Log.D($"Get Strobe Channel Parameter Fail Ch : {i + 1} Err Code : {rtn:0x04}");
                } else {
                    CheckedChannel[i] = (1 == ((mask >> 0) & 0x1)) ? true : false;

                    WidthChannel[i] = Width[0];

                    DelayChannel[i] = Delay[0];
                }
            }

            rtn = _Trigger.GetEncPosMapTableUse(out EncoderPositionMap encposmap);
            if (rtn != 0) {
                Log.D($"Get Trig Encoder Enable Parameter Fail Err Code : {rtn:0x04}");
            } else {
                TableSettingIndex = encposmap;
            }

            rtn = _Trigger.GetEncoderDirection(out EncoderDirection encdirection);
            if (rtn != 0) {
                Log.D($"Get Trig Encoder Direction Parameter Fail Err Code : {rtn:0x04}");
            } else {
                EncoderDirectionIndex = encdirection;
            }

            rtn = _Trigger.GetCntInType(out uint cnttype);
            if (rtn != 0) {
                Log.D($"Get Trig Encoder Input Type Parameter Fail Err Code : {rtn:0x04}");
            } else {
                EncoderInputByIndex = (EncoderMode)cnttype;
            }

            rtn = _Trigger.GetTrigMode(out TriggerGenMode _triggenmode, out ChannelOutMode _trigchoutmode);
            if (rtn != 0) {
                Log.D($"Get Trig Mode Parameter Fail Err Code : {rtn:0x04}");
            } else {
                GeneratorModeIndex = _triggenmode;
                ChOutputModeIndex = _trigchoutmode;
            }
        }

        private string encoderTriggerCount;

        public string EncoderTriggerCount { get => encoderTriggerCount; set => SetProperty(ref encoderTriggerCount, value); }

    }
}