using DIT.SharedMemory;
using log4net;
using log4net.Appender;
using log4net.Layout;
using log4net.Repository.Hierarchy;
using SocketCommunication;
using System;
using System.Collections;
using System.Net;
using System.Text;
using System.Threading;

namespace SHARP_CLAS_UI
{
    public class Client_Align:IDisposable
    {
        #region Logger
        /// <summary>
        /// Exception Log
        /// </summary>
        private ILog ClientLog = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");

        /// <summary>
        /// Exception Log Write
        /// </summary>
        /// <param name="Methodname">Method name of exception that occurred</param>
        /// <param name="ex">exception</param>
        public void WriteClientLog(string message)
        {
            if (ClientLog != null) ClientLog.Debug($"{message}");
        }
        #endregion

        #region Property
        public bool isConnected { get { return client == null ? false : client.isConnected; } }

        public string Ip { get { return ip; } }
        public int Port { get { return port; } }
        #endregion

        #region Field
        Equipment _equip;

        private SocketClient client;
        public Queue commandlist;

        Vision_Control vision_control;

        SharedMemory sm;

        private bool IsDisposed = false;
        public readonly string Clientname = "Align_PC";
        private string ip = "126.100.100.11";
        private int port = 8119;

        private Thread communicationThread;

        private int retry_connect_cnt;

        private DateTime alive_check;
        private DateTime connect_time_check;
        #endregion

        #region Construct
        public Client_Align(Equipment _equip, string ip, int port)
        {
            Create_Client_logger();

            this._equip = _equip;
            
            sm = new SharedMemory("SHARP_CLAS", 10000, true);
            sm.Open();

            vision_control = new Vision_Control();

            alive_check = DateTime.Now;
            connect_time_check = DateTime.Now;

            this.ip = ip;
            this.port = port;

            Init_Client();

            commandlist = new Queue();
            communicationThread = new Thread(Command_trigger);
            communicationThread.Start();
        }
        #endregion

        #region Function
        /// <summary>
        /// Create excepton logger
        /// </summary>
        private void Create_Client_logger()
        {
            Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
            RollingFileAppender rollingAppender = new RollingFileAppender();

            PatternLayout layout = new PatternLayout();
            hierarchy.Configured = true;

            rollingAppender.Name = "ClientRollingFile";
            rollingAppender.LockingModel = new RollingFileAppender.MinimalLock();
            rollingAppender.File = $@"D:\Logger\Align_Vision\";
            rollingAppender.AppendToFile = true;
            rollingAppender.DatePattern = "yyyy\\\\MM\\\\'Align_Vision'_dd'.log'";
            rollingAppender.RollingStyle = RollingFileAppender.RollingMode.Composite;
            rollingAppender.MaxSizeRollBackups = 10;
            rollingAppender.MaximumFileSize = "100MB";
            rollingAppender.StaticLogFileName = false;
            rollingAppender.Encoding = Encoding.UTF8;
            rollingAppender.PreserveLogFileNameExtension = true;
            layout = new PatternLayout("%d{yyyy/MM/dd HH:mm:ss.fff} %m%n");
            layout.ActivateOptions();
            rollingAppender.Layout = layout;
            rollingAppender.ActivateOptions();

            hierarchy.GetLogger("SHARP_CLAS_VISION_AOI_Vision");
            ILog log = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");
            Logger l = (Logger)log.Logger;
            l.Level = log4net.Core.Level.Debug;
            l.AddAppender(rollingAppender);

            ClientLog = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");
        }

        private void Init_Client()
        {
            if (client != null) client.Disconnect();

            client = new SocketClient(IPAddress.Parse(ip), port, Clientname);
            client.Add_received_event(Received);
        }

