using AuroraDeviceCommon.Utils;
using Hermes;
using System;
using System.Collections.Generic;

namespace AuroraPLC
{
    public struct stPLCUpdatorInfo
    {
        // 데이터 업데이트 스레드 동작 여부 확인용
        public ulong NumberOfUpdateCycle { get; set; }

        public ulong NumberOfReadBit { get; set; }
        public ulong NumberOfReadWord { get; set; }
        public ulong NumberOfWriteBit { get; set; }
        public ulong NumberOfWriteWord { get; set; }

        // 현재 어느 지점인지 확인용
        public ushort UpdatePointer { get; set; }

        public ulong NumberOfRBFail { get; set; }
        public ulong NumberOfWBFail { get; set; }
        public ulong NumberOfRWFail { get; set; }
        public ulong NumberOfWWFail { get; set; }

        public ulong NumberOfReconnection { get; set; }

        public stPLCUpdatorInfo(int init = 0)
        {
            NumberOfUpdateCycle = NumberOfReadBit = NumberOfReadWord = NumberOfWriteBit = NumberOfWriteWord = NumberOfRBFail
                = NumberOfWBFail = NumberOfRWFail = NumberOfWWFail = NumberOfReconnection = (ulong)init;
            UpdatePointer = (ushort)init;
        }
    }

    public abstract partial class PLCBase
    {
        const int RWStart = 0;      // RW 시작
        const int OnReadWI = 1;     // Read Word Input 중
        const int AfterReadWI = 2;  // Read Word Input 완료
        const int OnReadBI = 3;     // Read Bit Input 중
        const int AfterReadBI = 4;  // Read Bit Input 완료
        const int OnWriteWO = 5;    // Write Word Output 중
        const int AfterWriteWO = 6; // Write Word Output 완료
        const int OnWriteBO = 7;    // Write Bit Output 중
        const int RWEnd = 8;        // RW 완료

        //--------------------------------------------
        // 수정 검토...
        public enum ePLCDevice
        {
            M = 4,
            D = 13,
            B = 23,        // LB : Link relay
            W = 24,        // LW : Link register
            ZR = 220
        }

        private const char DevB = 'B';
        private const char DevW = 'W';
        private const char DevM = 'M';
        private const char DevD = 'D';
        //======================================================
        private const int _wordSize = 16;   // bit

        // 뮤텍스 : 현 구조상, Bit 와 Word 2개로만 구분함
        private readonly object _lockBitInOut = new object();
        private readonly object _lockWordInOut = new object();

        // 송수신 워드 size
        public int BitInputWordSize { get; private set; }
        public int BitOutputWordSize { get; private set; }
        public int MBitInputWordSize { get; private set; }
        public int MBitOutputWordSize { get; private set; }
        public int WordInputWordSize { get; private set; }
        public int WordOutputWordSize { get; private set; }
        public int DWordInputWordSize { get; private set; }
        public int DWordOutputWordSize { get; private set; }
        // 기타: Bit 개수
        public int BitInputSize { get; private set; }
        public int BitOutputSize { get; private set; }
        public int MBitInputSize { get; private set; }
        public int MBitOutputSize { get; private set; }

        //public double DataUpdateRateMS { get; private set; }
        public double DataUpdateRateUS { get; private set; }

        #region PLC 관련 메모리 버퍼 및 초기화
        // PLC Bit/Word 메모리 관련
        internal class IOBlock<T>
        {
            internal int BaseAddress;   // 시작 주소값
            internal int Count;         // 버퍼 범위
            internal T[] Data;          // 실제 data
            internal string DevAddr;    // 미츠비시 PLC 의 Device type (ex. LB (23), LW (24), etc)

            internal void MakeDevAddr(char dev)
            {
                if (dev == 'D' || dev == 'M') {
                    DevAddr = string.Format("{0}{1:D}", dev, BaseAddress);
                } else {
                    DevAddr = string.Format("{0}{1:X}", dev, BaseAddress);
                }
            }
        }

        private IOBlock<bool> BitInputBlock;  // Input: PC <-- PLC
        private IOBlock<bool> BitOutputBlock;  // Output: PC --> PLC
        private IOBlock<bool> MBitInputBlock;
        private IOBlock<bool> MBitOutputBlock;
        private IOBlock<short> WordInputBlock;
        private IOBlock<short> WordOutputBlock;
        private IOBlock<short> DWordInputBlock;
        private IOBlock<short> DWordOutputBlock;

