using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Diagnostics;

namespace FPER
{
    public class TSocket
    {// ���� Ŭ����
        private TcpClient cmd_tcpclient;
        private TcpClient event_tcpclient;

        private Tprotocol tprotocol;

        private String DestIP;
        private int commandPort;
        private int eventPort;

        private Thread cmd_rcv_th;
        private int cmd_rcv_th_state = 0;
        private NetworkStream cmd_sendStm, cmd_recvStm;
        private NetworkStream event_sendStm, event_recvStm;

        private Thread event_rcv_th;
        private int event_rcv_th_state;

        byte[] CMD_RcvBuffer = new byte[2048];
        int CMD_RcvBufferPos = 0;
        LogFileCreate LFC = new LogFileCreate();

        private bool cmdConnected = false;
        private bool eventConnected = false;

        public delegate int dRcvProcess(byte[] buffer, int size);

        private event dRcvProcess CMDRcvProcess;
        private event dRcvProcess EVENTRcvProcess;

        public TSocket(String Dest_ip, int commandPort, int eventPort, int Demon_ID, Tprotocol tp)
        {
            try
            {
                this.DestIP = Dest_ip;
                // LCH 2018.02.27 : ������ �ٸ� PC�� �д�
                //this.DestIP = "192.168.100.218";
                this.commandPort = commandPort;
                this.eventPort = eventPort;
                this.tprotocol = tp;

                CMDRcvProcess += new dRcvProcess(this.tprotocol.CMDResponceFunc);
                EVENTRcvProcess += new dRcvProcess(this.tprotocol.EVENTCallFunc);

                this.cmd_tcpclient = new TcpClient();
                this.event_tcpclient = new TcpClient();
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
        }

        public int ConnectSocket()
        {// ���� ���� �Լ� 
            int iret = 0;
            try
            {
                iret = this.Start_Connection();
                if (iret == 1)
                {// ���� ������ 
                    this.cmdConnected = true;
                    this.eventConnected = true;

                    iret = this.cmd_tcpclient.Connected ? 1 : 0;
                }
            }
            catch (Exception ex)
            {
                iret = -1;
                Util.UErrorMessage(ex, 0, 0);
            }
            return iret;
        }

        public int DisconnectToDemon(int Own_ID, int Demon_ID)
        {// ���� ���� ����
            try
            {
                Stop_Connection();
                this.cmdConnected = false;
                this.eventConnected = false;
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return 0;
        }

        IPEndPoint CommandEndPoint { get { return new IPEndPoint(IPAddress.Parse(this.DestIP), this.commandPort); } }
        IPEndPoint EventEndPoint { get { return new IPEndPoint(IPAddress.Parse(this.DestIP), this.eventPort); } }

        //cmd��������
        public Boolean cmd_Connected
        {//2010,11,22, k.s.d , demon connection status check routine rollback , ( Ź���� ������ �߰��� �ٲ���. �� �ٲ����� �� )
            get
            {
                Boolean TcpConnected = false;
                try
                {
                    //if (this.cmd_tcpclient != null) {
                    //  TcpConnected = this.cmd_tcpclient.Connected;
                    //  if (TcpConnected) {
                    //    TcpConnected = this.cmdConnected;
                    //  }
                    //}
                    ////
                    if (this.cmd_tcpclient != null) TcpConnected = this.cmdConnected;
                }
                catch (Exception ex)
                {
                    Util.UErrorMessage(ex, 0, 0);
                }
                return TcpConnected;
            }
        }

        //�̺�Ʈ��������
        public Boolean event_Connected
        {//2010,11,22, k.s.d , demon connection status check routine rollback , ( Ź���� ������ �߰��� �ٲ���. �� �ٲ����� �� )
            get
            {
                Boolean TcpConnected = false;
                try
                {
                    //if (this.event_tcpclient != null) {
                    //  TcpConnected = this.event_tcpclient.Connected;
                    //  if (TcpConnected) {
                    //    TcpConnected = this.eventConnected;
                    //  }
                    //}
                    ////
                    if (this.event_tcpclient != null) TcpConnected = this.eventConnected;
                }
                catch (Exception ex)
                {
                    Util.UErrorMessage(ex, 0, 0);
                }
                return TcpConnected;
            }
        }

        public int Start_Connection()
        {// ���� ���� �Լ� 
            int ret = 0;
            try
            {
                ret = Start_Con_cmd();

                if (ret == 1)
                {// ���� ����
                    ret = Start_Con_event();
                }
            }
            catch (Exception ex)
            {
                ret = -1;
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret;
        }

        // cyim 2016.12.29 : ȭ�� ���� ���� ����
        public delegate void Connect_Thread_Inform_Handler();
        public event Connect_Thread_Inform_Handler Connect_Thread_Inform_Event;
        public bool Connect_Thread_Inform_Event_Receive = false;
        public void Connect_Thread(TcpClient socket, int port, TimeSpan timeout)
        {
            Connect_Thread_Inform_Event_Receive = false;
            if (this.Connect_Thread_Inform_Event != null)
                this.Connect_Thread_Inform_Event -= new Connect_Thread_Inform_Handler(TSocket_Connect_Thread_Inform_Event);
            this.Connect_Thread_Inform_Event += new Connect_Thread_Inform_Handler(TSocket_Connect_Thread_Inform_Event);
            _ConnectThread ConnectThread = new _ConnectThread();
            ConnectThread.socket = socket;
            ConnectThread.port = port;
            ConnectThread.timeout = timeout;

            // ������� ����
            Thread WorkingThread = new Thread(new ParameterizedThreadStart(Connect_Thread_WorkFunction));
            WorkingThread.Start(ConnectThread);

            // cyim 2017.01.02 
            // ���α׷� ������ ���� ���� �������� �ǵ��ʹ� �ٸ��� �ҹ� ���Ź��� ȭ������� ó���ϱ� ���� �Ϻ� �����ؾ� �Ѵ�
            // ��, �ڵ� ��ƾ �߰��� ������ ���� �����̰� �߻��ϴ°��� ��¿������ �̺�Ʈ ó���� �ؾ��Ѵ�
            // �ҽ� ��ƾ �߰��� ���ӿ��θ� ����� �ڵ带 �񵿱�� ó���ϱ� ���ؼ� AutoResetEvent �� ���� �����尡 �������� �̺�Ʈ�� ��ٸ��� �Ҽ��� ������
            // ���� ������ ������ �����ؾ� �ǹǷ� �񵿱�+������ �� ���� ��Ȳ������ �� ����� �ּ��ΰͰ��� 

            while (true)
            {
                if (Connect_Thread_Inform_Event_Receive)
                    break;
            }
            if (this.Connect_Thread_Inform_Event != null)
                this.Connect_Thread_Inform_Event -= new Connect_Thread_Inform_Handler(TSocket_Connect_Thread_Inform_Event);
        }

        public void TSocket_Connect_Thread_Inform_Event()
        {
            Connect_Thread_Inform_Event_Receive = true;
        }

        // �����Լ��� �����嵵 ��ü�ϰ� Ÿ�Ӿƿ��� �߻����Ѽ� ����� ȹ���Ѵ�
        public bool Connect_Thread_Result = false;
        public void Connect_Thread_WorkFunction(object obj)
        {
            // ���� ������ ���� ����
            _ConnectThread ConnectThread = (_ConnectThread)obj;
            TcpClient socket = ConnectThread.socket;
            int port = ConnectThread.port;
            TimeSpan timeout = ConnectThread.timeout;

            try
            {
                IPAddress addr = IPAddress.Parse(this.DestIP);
                var result = socket.BeginConnect(addr, port, null, null);
                bool success = result.AsyncWaitHandle.WaitOne(timeout, true);

                if (success)
                {
                    socket.EndConnect(result);
                    Connect_Thread_Result = true;
                }
                else
                {
                    socket.Close();
                    Connect_Thread_Result = false;
                    Console.WriteLine(this.DestIP);
                }
            }
            catch
            {
                socket.Close();
                Connect_Thread_Result = false;
            }
            TSocket_Connect_Thread_Inform_Event();
        }

        // 2010,11,25, k.s.d , return value add . 
        int Start_Con_cmd()
        {
            int ret = 0;
            try
            {
                // cyim 2016.12.29 : ȭ�� ���� ���� ����
                if (_Data.FireDeskMode == true)
                {
                    Connect_Thread(this.cmd_tcpclient, this.commandPort, new TimeSpan(0, 0, 1));
                }
                else
                {
                    this.cmd_tcpclient.Connect(this.CommandEndPoint);
                }

                this.cmd_sendStm = new NetworkStream(this.cmd_tcpclient.Client);
                this.cmd_recvStm = new NetworkStream(this.cmd_tcpclient.Client);

                this.cmd_rcv_th = new Thread(this.Cmd_ReceiveThread);
                this.cmd_rcv_th_state = 1;
                if (this.cmd_rcv_th != null)  // ������ �Ҵ� ���� Ȯ���� ���۽�Ŵ.
                {
                    this.cmd_rcv_th.Start();
                }
                ret = 1;
            }
            catch (Exception ex)
            {
                ret = -1;
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret;

        }

        // 2010,11,25, k.s.d , return value add . 
        int Start_Con_event()
        {
            int ret = 0;
            try
            {
                // cyim 2016.12.29 : ȭ�� ���� ���� ����
                if (_Data.FireDeskMode == true)
                {
                    Connect_Thread(this.event_tcpclient, this.eventPort, new TimeSpan(0, 0, 1));
                }
                else
                {
                    this.event_tcpclient.Connect(this.EventEndPoint);
                }

                this.event_sendStm = new NetworkStream(this.event_tcpclient.Client);
                if (this.event_sendStm == null)
                {
                    ret = -1;
                    return ret;
                }

                this.event_recvStm = new NetworkStream(this.event_tcpclient.Client);
                if (this.event_recvStm == null)
                {
                    ret = -1;
                    return ret;
                }

                this.event_rcv_th = new Thread(this.Event_ReceiveThread);
                if (this.event_rcv_th != null)
                {
                    //===============================================
                    // ���� �߰� ���� 2013-06-05  CSW
                    //===============================================
                    this.event_rcv_th_state = 1;
                    this.event_rcv_th.Start();
                    ret = 1;
                }
                else
                {
                    ret = -1;
                }
                //Util.UDebugMessage("Start_Con_event Start",0,0);

            }
            catch (Exception ex)
            {
                ret = -1;
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret;
        }

        public void Stop_Connection()
        {
            try
            {
                //Util.UDebugMessage("Stop",0,0);
                Stop_Con_cmd();
                Stop_Con_event();
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
        }

        void Stop_Con_cmd()
        {
            try
            {
                //        if (this.cmd_rcv_th_state == 1) this.cmd_rcv_th.Abort();
                if (this.cmd_rcv_th != null) // cyim 2016.12.28 : ����ó�� �߰�
                    if (this.cmd_rcv_th.IsAlive)
                        this.cmd_rcv_th.Abort();  // ������ ����.

                if (this.cmd_tcpclient != null) this.cmd_tcpclient.Close();
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
        }

        void Stop_Con_event()
        {
            try
            {
                //if (this.event_rcv_th_state == 1) this.event_rcv_th.Abort();
                if (this.event_rcv_th != null) // cyim 2016.12.28 : ����ó�� �߰�
                    if (this.event_rcv_th.IsAlive)
                        this.event_rcv_th.Abort();

                if (this.event_tcpclient != null) this.event_tcpclient.Close();
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
        }

        //��������
        public int Cmd_Send(byte[] bt, int size)
        { //2010.3.12ksd ,// cmd ���� �Լ� 
            int ret = 0;
            try
            {
                if (this.cmd_tcpclient != null)
                {
                    if (this.cmd_tcpclient.Connected)
                    {
                        try
                        {
                            string Data = String.Empty;
                            for (int i = 0; i < bt.Length; i++)
                            {
                                string value = Convert.ToString(bt[i], 16);
                                if (value.Length == 1) value = "0" + value;
                                Data += value + " ";
                            }
                            if (Data.Substring(12, 2) != "14")
                                LFC.Log("[ Commo ] [����] " + Data);
                            if (_Data.Enable_Log == true)
                            {
                                _Event.Log_SendMessage_Write("[ Commo ] [����] " + Data);
                            }
                            this.cmd_sendStm.Write(bt, 0, size);
                            this.cmd_sendStm.Flush();
                            ret = 1;
                        }
                        catch (Exception ex)
                        {
                            Util.UErrorMessage(ex, 0, 0);
                            ret = -3;
                        }
                    }
                    else
                    {
                        ret = -2;
                    }
                }
                else
                {
                    ret = -1;
                }
            }
            catch (Exception ex)
            {
                ret = -1;
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret;
        }

        void Cmd_ReceiveThread()
        {//cmd listen thread 

            byte[] ReadBuffer = new byte[1024];
            int offset = 0;

            while (this.cmd_rcv_th_state == 1)
            {
                try
                {
                    if (this.cmd_tcpclient.Connected)
                    {
                        // cyim 2013.7.19 �ӵ������۾�
                        //for (int i = 0; i < 1024; i++)
                        //{
                        //    ReadBuffer[i] = 0x00;
                        //}
                        Array.Clear(ReadBuffer, 0, 1024);

                        offset = 0;

                        if (this.cmd_recvStm.CanRead)
                        {
                            offset = this.cmd_recvStm.Read(ReadBuffer, 0, ReadBuffer.Length);
                            //Debug.WriteLine("Receive Read : " + offset.ToString());
                            if (offset > 0)
                            {
                                //Debug.WriteLine(ToHex(ReadBuffer, offset));
                                string Data = String.Empty;
                                for (int i = 0; i < offset; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                                {
                                    string value = Convert.ToString(ReadBuffer[i], 16);
                                    if (value.Length == 1) value = "0" + value;
                                    Data += value + " ";
                                }
                                if (Data.Substring(12, 2) != "80" && Data.Substring(12, 2) != "94")
                                    LFC.Log("[ Commo ] [����] " + Data);
                                if (_Data.Enable_Log == true)
                                {
                                    _Event.Log_SendMessage_Write("[ Commo ] [����] " + Data);
                                    System.Diagnostics.Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + " ���� " + Data + "\r\n");
                                }
                                CMDReceiveMSGProc(ReadBuffer, offset);
                            }
                            else
                            {
                                if (cmd_recvStm.DataAvailable)
                                {
                                    //Debug.WriteLine("cmd_recvStm.DataAvailable");
                                }
                                else
                                {
                                    //Debug.WriteLine("Error");
                                    this.cmd_rcv_th_state = 0;
                                    this.cmdConnected = false;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            //Debug.WriteLine("Error");
                            this.cmd_rcv_th_state = 0;
                            this.cmdConnected = false;
                            break;
                        }
                        this.cmd_recvStm.Flush();
                    }
                    else
                    {
                        // don't connected
                        //Debug.WriteLine("Error");
                        this.cmd_rcv_th_state = 0;
                        this.cmdConnected = false;
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Util.UErrorMessage(ex, 0, 0);
                    //Debug.WriteLine(e.ToString());

                    //Debug.WriteLine("Error");
                    this.cmd_rcv_th_state = 0;
                    this.cmdConnected = false;
                    break;
                }
            }
            this.cmd_rcv_th_state = 0;
        }

        //void Cmd_ReceiveThread()
        //{
        //    try
        //    {

        //        byte[] ReadBuffer = new byte[1024];
        //        int offset = 0;

        //        while (this.cmd_rcv_th_state == 1)
        //        {
        //            if (this.cmd_tcpclient.Connected)
        //            {
        //                //Debug.WriteLine("Receive Connected");
        //                for (int i = 0; i < 1024; i++)
        //                {
        //                    ReadBuffer[i] = 0x00;
        //                }
        //                offset = 0;

        //                if (this.cmd_recvStm.CanRead)
        //                {
        //                    //Debug.WriteLine("Receive CanRead");
        //                    offset = this.cmd_recvStm.Read(ReadBuffer, 0, ReadBuffer.Length);
        //                    //Debug.WriteLine("Receive Read");
        //                    if (offset > 0)
        //                    {
        //                        Debug.WriteLine(ToHex(ReadBuffer, offset));

        //                        CMDReceiveMSGProc(ReadBuffer, offset);
        //                    }
        //                    else
        //                    {
        //                        //������ �׾���..
        //                        this.cmd_rcv_th_state = 0;
        //                        Stop_Con_cmd();
        //                        break;
        //                    }
        //                }
        //                //������ ����� ���ѷ��� ����..
        //                //if (!this.cmd_recvStm.DataAvailable) this.cmd_rcv_th_state = 0;
        //                this.cmd_recvStm.Flush();
        //            }
        //            else
        //            {
        //                // don't connected
        //                break;
        //            }
        //        }
        //        this.cmd_rcv_th_state = 0;
        //    }
        //    catch (Exception ex)
        //    {
        //       MessageBox.Show(string.Format("[{0}]\r\n{1}",ex.Message,ex.Source),Application.ProductName);
        //    }
        //}

        void CMDReceiveMSGProc(byte[] ReadBuffer, int size)
        {
            // cmd message processing function

            // cyim 2013.7.19 �ӵ������۾�
            //init buffer
            //for (int i = 0; i < 2048; i++)
            //{
            //    CMD_RcvBuffer[i] = 0x00;
            //}
            Array.Clear(CMD_RcvBuffer, 0, 2048);

            CMD_RcvBufferPos = 0;

            for (int i = 0; i < size; i++)
            {
                //copy buffer
                CMD_RcvBuffer[CMD_RcvBufferPos + i] = ReadBuffer[i];
            }
            CMD_RcvBufferPos += size;

            int datasize = CMD_RcvBuffer[3];
            if (datasize == 0)
            {
                datasize = (CMD_RcvBuffer[5] & 0xff | (CMD_RcvBuffer[6] << 8) & 0xff00) & 0xffff;
            }
            //CMDResponceFunc(datasize);

            byte[] cmdbuffer = new byte[datasize + 1];
            Array.Copy(CMD_RcvBuffer, 0, cmdbuffer, 0, datasize + 1);


            //for (int i = 0; i < rcvSize + 1; i++)
            //{//copy data
            //    cmdbuffer[i] = rcvBuff[i];
            //}
            for (int i = 0; i < 2048; i++)
            {//rcv buffer compress
                if (i < CMD_RcvBufferPos)
                {
                    CMD_RcvBuffer[i] = CMD_RcvBuffer[i + datasize + 1];
                }
                else
                {
                    CMD_RcvBuffer[i] = 0x00;
                }
                CMD_RcvBufferPos -= datasize + 1;
            }
            //����ó�� �̺�Ʈ
            CMDRcvProcess(cmdbuffer, datasize);
        }

        public void Event_Send(byte[] bt, int size)
        {  //2010.3.17_moon //don't using
            try
            {
                if (this.event_tcpclient != null)
                {
                    if (this.event_tcpclient.Connected)
                    {
                        this.event_sendStm.Write(bt, 0, size);
                        this.event_sendStm.Flush();
                    }
                }
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
        }

        //void Event_ReceiveThread()
        //{
        //    byte[] ReadBuffer = new byte[1024];
        //    int offset = 0;

        //    while (this.event_rcv_th_state == 1)
        //    {
        //        if (this.event_tcpclient.Connected)
        //        {
        //            //              Debug.WriteLine("Event_ReceiveThread");
        //            try
        //            {
        //                if (this.event_recvStm.CanRead)
        //                {
        //                    for (int i = 0; i < 1024; i++)
        //                    {
        //                        ReadBuffer[i] = 0x00;
        //                    }
        //                    offset = this.event_recvStm.Read(ReadBuffer, 0, ReadBuffer.Length);

        //                    if (offset > 0)
        //                    {
        //                        string str;
        //                        str = ToHex(ReadBuffer, offset);
        //                        Debug.WriteLine("Event_ReceiveThread size : " + offset.ToString() + "//data : " + str);
        //                        //                        Debug.WriteLine(string.Format("0x{0:x2} ", ReadBuffer[offset-1]));

        //                        EVENTReceiveMSGFunc(ReadBuffer, offset);
        //                    }
        //                    else
        //                    {
        //                        //������ �׾���..
        //                        this.event_rcv_th_state = 0;
        //                        Stop_Con_event();
        //                        break;
        //                    }

        //                }
        //                this.event_recvStm.Flush();
        //                // call main func -> case by case
        //            }
        //            catch (Exception e)
        //            {
        //                //error
        //                Debug.WriteLine(e.Message);
        //            }
        //        }
        //        else
        //        {
        //            break;
        //        }
        //    }
        //    this.event_rcv_th_state = 0;
        //}

        void Event_ReceiveThread()
        {// event listen thread 

            byte[] ReadBuffer = new byte[3072];//2048
            int offset = 0;

            while (this.event_rcv_th_state == 1)
            {
                if (this.event_tcpclient.Connected)
                {
                    //              //Debug.WriteLine("Event_ReceiveThread");
                    try
                    {
                        if (this.event_recvStm.CanRead)
                        {
                            // cyim 2013.7.19 �ӵ������۾�
                            //for (int i = 0; i < 3072; i++)
                            //{
                            //    ReadBuffer[i] = 0x00;
                            //}
                            Array.Clear(ReadBuffer, 0, 3072);//2048

                            offset = this.event_recvStm.Read(ReadBuffer, 0, ReadBuffer.Length);

                            if (offset > 0)
                            {
                                string str;
                                str = ToHex(ReadBuffer, offset);
                                //Debug.WriteLine("Event_ReceiveThread size : " + offset.ToString() + "//data : " + str);3072
                                //                        //Debug.WriteLine(string.Format("0x{0:x2} ", ReadBuffer[offset-1]));
                                //Util.LogBineryWrite(ReadBuffer, offset);    //���󿡼� ������ ��Ŷ�� ���Ͽ� �����Ѵ�.. --�ӽ�
                                EVENTReceiveMSGFunc(ReadBuffer, offset);

                                // LCH 2018.02.27 : �̺�Ʈ �α�
                                /*
                                if (_Data.Enable_Log == true)
                                {
                                    string Data = String.Empty;
                                    for (int i = 0; i < offset; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                                    {
                                        string value = Convert.ToString(ReadBuffer[i], 16);
                                        if (value.Length == 1) value = "0" + value;
                                        Data += value + " ";
                                    }
                                    _Event.Log_SendMessage_Write("[ Event ] [����] " + Data);
                                    LFC.Log("[ Event ] [����] " + Data);
                                    //System.Diagnostics.Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + " ���� " + Data + "\r\n");
                                }
                                else
                                {
                                    string Data = String.Empty;
                                    for (int i = 0; i < offset; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                                    {
                                        string value = Convert.ToString(ReadBuffer[i], 16);
                                        if (value.Length == 1) value = "0" + value;
                                        Data += value + " ";
                                    }
                                    LFC.Log("[ Event ] [����] " + Data);
                                }*/
                            }
                            else
                            {
                                if (event_recvStm.DataAvailable)
                                {
                                    //Debug.WriteLine("cmd_recvStm.DataAvailable");
                                }
                                else
                                {
                                    //Debug.WriteLine("Error");
                                    this.event_rcv_th_state = 0;
                                    this.eventConnected = false;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            //Debug.WriteLine("Error");
                            this.cmd_rcv_th_state = 0;
                            this.cmdConnected = false;
                            break;
                        }
                        this.event_recvStm.Flush();
                        // call main func -> case by case
                    }
                    catch (Exception ex)
                    {
                        Util.UErrorMessage(ex, 0, 0);
                        //Debug.WriteLine(e.Message);
                        //Debug.WriteLine("Error");
                        this.cmd_rcv_th_state = 0;
                        this.cmdConnected = false;
                        break;
                    }
                }
                else
                {
                    //Debug.WriteLine("Error");
                    this.cmd_rcv_th_state = 0;
                    this.cmdConnected = false;
                    break;
                }
            }
            this.event_rcv_th_state = 0;
        }

        byte[] EVENT_RcvBuffer = new byte[6144];
        int EVENT_RcvBufferPos = 0;

        void EVENTReceiveMSGFunc(byte[] ReadBuffer, int size)
        {
            // event data processing functin 
            //Util.LogWrite(string.Format("EVENTReceiveMSGFunc() ReadBuffer:{0},size:{1}", Util.ToHex(ReadBuffer), size));

            if ((EVENT_RcvBufferPos < 0) && (EVENT_RcvBufferPos > 3072))
            {
                // cyim 2013.7.19 ���� �ʰ� ���â
                //Util.LogWrite(string.Format("���ۻ����� �ʰ�!! ���� EVENT_RcvBufferPos:{0}", EVENT_RcvBufferPos));

                // cyim 2015.8.4 ���Ź��� ���� static Ŭ���� ����  : ���ʿ��� ��ƾ ����
                //mdi.Event.SocketBufferError_Inform_Write(string.Format("���ۻ����� �ʰ�!! ���� EVENT_RcvBufferPos:{0}", EVENT_RcvBufferPos));

                // cyim 2013.7.19 �ӵ������۾�
                //init buffer
                //for (int i = 0; i < 3072; i++)
                //{                
                //    EVENT_RcvBuffer[i] = 0x00;
                //}
                Array.Clear(EVENT_RcvBuffer, 0, 3072);

                EVENT_RcvBufferPos = 0;
            }

            for (int i = 0; i < size; i++)
            {
                //copy buffer
                EVENT_RcvBuffer[EVENT_RcvBufferPos + i] = ReadBuffer[i];
            }
            EVENT_RcvBufferPos += size;

            while (EVENT_RcvBufferPos > 7)
            {
                // data minimum size 
                if (EVENT_RcvBuffer[0] == 0x02)
                {
                    // stx
                    if (EVENT_RcvBuffer[3] == 0x00)
                    {
                        //extend size
                        int extendsize = (EVENT_RcvBuffer[5] & 0xff | (EVENT_RcvBuffer[6] << 8) & 0xff00) & 0xffff;
                        //Util.UDebugMessage("EVENTReceiveMSGFunc: extend size : " + extendsize.ToString(),0,0);
                        if (extendsize + 1 > EVENT_RcvBufferPos)
                        {
                            //short , next
                            //Util.UDebugMessage("EVENTReceiveMSGFunc: short , next ",0,0);
                            break;
                        }
                        else
                        {
                            //processing

                            //ó���� ��Ŷ��ŭ ������..
                            byte[] cmdbuffer = new byte[extendsize + 1];
                            Array.Copy(EVENT_RcvBuffer, cmdbuffer, extendsize + 1);

                            EVENTRcvProcess(cmdbuffer, extendsize); //��Ŷó��
                            //�α� ó�� cmdbuffer, extendsiz
                            if (_Data.Enable_Log == true)
                            {
                                string Data = String.Empty;
                                for (int i = 0; i < extendsize; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                                {
                                    string value = Convert.ToString(cmdbuffer[i], 16);
                                    if (value.Length == 1) value = "0" + value;
                                    Data += value + " ";
                                }
                                _Event.Log_SendMessage_Write("[ Event ] [����] " + Data);
                                LFC.Log("[ Event ] [����] " + Data);
                            }
                            else
                            {
                                string Data = String.Empty;
                                for (int i = 0; i < extendsize; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                                {
                                    string value = Convert.ToString(cmdbuffer[i], 16);
                                    if (value.Length == 1) value = "0" + value;
                                    Data += value + " ";
                                }
                                LFC.Log("[ Event ] [����] " + Data);
                            }

                            //ó���� ��Ŷ�� �����Ѵ�.
                            Array.Copy(EVENT_RcvBuffer, extendsize + 1, EVENT_RcvBuffer, 0, EVENT_RcvBuffer.Length - extendsize - 1);
                            EVENT_RcvBufferPos -= extendsize + 1;

                            //Debug.WriteLine("EVENTReceiveMSGFunc: processing ");
                            //EVENTRcvProcess(EVENT_RcvBuffer,extendsize);
                            //Util.LogWrite(string.Format("EVENT_RcvBuffer:{0},Length:{1}", Util.ToHex(EVENT_RcvBuffer), extendsize));
                            //EVENT_RcvBufferPos -= extendsize + 1;
                        }
                    }
                    else if (EVENT_RcvBuffer[3] + 1 > EVENT_RcvBufferPos)
                    {
                        //short , next
                        //Util.UDebugMessage("EVENTReceiveMSGFunc: short , next",0,0);
                        break;
                    }
                    else
                    {
                        int extendsize = EVENT_RcvBuffer[3];

                        //ó���� ��Ŷ��ŭ ������..
                        byte[] cmdbuffer = new byte[extendsize + 1];
                        Array.Copy(EVENT_RcvBuffer, cmdbuffer, extendsize + 1);

                        EVENTRcvProcess(cmdbuffer, extendsize); //��Ŷó��
                        //�α� ó�� cmdbuffer, extendsiz
                        if (_Data.Enable_Log == true)
                        {
                            string Data = String.Empty;
                            for (int i = 0; i < extendsize; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                            {
                                string value = Convert.ToString(cmdbuffer[i], 16);
                                if (value.Length == 1) value = "0" + value;
                                Data += value + " ";
                            }
                            _Event.Log_SendMessage_Write("[ Event ] [����] " + Data);
                            LFC.Log("[ Event ] [����] " + Data);
                        }
                        else
                        {
                            string Data = String.Empty;
                            for (int i = 0; i < extendsize; i++) // for (int i = 0; i < ReadBuffer.Length; i++)
                            {
                                string value = Convert.ToString(cmdbuffer[i], 16);
                                if (value.Length == 1) value = "0" + value;
                                Data += value + " ";
                            }
                            LFC.Log("[ Event ] [����] " + Data);
                        }

                        //ó���� ��Ŷ�� �����Ѵ�.
                        Array.Copy(EVENT_RcvBuffer, extendsize + 1, EVENT_RcvBuffer, 0, EVENT_RcvBuffer.Length - extendsize - 1);
                        EVENT_RcvBufferPos -= extendsize + 1;

                        ////processing
                        //Debug.WriteLine("EVENTReceiveMSGFunc: size : " + EVENT_RcvBuffer[3].ToString());
                        //Debug.WriteLine("EVENTReceiveMSGFunc: processing" + EVENT_RcvBuffer[3].ToString());
                        //int extendsize = EVENT_RcvBuffer[3];
                        //EVENTRcvProcess(EVENT_RcvBuffer, extendsize);
                        //Util.LogWrite(string.Format("EVENT_RcvBuffer:{0},Length:{1}", Util.ToHex(EVENT_RcvBuffer), extendsize));
                        //EVENT_RcvBufferPos -= extendsize + 1;
                    }
                }
                else
                {
                    // header error
                    Util.LogWrite(string.Format("EVENTReceiveMSGFunc header error {0}", Util.ToHex(EVENT_RcvBuffer)));    //���� �α׿� ����
                    //Debug.WriteLine("EVENTReceiveMSGFunc: header error : " + EVENT_RcvBuffer[0].ToString());
                    for (int i = 0; i < 3072; i++)
                    {
                        //init buffer
                        //EVENT_RcvBuffer[i] = 0x00;
                        //���� ����� ��..
                        if (EVENT_RcvBuffer[i] == 0x02)
                        {
                            //����� ã����ġ �������� ������.
                            int extendsize = i - 1;

                            //ó���� ��Ŷ�� �����Ѵ�.
                            Array.Copy(EVENT_RcvBuffer, extendsize + 1, EVENT_RcvBuffer, 0, EVENT_RcvBuffer.Length - extendsize - 1);
                            EVENT_RcvBufferPos -= extendsize + 1;
                            break;
                        }
                    }

                    //for (int i = 0; i < 3072; i++)
                    //{//init buffer
                    //    EVENT_RcvBuffer[i] = 0x00;
                    //}
                    //EVENT_RcvBufferPos = 0;
                    break;
                }
            }
        }

        string ToHex(byte[] bin_data)
        {// byte to hex function 
            string result = "";
            try
            {
                foreach (byte ch in bin_data)
                {
                    result += string.Format("{0:x2} ", ch);
                }
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return result;
        }

        string ToHex(byte[] bin_data, int len)
        {// multiple byte to hex 
            string result = "";
            try
            {
                for (int i = 0; i < len; i++)
                {
                    result += string.Format("{0:x2} ", bin_data[i]);
                }
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return result;
        }
    }
}