        public bool Connect()
        {
            try
            {
                if (client.Connect())
                {
                    Thread.Sleep(50);

                    if (client.isConnected)
                    {
                        WriteClientLog("Connection Success.");
                        alive_check = DateTime.Now;
                        return true;
                    }
                    else
                    {
                        WriteClientLog("Connection Fail.");
                        return false;
                    }
                }
                else
                {
                    WriteClientLog("Connection Fail.");
                    Init_Client();
                    return false;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public void DisConnect()
        {
            client.Disconnect();
        }

        public void Received(object sender, ReceiveEventArgs events)
        {
            byte[] data = new byte[events.stateobject.Received_data.Length];

            Array.Copy(events.stateobject.buffer, data, data.Length);

            //===============================================
            ArrayList recvList = new ArrayList();
            byte[] data1;
            byte[] data2;
            while (true)
            {
                bool check = RecvData(data, out data1, out data2);

                if (check)
                {
                    if (data1 != null)
                        recvList.Add(data1);

                    break;
                }
                else
                {
                    recvList.Add(data1);

                    data = data2;
                }
            }
            //===============================================
            WriteClientLog("Get data.");

            foreach (byte[] commands in recvList)
            {
                commandlist.Enqueue(commands);
            }
        }

        private bool RecvData(byte[] recvData, out byte[] Data1, out byte[] Data2)
        {
            try
            {
                ArrayList list = new ArrayList();

                byte[] data = new byte[recvData.Length];

                Array.Copy(recvData, data, data.Length);

                byte[] bsize = new byte[4];
                Array.Copy(data, bsize, bsize.Length);

                int size = BitConverter.ToInt32(bsize, 0) + 6;

                if (recvData.Length > size)
                {
                    Data1 = new byte[size];
                    Array.Copy(recvData, Data1, Data1.Length);

                    Data2 = new byte[recvData.Length - size];
                    Array.Copy(recvData, Data1.Length, Data2, 0, Data2.Length);

                    return false;
                }
                else if (recvData.Length == size)
                {
                    Data1 = new byte[size];
                    Array.Copy(recvData, Data1, Data1.Length);

                    Data2 = null;

                    return true;
                }
                else
                {
                    Data1 = recvData;
                    Data2 = null;

                    return true;
                }
            }
            catch (Exception ex)
            {
                WriteClientLog($"{ex.Message}");
                Data1 = null;
                Data2 = null;
                return true;
            }
        }

        public bool SendData(byte[] data)
        {
            try
            {
                if (client != null && client.isConnected)
                {
                    string str = string.Empty;
                    foreach (byte bt in data)
                    {
                        str += $"{bt} ";
                    }

                    return client.SendData(data);
                }
                else
                    throw new Exception($"{Clientname.ToString()} is not connected.");
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public void Command_trigger()
        {
            while (!IsDisposed)
            {
                try
                {
                    Thread.Sleep(10);

                    if (commandlist.Count > 0)
                    {
                        byte[] Recvdata = (byte[])commandlist.Dequeue();
                        byte[] size = new byte[4];
                        byte[] bcode = new byte[2];

                        Array.Copy(Recvdata, size, size.Length);
                        Array.Copy(Recvdata, 4, bcode, 0, bcode.Length);
                        short code = BitConverter.ToInt16(bcode, 0);

                        switch (code)
                        {
                            case 210:
                                {
                                    RecipeChangeAck recipe_change_Ack;
                                    vision_control.Recv_Recipe_Change_Ack(Recvdata, out recipe_change_Ack);

                                    WriteClientLog($"[Recv]Recipe_Change, Result : {recipe_change_Ack.result}");

                                    sm.Set_Bit(Vision_Address.Align_PC_Recipe_Change_Ack, true);
                                    sm.Set_Value(Vision_Address.Align_PC_Recipe_Change_Result, recipe_change_Ack.result);
                                    
                                    break;
                                }
                            case 220:
                                {
                                    GrabReadyAck grab_ready_Ack;
                                    vision_control.Recv_Grab_Read_Ack(Recvdata, out grab_ready_Ack);

                                    if (grab_ready_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                    {
                                        WriteClientLog($"[Recv]Film Judge Grab Ready, Result : {grab_ready_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Ack, true);
                                        sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
                                    }
                                    else if (grab_ready_Ack.SeqType == (int)En_SeqType.Pre_Align)
                                    {
                                        WriteClientLog($"[Recv]Pre Align Grab Ready, Result : {grab_ready_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Ack, true);
                                        sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
                                    }
                                    else if (grab_ready_Ack.SeqType == (int)En_SeqType.Fine_Align)
                                    {
                                        WriteClientLog($"[Recv]Fine Align Grab Ready, Result : {grab_ready_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Ack, true);
                                        sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
                                    }
                                    else if (grab_ready_Ack.SeqType == (int)En_SeqType.Measurement)
                                    {
                                        WriteClientLog($"[Recv]Measurement Grab Ready, Result : {grab_ready_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Measurement_Grab_Ready_Ack, true);
                                        sm.Set_Bit(Vision_Address.Measurement_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
                                    }

                                    break;
                                }
                            case 230:
                                {
                                    GrabStartAck grab_start_Ack;
                                    vision_control.Recv_Grab_Start_Ack(Recvdata, out grab_start_Ack);

                                    if (grab_start_Ack.ModuleIdx == (int)En_Module_Idx.Left)
                                    {
                                        if (grab_start_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                        {
                                            WriteClientLog($"[Recv]Film Judge Left Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Ack, true);
                                            sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Pre_Align)
                                        {
                                            WriteClientLog($"[Recv]Pre Align Left Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Ack, true);
                                            sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Fine_Align)
                                        {
                                            WriteClientLog($"[Recv]Fine Align Left Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Ack, true);
                                            sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Measurement)
                                        {
                                            WriteClientLog($"[Recv]Measurement Left Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Left_Ack, true);
                                            sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                    }
                                    else if (grab_start_Ack.ModuleIdx == (int)En_Module_Idx.Right)
                                    {
                                        if (grab_start_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                        {
                                            WriteClientLog($"[Recv]Film Judge Right Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Ack, true);
                                            sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Pre_Align)
                                        {
                                            WriteClientLog($"[Recv]Pre Align Right Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Ack, true);
                                            sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Fine_Align)
                                        {
                                            WriteClientLog($"[Recv]Fine Align Right Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Ack, true);
                                            sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                        else if (grab_start_Ack.SeqType == (int)En_SeqType.Measurement)
                                        {
                                            WriteClientLog($"[Recv]Measurement Right Grab Start, Result : {grab_start_Ack.result}");
                                            sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Right_Ack, true);
                                            sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
                                        }
                                    }
                                  
                                    break;
                                }
                            case 241:
                                {
                                    FilmJudgeResultAck film_judge_result_Ack;
                                    vision_control.Recv_Film_Judge_Result(Recvdata, out film_judge_result_Ack);
                                    if(film_judge_result_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                    {
                                        WriteClientLog($"[Recv]Film Judge Left Result, Result : {film_judge_result_Ack.film_result}");
                                        sm.Set_Bit(Vision_Address.Film_Judge_Left_Ack, true);
                                        sm.Set_Value(Vision_Address.Film_Judge_Left_Result, film_judge_result_Ack.film_result);
                                    }

                                    break;
                                }
                            case 242:
                                {
                                    FilmJudgeResultAck film_judge_result_Ack;
                                    vision_control.Recv_Film_Judge_Result(Recvdata, out film_judge_result_Ack);

                                    if (film_judge_result_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                    {
                                        WriteClientLog($"[Recv]Film Judge Right Result, Result : {film_judge_result_Ack.film_result}");
                                        sm.Set_Bit(Vision_Address.Film_Judge_Right_Ack, true);
                                        sm.Set_Value(Vision_Address.Film_Judge_Right_Result, film_judge_result_Ack.film_result);
                                    }
                                    break;
                                }
                            case 251:
                                {
                                    AlignResultAck align_result_Ack;
                                    vision_control.Recv_Align_Result(Recvdata, out align_result_Ack);
                                    
                                    WriteClientLog($"[Recv]Pre Align Left Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}");
                                    sm.Set_Bit(Vision_Address.Pre_Align_Left_Ack, true);
                                    sm.Set_Value(Vision_Address.Pre_Align_Left_Result, align_result_Ack.align_result);
                                    sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_X, align_result_Ack.AlignX);
                                    sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_Y, align_result_Ack.AlignY);
                                    sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_T, align_result_Ack.AlignAngle);

                                    break;
                                }
                            case 252:
                                {
                                    AlignResultAck align_result_Ack;
                                    vision_control.Recv_Align_Result(Recvdata, out align_result_Ack);
                                    
                                    WriteClientLog($"[Recv]Pre Align Right Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}");
                                    sm.Set_Bit(Vision_Address.Pre_Align_Right_Ack, true);
                                    sm.Set_Value(Vision_Address.Pre_Align_Right_Result, align_result_Ack.align_result);
                                    sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_X, align_result_Ack.AlignX);
                                    sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_Y, align_result_Ack.AlignY);
                                    sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_T, align_result_Ack.AlignAngle);

                                    break;
                                }
                            case 261:
                                {
                                    MeasurementResultAck measurement_result_Ack;
                                    vision_control.Recv_Measurement_Result(Recvdata, out measurement_result_Ack);

                                    if (measurement_result_Ack.moduleIdx == (int)En_Module_Idx.Left)
                                    {
                                        WriteClientLog($"[Recv]Measurement Left Result, Result : {measurement_result_Ack.align_result}, Mark_1_Point_1 : {measurement_result_Ack.Mark1Point1}, Mark_1_Point_2 : {measurement_result_Ack.Mark1Point2}, Mark_2_Point_1 : {measurement_result_Ack.Mark2Point1}, Mark_2_Point_2 : {measurement_result_Ack.Mark2Point2}, Mark_Distance : {measurement_result_Ack.MarkDistance}, Align_Result : {measurement_result_Ack.align_result}");
                                        sm.Set_Bit(Vision_Address.Measurement_Left_Ack, true);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Result, measurement_result_Ack.measurement_result);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_1_Point_1, measurement_result_Ack.Mark1Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_1_Point_2, measurement_result_Ack.Mark1Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_2_Point_1, measurement_result_Ack.Mark2Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_2_Point_2, measurement_result_Ack.Mark2Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_3_Point_1, measurement_result_Ack.Mark3Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_3_Point_2, measurement_result_Ack.Mark3Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_4_Point_1, measurement_result_Ack.Mark4Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_4_Point_2, measurement_result_Ack.Mark4Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Mark_Distance, measurement_result_Ack.MarkDistance);
                                        sm.Set_Value(Vision_Address.Measurement_Left_Align_Result, measurement_result_Ack.align_result);
                                    }
                                    break;
                                }
                            case 262:
                                {
                                    MeasurementResultAck measurement_result_Ack;
                                    vision_control.Recv_Measurement_Result(Recvdata, out measurement_result_Ack);
                                    if (measurement_result_Ack.moduleIdx == (int)En_Module_Idx.Right)
                                    {
                                        WriteClientLog($"[Recv]Measurement Right Result, Result : {measurement_result_Ack.align_result}, Mark_1_Point_1 : {measurement_result_Ack.Mark1Point1}, Mark_1_Point_2 : {measurement_result_Ack.Mark1Point2}, Mark_2_Point_1 : {measurement_result_Ack.Mark2Point1}, Mark_2_Point_2 : {measurement_result_Ack.Mark2Point2}, Mark_Distance : {measurement_result_Ack.MarkDistance}, Align_Result : {measurement_result_Ack.align_result}");
                                        sm.Set_Bit(Vision_Address.Measurement_Right_Ack, true);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Result, measurement_result_Ack.measurement_result);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_1_Point_1, measurement_result_Ack.Mark1Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_1_Point_2, measurement_result_Ack.Mark1Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_2_Point_1, measurement_result_Ack.Mark2Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_2_Point_2, measurement_result_Ack.Mark2Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_3_Point_1, measurement_result_Ack.Mark3Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_3_Point_2, measurement_result_Ack.Mark3Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_4_Point_1, measurement_result_Ack.Mark4Point1);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_4_Point_2, measurement_result_Ack.Mark4Point2);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Mark_Distance, measurement_result_Ack.MarkDistance);
                                        sm.Set_Value(Vision_Address.Measurement_Right_Align_Result, measurement_result_Ack.align_result);
                                    }
                                    break;
                                }
                            case 271:
                                {
                                    FineAlignResultAck align_result_Ack;
                                    vision_control.Recv_Fine_Align_Result(Recvdata, out align_result_Ack);
                                    
                                    WriteClientLog($"[Recv]Fine Align Left Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}, Mark Distance : {align_result_Ack.Mark_Distance}");
                                    sm.Set_Bit(Vision_Address.Fine_Align_Left_Ack, true);
                                    sm.Set_Value(Vision_Address.Fine_Align_Left_Result, align_result_Ack.align_result);
                                    sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_X, align_result_Ack.AlignX);
                                    sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_Y, align_result_Ack.AlignY);
                                    sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_T, align_result_Ack.AlignAngle);
                                    sm.Set_Value(Vision_Address.Fine_Align_Left_Mark_Distance, align_result_Ack.Mark_Distance);

                                    break;
                                }
                            case 272:
                                {
                                    FineAlignResultAck align_result_Ack;
                                    vision_control.Recv_Fine_Align_Result(Recvdata, out align_result_Ack);
                                    
                                    WriteClientLog($"[Recv]Fine Align Right Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}, Mark Distance : {align_result_Ack.Mark_Distance}");
                                    sm.Set_Bit(Vision_Address.Fine_Align_Right_Ack, true);
                                    sm.Set_Value(Vision_Address.Fine_Align_Right_Result, align_result_Ack.align_result);
                                    sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_X, align_result_Ack.AlignX);
                                    sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_Y, align_result_Ack.AlignY);
                                    sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_T, align_result_Ack.AlignAngle);
                                    sm.Set_Value(Vision_Address.Fine_Align_Right_Mark_Distance, align_result_Ack.Mark_Distance);

                                    break;
                                }
                            case 281:
                                {
                                    MotorPosMoveReq motor_pos_move_Req;
                                    vision_control.Recv_Motor_Pos_Move_Req(Recvdata, out motor_pos_move_Req);
                                    if (motor_pos_move_Req.SeqType == (int)En_SeqType.Film_Judge)
                                    {
                                        WriteClientLog($"[Recv]Film Judge Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
                                        sm.Set_Bit(Vision_Address.Film_Judge_Motor_Pos_Ack, true);
                                        sm.Set_Value(Vision_Address.Film_Judge_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
                                        sm.Set_Value(Vision_Address.Film_Judge_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
                                    }
                                    else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Pre_Align)
                                    {
                                        WriteClientLog($"[Recv]Pre Align Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
                                        sm.Set_Bit(Vision_Address.Pre_Align_Motor_Pos_Ack, true);
                                        sm.Set_Value(Vision_Address.Pre_Align_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
                                        sm.Set_Value(Vision_Address.Pre_Align_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
                                    }
                                    else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Fine_Align)
                                    {
                                        WriteClientLog($"[Recv]Fine Align Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
                                        sm.Set_Bit(Vision_Address.Fine_Align_Motor_Pos_Ack, true);
                                        sm.Set_Value(Vision_Address.Fine_Align_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
                                        sm.Set_Value(Vision_Address.Fine_Align_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
                                    }
                                    else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Measurement)
                                    {
                                        WriteClientLog($"[Recv]Measurement Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
                                        sm.Set_Bit(Vision_Address.Measurement_Motor_Pos_Ack, true);
                                        sm.Set_Value(Vision_Address.Measurement_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
                                        sm.Set_Value(Vision_Address.Measurement_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
                                    }
                                    break;
                                }
                            case 291:
                                {
                                    UserCommandAck user_command_Ack;
                                    vision_control.Recv_User_Command_Ack(Recvdata, out user_command_Ack);

                                    if (user_command_Ack.SeqType == (int)En_SeqType.Film_Judge)
                                    {
                                        WriteClientLog($"[Recv]Film Judge User Command, Result : {user_command_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Film_Judge_User_Command_Ack, true);
                                        sm.Set_Value(Vision_Address.Film_Judge_User_Command_Result, user_command_Ack.result);
                                    }
                                    else if (user_command_Ack.SeqType == (int)En_SeqType.Pre_Align)
                                    {
                                        WriteClientLog($"[Recv]Pre Align User Command, Result : {user_command_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Pre_Align_User_Command_Ack, true);
                                        sm.Set_Value(Vision_Address.Pre_Align_User_Command_Result, user_command_Ack.result);
                                    }
                                    else if (user_command_Ack.SeqType == (int)En_SeqType.Fine_Align)
                                    {
                                        WriteClientLog($"[Recv]Fine Align User Command, Result : {user_command_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Fine_Align_User_Command_Ack, true);
                                        sm.Set_Value(Vision_Address.Fine_Align_User_Command_Result, user_command_Ack.result);
                                    }
                                    else if (user_command_Ack.SeqType == (int)En_SeqType.Measurement)
                                    {
                                        WriteClientLog($"[Recv]Measurement User Command, Result : {user_command_Ack.result}");
                                        sm.Set_Bit(Vision_Address.Measurement_User_Command_Ack, true);
                                        sm.Set_Value(Vision_Address.Measurement_User_Command_Result, user_command_Ack.result);
                                    }
                                    break;
                                }
                            case 292:
                                {
                                    SystemTimeSyncAck system_time_sync_Ack;
                                    vision_control.Recv_System_Time_Sync_Ack(Recvdata, out system_time_sync_Ack);

                                    WriteClientLog($"[Recv]System Time Sync, Result : {system_time_sync_Ack.result}");
                                    sm.Set_Bit(Vision_Address.Align_PC_System_Time_Sync_Ack, true);
                                    sm.Set_Value(Vision_Address.Align_PC_System_Time_Sync_Result, system_time_sync_Ack.result);
                                    break;
                                }
                            case 100:
                                {
                                    VisionAliveAck vision_alive_Ack;
                                    vision_control.Recv_Vision_Alive(Recvdata, out vision_alive_Ack);

                                    if (vision_alive_Ack.Controller == 1)
                                    {
                                        sm.Set_Bit(Vision_Address.Align_PC_Vision_Alive_Ack, true);
                                        sm.Set_Value(Vision_Address.Align_PC_Vision_Alive_Heart_Beat, vision_alive_Ack.HeartBeat);
                                    }
                                    else if (vision_alive_Ack.Controller == 2)
                                    {
                                        sm.Set_Bit(Vision_Address.AOI_PC_Vision_Alive_Ack, true);
                                        sm.Set_Value(Vision_Address.AOI_PC_Vision_Alive_Heart_Beat, vision_alive_Ack.HeartBeat);
                                    }

                                    alive_check = DateTime.Now;
                                    break;
                                }
                            default:
                                break;
                        }
                    }

                    if ((DateTime.Now - alive_check).TotalSeconds > _equip.Setting.Vision_Connect_Time)
                    {
                        if (client.isConnected)
                        {
                            client.Disconnect();
                            continue;
                        }
                    }

                    if (!client.isConnected)
                    {
                        if ((DateTime.Now - connect_time_check).TotalSeconds > 3)
                        {
                            if (Connect())
                            {
                                retry_connect_cnt = 0;
                            }
                            else
                            {
                                if (retry_connect_cnt > 3)
                                {
                                    //Alarm.
                                }

                                //Init_Client();
                                retry_connect_cnt++;
                            }

                            connect_time_check = DateTime.Now;
                        }
                    }
                }
                catch (Exception ex)
                {
                }
            }
        }

        public void Dispose()
        {
            IsDisposed = true;
            client.Disconnect();
        }
        #endregion

        #region Send_Function
        /// <summary>
        /// Send Recipe Change Req
        /// </summary>
        /// <param name="RecipeMode">Recipe Move, 1 : 추가 , 2 : 변경(default), 3 : 삭제 => 현재 변경 고정 사용</param>
        /// <param name="RecipeName">제품 구분 정보(레시피 명)</param>
        public bool Send_Recipe_Change_Req(int RecipeMode, string RecipeName)
        {
            sm.Set_Bit(Vision_Address.Align_PC_Recipe_Change_Ack, false);

            WriteClientLog($"[Send]Recipe_Change, RecipeMode : {RecipeMode}, RecipeName : {RecipeName}");

            return SendData(vision_control.Send_Recipe_Change_Req(RecipeMode, RecipeName));
        }

        /// <summary>
        ///  Send Grab Ready Req
        /// </summary>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
        /// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
        /// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
        /// <param name="SlotNo">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Film_Judge_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
        {
            int SeqType = 0;

            sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Ack, false);

            if (ModuleIdx == 0)
                sm.Set_Bit(Vision_Address.Film_Judge_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Film_Judge_Right_Ack, false);

            WriteClientLog($"[Send]Film Judge Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");

            return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
        }

        /// <summary>
        /// Send Grab Start Req
        /// </summary>
        /// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
        /// <param name="MotorOffsetX">현재 Motor Position X</param>
        /// <param name="MotorOffsetY">현재 Motor Position Y</param>
        public bool Send_Film_Judge_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
        {
            int SeqType = 0;

            if (ModelIdx == 0)
                sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Ack, false);

            WriteClientLog($"[Send]Film Judge Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");

            return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
        }

        /// <summary>
        /// Send Command Req
        /// </summary>
        /// <param name="CmdType">0: Scrap(제거, 1: Retry(재시도), 3: Skip(NG), 4: Pass(OK), 5: User(수동선택)</param>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="Slot_No">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Film_Judge_Command(int CmdType, int ModuleIdx, int Slot_No, int PnlIdx, string PanelID)
        {
            int SeqType = 0;

            sm.Set_Bit(Vision_Address.Film_Judge_User_Command_Ack, false);

            WriteClientLog($"[Send]Film Judge Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {Slot_No}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");

            return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, Slot_No, PnlIdx, PanelID));
        }

        /// <summary>
        ///  Send Grab Ready Req
        /// </summary>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
        /// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
        /// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
        /// <param name="SlotNo">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Pre_Align_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
        {
            int SeqType = 1;

            sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Ack, false);

            if (ModuleIdx == 0)
                sm.Set_Bit(Vision_Address.Pre_Align_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Pre_Align_Right_Ack, false);

            WriteClientLog($"[Send]Pre Align Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
            
            return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
        }

        /// <summary>
        /// Send Grab Start Req
        /// </summary>
        /// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
        /// <param name="MotorOffsetX">현재 Motor Position X</param>
        /// <param name="MotorOffsetY">현재 Motor Position Y</param>
        public bool Send_Pre_Align_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
        {
            int SeqType = 1;

            if (ModelIdx == 0)
                sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Ack, false);

            WriteClientLog($"[Send]Pre Align Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");

            return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
        }

        /// <summary>
        /// Send Command Req
        /// </summary>
        /// <param name="CmdType">0: Scrap(제거), 1: Retry(재시도), 2: Skip(NG), 3: Pass(OK), 4: User(수동선택)</param>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="Slot_No">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Pre_Align_Command(int CmdType, int ModuleIdx, int Slot_No, int PnlIdx, string PanelID)
        {
            int SeqType = 1;

            sm.Set_Bit(Vision_Address.Pre_Align_User_Command_Ack, false);

            WriteClientLog($"[Send]Pre Align Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {Slot_No}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");

            return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, Slot_No, PnlIdx, PanelID));
        }

        /// <summary>
        ///  Send Grab Ready Req
        /// </summary>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
        /// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
        /// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
        /// <param name="SlotNo">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Fine_Align_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
        {
            int SeqType = 2;

            sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Ack, false);

            if (ModuleIdx == 0)
                sm.Set_Bit(Vision_Address.Fine_Align_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Fine_Align_Right_Ack, false);

            WriteClientLog($"[Send]Fine Align Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");

            return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
        }

        /// <summary>
        /// Send Grab Start Req
        /// </summary>
        /// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
        /// <param name="MotorOffsetX">현재 Motor Position X</param>
        /// <param name="MotorOffsetY">현재 Motor Position Y</param>
        public bool Send_Fine_Align_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
        {
            int SeqType = 2;

            if (ModelIdx == 0)
                sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Ack, false);
            else
                sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Ack, false);

            WriteClientLog($"[Send]Fine Align Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");

            return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
        }

        /// <summary>
        /// Send Command Req
        /// </summary>
        /// <param name="CmdType">0: Scrap(제거, 1: Retry(재시도), 3: Skip(NG), 4: Pass(OK), 5: User(수동선택)</param>
        /// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
        /// <param name="SlotNo">Tray Slot 번호</param>
        /// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
        /// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
        public bool Send_Fine_Align_Command(int CmdType, int ModuleIdx, int SlotNo, int PnlIdx, string PanelID)
        {
            int SeqType = 2;

            sm.Set_Bit(Vision_Address.Fine_Align_User_Command_Ack, false);

            WriteClientLog($"[Send]Fine Align Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");

            return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, SlotNo, PnlIdx, PanelID));
        }

        /// <summary>
        /// Send Motor Pos Move Ack
        /// </summary>
        /// <param name="Return"> 0 : 위치 이동 완료 (Success), n : 기타 에러(Fail) 제어 정의.</param>
        public bool Send_Motor_Pos_Move_Ack(int Return)
        {
            sm.Set_Bit(Vision_Address.Fine_Align_Motor_Pos_Ack, false);

            WriteClientLog($"[Send]Motor_Pos_Move, Return : {Return}");

            return SendData(vision_control.Send_Motor_Pos_Move_Ack(Return));
        }

        /// <summary>
        /// Send System Time Sync Req
        /// </summary>
        public bool Send_System_Time_Sync()
        {
            sm.Set_Bit(Vision_Address.AOI_PC_System_Time_Sync_Ack, false);

            return SendData(vision_control.Send_System_Time_Sync_Req());
        }
        #endregion
    }
}