        private void InitBitBlock(IList<(int address, AddrCommentList descript)> config, IOBlock<bool> bitBlock, ePLCDevice device = ePLCDevice.B)
        {
            // 메모리 주소를 config에 반영시 반드시 정렬되어 있다고 가정, 따라서 정렬로직은 불필요...
            if (config.Count != 0) {
                var startAddress = config[0].address;

                // 시작주소는 16 배수여야 한다. 메모리 총합도 16 배수여야 함
                bitBlock.BaseAddress = startAddress;
                bitBlock.Count = config.Count;
            } else {
                bitBlock.Count = 0;
            }
            // 버퍼 할당
            bitBlock.Data = new bool[bitBlock.Count];
            // 시작주소를 'B' + "HexAddr" 로 저장
            if(device == ePLCDevice.M) {
                bitBlock.MakeDevAddr(DevM);
            } else {
                bitBlock.MakeDevAddr(DevB);
            }
        }

        private void InitWordBlock(IList<(int address, AddrCommentList descript)> config, IOBlock<short> wordBlock, ePLCDevice device = ePLCDevice.W)
        {
            if (config.Count != 0) {
                //var startAddress = config.OrderBy(x => x.address).First().address;
                var startAddress = config[0].address;

                wordBlock.BaseAddress = startAddress;
                wordBlock.Count = config.Count;
            } else {
                wordBlock.Count = 0;
            }

            wordBlock.Data = new short[wordBlock.Count];

            if(device == ePLCDevice.D) {
                wordBlock.MakeDevAddr(DevD);
            } else {
                wordBlock.MakeDevAddr(DevW);
            }
        }
        #endregion

        #region 유틸리티
        private static bool InRange<T>(IOBlock<T> block, int addrOffset, int numOfData = 1)
        {
            // 예외 검사
            if (numOfData <= 0) {
                return false;
            }
            // addrOffset: [0, block.Count)
            return addrOffset >= 0 && addrOffset + numOfData - 1 < block.Count;
        }

        private void BitArrayToWordArray(bool[] bitArray, short[] wordArray)
        {
            int wordIndex = 0;
            for (int j = 0; j < wordArray.Length; j++) {
                for (int k = 0; k < _wordSize; k++) {
                    wordArray[j] |= (short)((bitArray[wordIndex + k] ? 1 : 0) << k);
                }
                wordIndex += _wordSize;
            }
        }

        /// <summary>
        /// 입력: wordArray 를 bitArray 에 저장한다.
        /// </summary>
        /// <param name="wordArray"></param>
        /// <param name="bitArray"></param>
        private void WordArrayToBitArray(short[] wordArray, bool[] bitArray)
        {
            int bitIndex = 0;
            for (int j = 0; j < wordArray.Length; j++) {
                for (int k = 0; k < _wordSize; k++) {
                    // [0~15] : 워드 data (16 bit)를 각각 0번 bit 로 이동시켜서 bit 검사 및 저장하는 로직
                    bitArray[bitIndex + k] = ((wordArray[j] >> k) & 0x01) == 1;
                }
                bitIndex += _wordSize;
            }
        }
        #endregion


        #region 모니터링 뷰에서만 사용
        static public class DisplayFormat
        {
            public const string Bit16 = "16Bit";
            public const string Bit32Odd = "32BitOdd";
            public const string Bit32Even = "32BitEven";
            public const string ASCII = "ASCII";
        }
        public enum eDataType
        {
            Type_16Bit = 0,
            Type_32Bit = 1,
            Type_Ascii = 2,
        }
        public enum eSendResult
        {
            OK = E1.OK,
            Error_NotActivated = E2.NOT_READY,
            Error_NotConnect = E2.NOT_CONNECTED,
            Error_Communication = E1.NETWORK,
            Error_DataIsNumeric = -11111,
            Error_DataRange,
            Error_DataLength,
            Error_DataType,
            Error_Exception = -12345,
        }

        public string Conv_ReadData(eDataType eType, short lowerWord, short upperWord = 0, bool IsHex = false, bool bViewDot = false)
        {
            // LUKAS_CHECK: 여기에 try-catch 가 필요한 경우가 있을까...?? (제거 검토 목적)
            string strRtn = "";
            try {
                switch (eType) {
                    case eDataType.Type_16Bit:
                        strRtn = string.Format("{0:X4}", lowerWord);
                        if (!IsHex)
                            strRtn = Utils.Hex2short(strRtn).ToString();
                        break;
                    case eDataType.Type_32Bit:
                        strRtn = string.Format("{0:X4}", upperWord) + string.Format("{0:X4}", lowerWord);
                        if (!IsHex)
                            strRtn = Utils.Hex2Int(strRtn).ToString();
                        break;
                    case eDataType.Type_Ascii:  // 워드를 char 문자로
                        // 1 워드는 최대 2개의 문자로 구성됨
                        char[] charTemp = new char[2];
                        string[] strData = new string[2];

                        // 워드값을 16진수 문자열로 표기
                        // ex. A (65): "0041"
                        string strTemp = string.Format("{0:X4}", lowerWord);
                        // 첫 2개의 문자열에 해당하는 정수를 char 문자로 변환
                        // note: "00" 은 널문자 char 로 변환됨
                        charTemp[0] = Convert.ToChar(Utils.Hex2Int(Utils.StrLeft(strTemp, 2)));
                        // strTemp 의 2번째부터 남은 문자열에 해당하는 정수를 char 문자로 변환
                        charTemp[1] = Convert.ToChar(Utils.Hex2Int(Utils.StrRight(strTemp, 2)));

                        // bViewDot: 기호, 숫자, 알파벳 범위를 벗어난 경우, . 으로 할거냐, 빈문자열로 할거냐의 의미
                        if (bViewDot) {
                            // 아스키 기호, 숫자, 알파벳 범위를 벗어나면 dot 으로 대체
                            // 32 = space (빈칸)
                            // lower part
                            if ((charTemp[0] > 126) || (charTemp[0] < 32)) strData[0] = "."; // Convert.ToChar(46);
                            else strData[0] = charTemp[0].ToString();
                            // upper part
                            if ((charTemp[1] > 126) || (charTemp[1] < 32)) strData[1] = "."; // Convert.ToChar(46);
                            else strData[1] = charTemp[1].ToString();
                        } else {
                            if ((charTemp[0] > 126) || (charTemp[0] < 32)) strData[0] = ""; // Convert.ToChar(46);
                            else strData[0] = charTemp[0].ToString();

                            if ((charTemp[1] > 126) || (charTemp[1] < 32)) strData[1] = ""; // Convert.ToChar(46);
                            else strData[1] = charTemp[1].ToString();
                        }
                        strRtn = strData[1] + strData[0];

                        break;
                }
                return strRtn;
            } catch (Exception ex) {
                Log.E($"Exception : {ex.Message}");
                return "";
            }
        }

        #endregion

        #region PLC 통신 메서드 (내부용)
        private (int err, bool data) ReadBit(IOBlock<bool> ioblock, int addrOffset)
        {
            if (!InRange(ioblock, addrOffset)) {
                return (E2.INVALID_ARGUMENT, false);
            }
            return (E1.OK, ioblock.Data[addrOffset]);
        }

        private (int error, short data) ReadWord(IOBlock<short> ioblock, int addrOffset)
        {
            if (!InRange(ioblock, addrOffset)) {
                return (E2.INVALID_ARGUMENT, 0);
            }
            return (E1.OK, ioblock.Data[addrOffset]);
        }

        private (int err, short[] array) ReadWordBlock(IOBlock<short> ioblock, int addrOffset, int wordSize)
        {
            if (!InRange(ioblock, addrOffset, wordSize)) {
                return (E2.INVALID_ARGUMENT, null);
            }

            // 1 워드 = 2 byte
            // 1 short 는 2 byte
            var wordArray = new short[wordSize];
            Array.Copy(ioblock.Data, addrOffset, wordArray, 0, wordSize);

            return (E1.OK, wordArray);
        }

        private int WriteBit(IOBlock<bool> ioblock, int addrOffset, bool onOff)
        {
            if (!InRange(ioblock, addrOffset)) {
                return E2.INVALID_ARGUMENT;
            }

            lock (_lockBitInOut) { // 뮤텍스가 필요함
                ioblock.Data[addrOffset] = onOff;
            }

            return E1.OK;
        }

        private int WriteWord(IOBlock<short> ioblock, int addrOffset, short shData)
        {
            if (!InRange(ioblock, addrOffset)) {
                return E2.INVALID_ARGUMENT;
            }

            lock (_lockWordInOut) {
                ioblock.Data[addrOffset] = shData;
            }

            return E1.OK;
        }

        private int WriteWordBlock(IOBlock<short> ioBlock, int addrOffset, int wdSize, short[] shArray)
        {
            if (shArray == null || shArray.Length == 0) {
                return E1.ARGUMENT;
            }

            if (!InRange(ioBlock, addrOffset, wdSize)) {
                return E2.INVALID_ARGUMENT;
            }

            lock (_lockWordInOut) {
                Array.Copy(shArray, 0, ioBlock.Data, addrOffset, wdSize);
            }

            return E1.OK;
        }

        private (int err, bool[] array) ReadBitBlock(IOBlock<bool> ioblock, int addrOffset, int bitSize)
        {
            if (!InRange(ioblock, addrOffset, bitSize)) {
                return (E2.INVALID_ARGUMENT, null);
            }

            var bitArray = new bool[bitSize];
            Array.Copy(ioblock.Data, addrOffset, bitArray, 0, bitSize);

            return (E1.OK, bitArray);
        }

        private int WriteBitBlock(IOBlock<bool> ioBlock, int addrOffset, int bitSize, bool[] bArray)
        {
            if (bArray == null || bArray.Length == 0) {
                return E1.ARGUMENT;
            }

            if (!InRange(ioBlock, addrOffset, bitSize)) {
                return E2.INVALID_ARGUMENT;
            }

            lock (_lockBitInOut) {
                Array.Copy(bArray, 0, ioBlock.Data, addrOffset, bitSize);
            }

            return E1.OK;
        }
        #endregion

        #region 물리적 네트워킹 관련 (PLC 제조사 API 사용)
        private int ReadBitInputFromPLC()
        {
            PLCUpdatorInfo.UpdatePointer = OnReadBI;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (BitInputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real mode
                short[] readDeviceBlock = new short[BitInputWordSize];
                short readSize = (short)BitInputWordSize;

                // 기본값: 실패를 가정
                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(BitInputWordSize * 2);   // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.B, (short)BitInputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"B{BitInputBlock.BaseAddress:X}";
                    // Using word size
                    _res = PLCNet.ReceiveFromPLC(in BitInputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    // 통신 실패하면 바로 통신 연결 플래그 해제
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRBFail;
                    Log.E($"fail to receive Bit data from PLC: address: B{BitInputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                // PLC로부터 읽어온 B 메모리 전체 블록을 버퍼에 업데이트
                // 여기에 뮤텍스를 걸어야 하는데,
                // Read 부분이므로, 여기가 유일한 업데이트 코드임
                // 시뮬에서 업데이트를 하긴 하나, 시뮬은 API 통신이 없다.
                // => 뮤텍스 불필요
                WordArrayToBitArray(readDeviceBlock, BitInputBlock.Data);
            }
            // Simul mode 인 경우는...
            // 시뮬레이션의 경우, PLC 가 없으므로, 읽어올 게 없다.
            // LUKAS_CHECK : 시뮬 한정 가상 PLC 메모리 버퍼를 만들어야 할까??

            return E1.OK;
        }
        private int ReadMBitInputFromPLC()
        {
            PLCUpdatorInfo.UpdatePointer = 3;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (MBitInputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real mode
                short[] readDeviceBlock = new short[MBitInputWordSize];
                short readSize = (short)MBitInputWordSize;

                // 기본값: 실패를 가정
                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(MBitInputWordSize * 2);   // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.M, (short)MBitInputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"B{BitInputBlock.BaseAddress:X}";
                    // Using word size
                    _res = PLCNet.ReceiveFromPLC(in MBitInputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    // 통신 실패하면 바로 통신 연결 플래그 해제
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRBFail;
                    Log.E($"fail to receive Bit data from PLC: address: M{MBitInputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                // PLC로부터 읽어온 B 메모리 전체 블록을 버퍼에 업데이트
                // 여기에 뮤텍스를 걸어야 하는데,
                // Read 부분이므로, 여기가 유일한 업데이트 코드임
                // 시뮬에서 업데이트를 하긴 하나, 시뮬은 API 통신이 없다.
                // => 뮤텍스 불필요
                WordArrayToBitArray(readDeviceBlock, MBitInputBlock.Data);
            }
            // Simul mode 인 경우는...
            // 시뮬레이션의 경우, PLC 가 없으므로, 읽어올 게 없다.
            // LUKAS_CHECK : 시뮬 한정 가상 PLC 메모리 버퍼를 만들어야 할까??

            return E1.OK;
        }
        private int ReadWordInputFromPLC()
        {
            PLCUpdatorInfo.UpdatePointer = OnReadWI;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (WordInputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real mode
                short[] readDeviceBlock = new short[WordInputWordSize];
                short readSize = (short)WordInputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(WordInputWordSize * 2);  // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.W, (short)WordInputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"W{WordInputBlock.BaseAddress:X}";
                    _res = PLCNet.ReceiveFromPLC(in WordInputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRWFail;
                    Log.E($"fail to receive Word data from PLC: address: W{WordInputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }
                // 여기가 유일한 업데이트임 : 뮤텍스 불필요
                readDeviceBlock.CopyTo(WordInputBlock.Data, 0);
            }

            return E1.OK;
        }
        private int ReadDWordInputFromPLC()
        {
            PLCUpdatorInfo.UpdatePointer = 1;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (DWordInputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real mode
                short[] readDeviceBlock = new short[DWordInputWordSize];
                short readSize = (short)DWordInputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(WordInputWordSize * 2);  // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.D, (short)DWordInputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    _res = PLCNet.ReceiveFromPLC(in DWordInputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRWFail;
                    Log.E($"fail to receive Word data from PLC: address: D{DWordInputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }
                // 여기가 유일한 업데이트임 : 뮤텍스 불필요
                readDeviceBlock.CopyTo(DWordInputBlock.Data, 0);
            }

            return E1.OK;
        }
        private int WriteBitOutputToPLC()
        {
            PLCUpdatorInfo.UpdatePointer = OnWriteBO;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (BitOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real 모드
                short[] writeDeviceBlock = new short[BitOutputWordSize];
                short writtenSize = (short)BitOutputWordSize;
                BitArrayToWordArray(BitOutputBlock.Data, writeDeviceBlock);

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    writtenSize = (short)(BitOutputWordSize * 2);   // Using byte size
                    _res = PLCNet.SendToPLC((int)ePLCDevice.B, (short)BitOutputBlock.BaseAddress, ref writtenSize, ref writeDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"B{BitOutputBlock.BaseAddress:X}";
                    // Using word size
                    _res = PLCNet.SendToPLC(in BitOutputBlock.DevAddr, writtenSize, ref writeDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfWBFail;
                    Log.E($"Fail to Write Bit data to PLC: address: B{BitOutputBlock.BaseAddress:X4}, size: {writtenSize}");

                    return E1.NETWORK;
                }
            }

            return E1.OK;
        }
        private int WriteMBitOutputToPLC()
        {
            PLCUpdatorInfo.UpdatePointer = 7;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (MBitOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {    // Real 모드
                short[] writeDeviceBlock = new short[MBitOutputWordSize];
                short writtenSize = (short)MBitOutputWordSize;
                BitArrayToWordArray(MBitOutputBlock.Data, writeDeviceBlock);

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    writtenSize = (short)(MBitOutputWordSize * 2);   // Using byte size
                    _res = PLCNet.SendToPLC((int)ePLCDevice.M, (short)MBitOutputBlock.BaseAddress, ref writtenSize, ref writeDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    _res = PLCNet.SendToPLC(in MBitOutputBlock.DevAddr, writtenSize, ref writeDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfWBFail;
                    Log.E($"Fail to Write Bit data to PLC: address: M{MBitOutputBlock.BaseAddress:X4}, size: {writtenSize}");

                    return E1.NETWORK;
                }
            }

            return E1.OK;
        }
        private int WriteWordOutputToPLC()
        {
            PLCUpdatorInfo.UpdatePointer = OnWriteWO;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (WordOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {
                // LUKAS_CHECK : Bit 는 데이터 타입이 달랐지만,
                // 어차피 전체 batch 기준인데, Word 장치의 경우, 굳이 지역 배열을 만들어서 복사할 필요가 있을까??
                // 나중에 나중에 테스트해보자~~~~~!!!
                short[] writeDeviceBlock = new short[WordOutputWordSize];
                short writtenSize = (short)WordOutputWordSize;
                Array.Copy(WordOutputBlock.Data, 0, writeDeviceBlock, 0, WordOutputWordSize);

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    writtenSize = (short)(WordOutputWordSize * 2);  // Using byte size
                    _res = PLCNet.SendToPLC((int)ePLCDevice.W, (short)WordOutputBlock.BaseAddress, ref writtenSize, ref writeDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"W{WordOutputBlock.BaseAddress:X}";
                    _res = PLCNet.SendToPLC(in WordOutputBlock.DevAddr, writtenSize, ref writeDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfWWFail;
                    Log.E($"fail to write Word data to PLC: address: W{WordOutputBlock.BaseAddress:X4}, size: {writtenSize}");

                    return E1.NETWORK;
                }
            }

            return E1.OK;
        }
        private int WriteDWordOutputToPLC()
        {
            PLCUpdatorInfo.UpdatePointer = 5;
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (DWordOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) {
                // LUKAS_CHECK : Bit 는 데이터 타입이 달랐지만,
                // 어차피 전체 batch 기준인데, Word 장치의 경우, 굳이 지역 배열을 만들어서 복사할 필요가 있을까??
                // 나중에 나중에 테스트해보자~~~~~!!!
                short[] writeDeviceBlock = new short[DWordOutputWordSize];
                short writtenSize = (short)DWordOutputWordSize;
                Array.Copy(DWordOutputBlock.Data, 0, writeDeviceBlock, 0, DWordOutputWordSize);

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    writtenSize = (short)(DWordOutputWordSize * 2);  // Using byte size
                    _res = PLCNet.SendToPLC((int)ePLCDevice.D, (short)DWordOutputBlock.BaseAddress, ref writtenSize, ref writeDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"W{WordOutputBlock.BaseAddress:X}";
                    _res = PLCNet.SendToPLC(in DWordOutputBlock.DevAddr, writtenSize, ref writeDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfWWFail;
                    Log.E($"fail to write Word data to PLC: address: D{DWordOutputBlock.BaseAddress:X4}, size: {writtenSize}");

                    return E1.NETWORK;
                }
            }
            return E1.OK;
        }
        private int ReadBitOutputFromPLC()  // 최초 동기화: PLC Bit 출력 => PC Bit 출력
        {
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (BitOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) { // Real mode
                short[] readDeviceBlock = new short[BitOutputWordSize];
                short readSize = (short)BitOutputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(BitOutputWordSize * 2);  // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.B, (short)BitOutputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"B{BitOutputBlock.BaseAddress:X}";
                    _res = PLCNet.ReceiveFromPLC(in BitOutputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    // 통신 실패하면 바로 통신 연결 플래그 해제
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRBFail;
                    Log.E($"fail to receive Bit Output data from PLC: address: B{BitOutputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                lock (_lockBitInOut) {
                    WordArrayToBitArray(readDeviceBlock, BitOutputBlock.Data);
                }
            }
            // 시뮬은 읽을게 없음..

            return E1.OK;
        }
        private int ReadMBitOutputFromPLC()  // 최초 동기화: PLC Bit 출력 => PC Bit 출력
        {
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (MBitOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) { // Real mode
                short[] readDeviceBlock = new short[MBitOutputWordSize];
                short readSize = (short)MBitOutputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(MBitOutputWordSize * 2);  // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.M, (short)MBitOutputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"B{BitOutputBlock.BaseAddress:X}";
                    _res = PLCNet.ReceiveFromPLC(in MBitOutputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    // 통신 실패하면 바로 통신 연결 플래그 해제
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRBFail;
                    Log.E($"fail to receive Bit Output data from PLC: address: M{MBitOutputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                lock (_lockBitInOut) {
                    WordArrayToBitArray(readDeviceBlock, MBitOutputBlock.Data);
                }
            }
            // 시뮬은 읽을게 없음..

            return E1.OK;
        }
        private int ReadWordOutputFromPLC() // 최초 동기화: PLC Word 출력 => PC Word 출력
        {
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (WordOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) { // Real mode
                short[] readDeviceBlock = new short[WordOutputWordSize];
                short readSize = (short)WordOutputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(WordOutputWordSize * 2);     // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.W, (short)WordOutputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"W{WordOutputBlock.BaseAddress:X}";
                    _res = PLCNet.ReceiveFromPLC(in WordOutputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRWFail;
                    Log.E($"fail to receive Word Output data from PLC: address: W{WordOutputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                lock (_lockWordInOut) {
                    Array.Copy(readDeviceBlock, WordOutputBlock.Data, WordOutputWordSize);
                }
            }
            // 시뮬모드는 nothing

            return E1.OK;
        }
        private int ReadDWordOutputFromPLC() // 최초 동기화: PLC Word 출력 => PC Word 출력
        {
            if (!IsConnected) {
                return E2.NOT_CONNECTED;
            }
            if (DWordOutputWordSize <= 0) {    // No data
                return E1.OK;
            }

            if (IsSimul == false) { // Real mode
                short[] readDeviceBlock = new short[DWordOutputWordSize];
                short readSize = (short)DWordOutputWordSize;

                var _res = false;
                if (NetworkType == ePLCNetType.MelsecNet) {
                    readSize = (short)(DWordOutputWordSize * 2);     // Using byte size
                    _res = PLCNet.ReceiveFromPLC((int)ePLCDevice.D, (short)DWordOutputBlock.BaseAddress, ref readSize, ref readDeviceBlock[0]);
                } else if (NetworkType == ePLCNetType.MXComponent) {
                    //string devLabel = $"W{WordOutputBlock.BaseAddress:X}";
                    _res = PLCNet.ReceiveFromPLC(in DWordOutputBlock.DevAddr, readSize, ref readDeviceBlock);
                }
                if (_res != true) {
                    IsConnected = false;
                    ++PLCUpdatorInfo.NumberOfRWFail;
                    Log.E($"fail to receive Word Output data from PLC: address: D{DWordOutputBlock.BaseAddress:X4}, size: {readSize}");

                    return E1.NETWORK;
                }

                lock (_lockWordInOut) {
                    Array.Copy(readDeviceBlock, DWordOutputBlock.Data, DWordOutputWordSize);
                }
            }
            // 시뮬모드는 nothing
            return E1.OK;
        }
        #endregion


        #region PLC Data processing
        private void DataUpdator()
        {
            // 비동기 PLC 데이터 update
            if (IsSimul == false) { // Real mode
                // Update
                // Note: 비동기 스레드의 동기화 체크 필요
                //       활성화, 비활성화 부분
                //       통신 연결/해제 부분


                // 업데이트 순서 (워드 입력 -> 비트 입력 -> 워드 출력 -> 비트 출력)

                // 0 : 시작
                PLCUpdatorInfo.UpdatePointer = RWStart;

                // --- Read
                // Receive (Word Input buffers) from PLC
                ReadWordInputFromPLC();
                ReadDWordInputFromPLC();
                // Read WordInput 완료
                PLCUpdatorInfo.UpdatePointer = AfterReadWI;   // WI 완료
                ++PLCUpdatorInfo.NumberOfReadWord;

                // Receive (Bit Input buffers) from PLC
                ReadBitInputFromPLC();
                ReadMBitInputFromPLC();
                // Read BitInput 완료
                PLCUpdatorInfo.UpdatePointer = AfterReadBI;   // BI 완료
                ++PLCUpdatorInfo.NumberOfReadBit;

                // --- Send
                // Send (Word Output buffers) to PLC
                WriteWordOutputToPLC();
                WriteDWordOutputToPLC();
                // Write WordOutput 완료
                PLCUpdatorInfo.UpdatePointer = AfterWriteWO;   // WO 완료
                ++PLCUpdatorInfo.NumberOfWriteWord;

                // Send (Bit Output buffers) to PLC
                WriteBitOutputToPLC();
                WriteMBitOutputToPLC();
                // Write BitOutput 완료
                PLCUpdatorInfo.UpdatePointer = RWEnd;   // BO 완료
                ++PLCUpdatorInfo.NumberOfWriteBit;
            } else {    // simul mode
                PLCUpdatorInfo.UpdatePointer = RWStart;
                PLCUpdatorInfo.UpdatePointer = AfterReadWI;   // WI 완료
                ++PLCUpdatorInfo.NumberOfReadBit;
                PLCUpdatorInfo.UpdatePointer = AfterReadBI;   // BI 완료
                ++PLCUpdatorInfo.NumberOfReadWord;
                PLCUpdatorInfo.UpdatePointer = AfterWriteWO;   // WO 완료
                ++PLCUpdatorInfo.NumberOfWriteBit;
                PLCUpdatorInfo.UpdatePointer = RWEnd;   // BO 완료
                ++PLCUpdatorInfo.NumberOfWriteWord;
            }

            ++PLCUpdatorInfo.NumberOfUpdateCycle;
        }
        #endregion
    }
}