using Aurora;
using Aurora.Api;
using Aurora.Util;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;
using System.Windows.Threading;
using static AuroraPLC.PLCBase;

namespace AuroraPLC.Views
{
    public class WordValue : NotifyPropertyChangedBase
    {
        private string _word;
        public string Word {
            get { return _word; }
            set {
                if (_word != value) {
                    _word = value;
                    NotifyPropertyChanged("Word");
                }
            }
        }
        public string Address { get; set; }
        private string _description;
        public string Description {
            get => _description;
            set {
                if (_description != value) {
                    _description = value;
                    NotifyPropertyChanged("Description");
                }
            }
        }
        public int addrOffset { get; set; }

        private bool _use = true;
        public bool Use {
            get { return _use; }
            set { SetProperty(ref _use, value); }
        } // DataGridRow의 IsEnable과 Binding되는 property
    }

    public class UCPLCWordViewModel : NotifyPropertyChangedBase
    {
        Logger Log = new Logger("PLC Mon. Word");

        // 32bit 옵션을 지원하기 위해서 (아스키 포함) string 으로 변경...
        private string _WORD_DATA;
        public string WORD_DATA { get => _WORD_DATA; set => SetProperty(ref _WORD_DATA, value); }

        public ICommand CMD_VisibleChanged { get; }
        //public ICommand CMD_CalculateFlatness { get; }
        public ICommand CMD_ChangeValue { get; }

        public List<WordValue> DigitalInputs { get; set; } = new List<WordValue>();
        public List<WordValue> DigitalOutputs { get; set; } = new List<WordValue>();
        public List<string> DataViewTypeList { get; set; }
            = new List<string>() { PLCBase.DisplayFormat.Bit16, PLCBase.DisplayFormat.Bit32Odd, PLCBase.DisplayFormat.Bit32Even, PLCBase.DisplayFormat.ASCII };
        public string DataViewTypeInput { get; set; }
        public string DataViewTypeOutput { get; set; }
        private bool _isCheckedDataViewHexInput = false;
        public bool IsCheckedDataViewHexInput { get => _isCheckedDataViewHexInput; set => SetProperty(ref _isCheckedDataViewHexInput, value); }

        private bool _isCheckedDataViewHexOutput = false;
        public bool IsCheckedDataViewHexOutput { get => _isCheckedDataViewHexOutput; set => SetProperty(ref _isCheckedDataViewHexOutput, value); }


        //------------------------
        // For Sim Only
        public bool IsThisInput { get; private set; }

        // Input/Ouput 공용 Item
        private WordValue selectedWordItem;
        public WordValue SelectedWordItem {
            get {
                return selectedWordItem;
            }
            set {
                selectedWordItem = value;
            }
        }

        private WordValue selectedInputItem;
        public WordValue SelectedInputItem {
            get {
                return selectedInputItem;
            }
            set {
                // 반대편 datagrid 의 선택을 해제한다.
                selectedOutputItem = null;
                NotifyPropertyChanged("SelectedOutputItem");
                //=====================================
                selectedInputItem = value;
                IsThisInput = true;
                selectedWordItem = value;   // For Sim mode : Input bit change
                NotifyPropertyChanged("SelectedWordAddress");
            }
        }
        //====================================
        private WordValue selectedOutputItem;
        public WordValue SelectedOutputItem {
            get {
                return selectedOutputItem;
            }
            set {
                // 반대편 datagrid 의 선택을 해제한다.
                selectedInputItem = null;
                NotifyPropertyChanged("SelectedInputItem");
                //=====================================
                selectedOutputItem = value;
                IsThisInput = false;
                selectedWordItem = value;   // For Sim mode (Input 쪽과 일관성을 위해서)
                NotifyPropertyChanged("SelectedWordAddress");
            }
        }

        public string SelectedWordAddress {
            get {
                return SelectedWordItem?.Address;
            }
        }

        private int selectedInputIndex = 0;
        public int SelectedInputIndex {
            get => selectedInputIndex;
            set {
                if (selectedInputIndex != value) {
                    selectedInputIndex = value;
                    DigitalInputs = InputMaps[value];
                    NotifyPropertyChanged("DigitalInputs");
                }
            }
        }

        private int selectedOutputIndex = 0;
        public int SelectedOutputIndex {
            get => selectedOutputIndex;
            set {
                if (selectedOutputIndex != value) {
                    selectedOutputIndex = value;
                    DigitalOutputs = OutputMaps[value];
                    NotifyPropertyChanged("DigitalOutputs");
                }
            }
        }

        private bool isActivated = false;
        public bool IsActivated {
            get => isActivated;
            set {
                if (isActivated != value) {
                    isActivated = value;
                    NotifyPropertyChanged("IsActivated");
                }
            }
        }

        private bool _changeButtonEnable;
        public bool ChangeButtonEnable {
            get => _changeButtonEnable;
            set => SetProperty(ref _changeButtonEnable, value);
        }

        public Dictionary<int, List<WordValue>> InputMaps = new Dictionary<int, List<WordValue>>();
        public Dictionary<int, List<WordValue>> OutputMaps = new Dictionary<int, List<WordValue>>();

        private bool isVisible;
        private eLangType curLanguage;

        private IDeviceEntry DeviceManager;
        private readonly PLCBase _plc;
        private ePLCDevice _deviceName;

        private readonly DispatcherTimer MonitorTimer;

        public UCPLCWordViewModel(IAuroraEnvironment aurora, string deviceId, ePLCNetType plcNetType, ePLCDevice device = ePLCDevice.W)
        {
            DeviceManager = aurora.DeviceManager;

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);
            CMD_ChangeValue = new DelegateCommand(ChangeWordValue);
            _deviceName = device;

            _plc = DeviceManager[deviceId] as PLCBase;

            List<WordValue> input = new List<WordValue>();
            List<WordValue> output = new List<WordValue>();
            InputMaps.Add(0, input);
            OutputMaps.Add(0, output);

            isVisible = false;
            curLanguage = PLCBase.Language;

            // Config 로부터 Input/Output 메모리 맵 파싱 및 할당
            LoadWordFromConfig();

            Observable.Merge(aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_ACTIVATED),
                aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_DEACTIVATED))
                .Select(msg => msg.Param as string)
                .Where(x => x == deviceId).ObserveOnDispatcher()
                .Subscribe(x => OnDeviceActiveChanged());

            // Log In/Out 시점 파악을 위한 이벤트 관측하기 : For Write 권한 제어
            aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_PERMISSION_CHANGED)
                .Subscribe(x => UpdateWriteState());

            // 언어 변경 이벤트
            aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_LANGUAGE_CHANGED)
                .Select(msg => msg.Param.ToString().Split('-').First().ToLower())//.Where(lan => lan != _currLanguage)
                .ObserveOnDispatcher().Subscribe(lan => UpdateLanguage(lan));

            DigitalInputs = InputMaps[0];
            DigitalOutputs = OutputMaps[0];

            // display 포맷 옵션 초기화
            DataViewTypeInput = PLCBase.DisplayFormat.Bit16;
            DataViewTypeOutput = PLCBase.DisplayFormat.Bit16;

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

        private void UpdateLanguage(string lan)
        {
            // 예외 조건
            // 언어가 변경되었는데, 모니터링 뷰 화면이 아닌 경우,
            if (isVisible == false) {

            } else {    // 모니터링 화면인 경우,
                // 타이머 중단
                MonitorTimer.Stop();

                switch (lan) {
                    case "en": {
                            UpdateViewLanguage(eLangType.English);

                            break;
                        }

                    case "ko": {
                            UpdateViewLanguage(eLangType.Korean);

                            break;
                        }
                }

                // 타이머 재시작
                MonitorTimer.Start();
            }
        }

        private void UpdateViewLanguage(eLangType langType)
        {
            int i = 0;
            switch (langType) {
                case eLangType.English: {
                        foreach (var ioValue in DigitalInputs) {
                            if (_deviceName == ePLCDevice.D) {
                                ioValue.Description = _plc.DWordInputs[i].description.Comment_EN;
                            } else {
                                ioValue.Description = _plc.WordInputs[i].description.Comment_EN;
                            }
                            ++i;
                        }

                        i = 0;
                        foreach (var ioValue in DigitalOutputs) {
                            if (_deviceName == ePLCDevice.D) {
                                ioValue.Description = _plc.DWordOutputs[i].description.Comment_EN;
                            } else {
                                ioValue.Description = _plc.WordOutputs[i].description.Comment_EN;
                            }
                            ++i;
                        }

                        break;
                    }

                case eLangType.Korean: {
                        foreach (var ioValue in DigitalInputs) {
                            if (_deviceName == ePLCDevice.D) {
                                ioValue.Description = _plc.DWordInputs[i].description.Comment_KR;
                            } else {
                                ioValue.Description = _plc.WordInputs[i].description.Comment_KR;
                            }
                            ++i;
                        }

                        i = 0;
                        foreach (var ioValue in DigitalOutputs) {
                            if (_deviceName == ePLCDevice.D) {
                                ioValue.Description = _plc.DWordOutputs[i].description.Comment_KR;
                            } else {
                                ioValue.Description = _plc.WordOutputs[i].description.Comment_KR;
                            }
                            ++i;
                        }

                        break;
                    }
            }

            // 뷰모델 및 PLC 언어도 업데이트
            PLCBase.Language = langType;
            curLanguage = langType;
        }

        private void UpdateWriteState() // 화면 내에서 사용자 권한이 변경되었을 경우
        {
            /*
            var curPermissionLevel = ApplicationExt.PermissionLevel;
            if (curPermissionLevel > (ushort)Aurora.Api.PermissionLevel.LEVEL3 || IsActivated == false) {   // 권한 부족
                ChangeButtonEnable = false;
            } else {
                if (PLC.IsViewEnabled) {
                    ChangeButtonEnable = true;
                } else {
                    ChangeButtonEnable = false;
                }
            }
            */
            // Auto 모드인경우, Write 불가
            if (PLCStatic.IsViewEnabled) {
                ChangeButtonEnable = true;
            } else {
                ChangeButtonEnable = false;
            }
        }

        private void VisibleChanged(object obj) // 화면 전환 시 동작하는 곳
        {
            UpdateWriteState();

            isVisible = (bool)obj;
            if (isVisible) {
                // 뷰모델이 가지고 있는 언어와 현재 Aurora 언어가 다르면, 설명 언어를 변경함
                if (curLanguage != _plc.GetLangTypeFrom(ApplicationExt.CurLang)) {
                    UpdateViewLanguage(PLCBase.Language);
                }

                MonitorTimer.Start();
            } else {
                MonitorTimer.Stop();
            }
        }

        private void OnDeviceActiveChanged()
        {
            IsActivated = _plc.IsActivated;
            if (IsActivated == false) {
                ChangeButtonEnable = false;
            }
        }

        private void LoadWordFromConfig()
        {
            if (_deviceName == ePLCDevice.D) {
                // Word Input (D)
                List<WordValue> InPutlist = InputMaps[0];

                for (int i = 0; i < _plc.DWordInputs.Count; i++) {
                    var inputW = _plc.DWordInputs[i];
                    var address = inputW.Item1;

                    string desc = null;
                    switch (curLanguage) {
                        case eLangType.English:
                            desc = inputW.Item2.Comment_EN;
                            break;
                        case eLangType.Korean:
                            desc = inputW.Item2.Comment_KR;
                            break;
                    }

                    desc?.Trim();

                    string strAddress = "D" + address.ToString();

                    var ioValue = new WordValue() {
                        Address = strAddress,
                        Description = desc,
                        //hexAddress = strAddress.Substring(1, strAddress.Length - 1),
                        //"주소 - 시작주소"가 아니라, 인덱스를 사용
                        addrOffset = i,
                        Use = true
                    };

                    InPutlist.Add(ioValue);
                }

                // Word Output
                List<WordValue> OutPutlist = OutputMaps[0];

                for (int i = 0; i < _plc.DWordOutputs.Count; i++) {
                    var outputW = _plc.DWordOutputs[i];
                    var address = outputW.Item1;

                    string desc = null;
                    switch (curLanguage) {
                        case eLangType.English:
                            desc = outputW.Item2.Comment_EN;
                            break;
                        case eLangType.Korean:
                            desc = outputW.Item2.Comment_KR;
                            break;
                    }

                    desc?.Trim();

                    string strAddress = "D" + address.ToString();

                    var ioValue = new WordValue() {
                        Address = strAddress,
                        Description = desc,
                        //"주소 - 시작주소"가 아니라, 인덱스를 사용
                        addrOffset = i,
                        Use = true
                    };

                    OutPutlist.Add(ioValue);
                }
            } else {
                // Word Input
                var startAddress = _plc.WordInputs.Count != 0 ? _plc.WordInputs.OrderBy(x => x.address).First().address : 0;
                foreach (var inputW in _plc.WordInputs) {
                    // 주소와 설명문으로 파싱
                    //var (address, desc) = inputW;
                    var address = inputW.Item1;
                    string desc = null;
                    switch (curLanguage) {
                        case eLangType.English: {
                                desc = inputW.Item2.Comment_EN;

                                break;
                            }
                        case eLangType.Korean: {
                                desc = inputW.Item2.Comment_KR;

                                break;
                            }
                    }

                    //desc.Trim();
                    desc?.Trim();

                    List<WordValue> InPutlist = InputMaps[0];

                    string strAddress = "W" + address.ToString("X4");  // convert to Hex string (4 자리)
                    var ioValue = new WordValue() {
                        Address = strAddress,
                        Description = desc,
                        //hexAddress = strAddress.Substring(1, strAddress.Length - 1),
                        addrOffset = address - startAddress,
                        Use = true // 특정 Value를 사용하지 않을 경우 false로 설정 (DataGridRow의 IsEnabled와 연동)
                    };

                    // 저장
                    //InPutlist.AddRange(TempInPutlist);
                    InPutlist.Add(ioValue);
                }

                // Word Output
                startAddress = _plc.WordOutputs.Count != 0 ? _plc.WordOutputs.OrderBy(x => x.address).First().address : 0;
                foreach (var outputW in _plc.WordOutputs) {
                    // 주소와 설명문으로 파싱
                    //var (address, desc) = outputW;
                    var address = outputW.Item1;
                    string desc = null;
                    switch (curLanguage) {
                        case eLangType.English: {
                                desc = outputW.Item2.Comment_EN;

                                break;
                            }
                        case eLangType.Korean: {
                                desc = outputW.Item2.Comment_KR;

                                break;
                            }
                    }

                    desc?.Trim();

                    List<WordValue> OutPutlist = OutputMaps[0];

                    string strAddress = "W" + address.ToString("X4");  // convert to Hex string (4자리)

                    var ioValue = new WordValue() {
                        Address = strAddress,
                        Description = desc,
                        //hexAddress = strAddress.Substring(1, strAddress.Length - 1),
                        addrOffset = address - startAddress,
                        Use = true // 특정 Value를 사용하지 않을 경우 false로 설정 (DataGridRow의 IsEnabled와 연동)
                    };

                    // 저장
                    //InPutlist.AddRange(TempInPutlist);
                    OutPutlist.Add(ioValue);
                }
            }

        }

        private void OnMonitoring(object sender, EventArgs e)
        {
            if (!_plc.IsActivated) {
                return;
            }

            // 뷰 상태 모니터링 : write 버튼 비활성화
            UpdateWriteState();


            DataViewTypePLCMonitoring(DigitalInputs, true);
            DataViewTypePLCMonitoring(DigitalOutputs, false);
        }

        private void DataViewTypePLCMonitoring(List<WordValue> IOList, bool IsInput)
        {
            int index = 0;
            if (IOList.Count <= 0) {
                return;
            }

            // 기존: memAddress + Count 로 한 번에 블럭 read
            // var memAddress = IOList[0].addrOffset;
            // (int err, short[] data) res;
            // if (_deviceName == ePLCDevice.D) { ... ReadWordBlock ... }

            // 변경: 내부 버퍼에서 주소별로 한 칸씩 읽기
            var data = new short[IOList.Count];

            foreach (var io in IOList) {
                (int err, short data) resOne;
                if (_deviceName == ePLCDevice.D) {
                    resOne = _plc.ReadWord(io.addrOffset, ePLCDevice.D, isInput: IsInput);
                } else {
                    resOne = _plc.ReadWord(io.addrOffset, isInput: IsInput);
                }

                data[index++] = resOne.data;
            }

            index = 0;

            string dataViewType = IsInput ? DataViewTypeInput : DataViewTypeOutput;
            bool hexType = IsInput ? IsCheckedDataViewHexInput : IsCheckedDataViewHexOutput;

            string tempStrComp = "";
            try {
                foreach (var ioValue in IOList) {
                    switch (dataViewType) {
                        case PLCBase.DisplayFormat.Bit32Odd:
                            if (index % 2 == 1) {
                                ioValue.Use = true;
                                // 메모리 주소가 홀수 - 짝수로 쌍을 이룸
                                // 마지막 주소가 버퍼 범위를 벗어나는지 검사 필요..
                                // 미츠비시 PLC 는 big endigan 임.  lower word -> upper word 순임
                                if (index + 1 < data.Length) {
                                    tempStrComp = _plc.Conv_ReadData(PLCBase.eDataType.Type_32Bit, data[index], data[index + 1], hexType);
                                } else {
                                    tempStrComp = _plc.Conv_ReadData(PLCBase.eDataType.Type_32Bit, data[index], 0, hexType);
                                }
                                if (tempStrComp != ioValue.Word) {
                                    ioValue.Word = tempStrComp;
                                }
                            } else {
                                ioValue.Word = "";
                                ioValue.Use = false;
                            }
                            break;
                        case PLCBase.DisplayFormat.Bit32Even:
                            if (index % 2 == 0) {
                                ioValue.Use = true;
                                if (index + 1 < data.Length) {
                                    tempStrComp = _plc.Conv_ReadData(PLCBase.eDataType.Type_32Bit, data[index], data[index + 1], hexType);
                                } else {
                                    tempStrComp = _plc.Conv_ReadData(PLCBase.eDataType.Type_32Bit, data[index], 0, hexType);
                                }
                                if (tempStrComp != ioValue.Word) {
                                    ioValue.Word = tempStrComp;
                                }
                            } else {
                                ioValue.Use = false;
                                ioValue.Word = "";
                            }
                            break;

                        case PLCBase.DisplayFormat.ASCII:
                            ioValue.Use = true;
                            tempStrComp = _plc.Conv_ReadData(PLCBase.eDataType.Type_Ascii, data[index], 0, false,
                                true);
                            if (tempStrComp != ioValue.Word) {
                                ioValue.Word = tempStrComp;
                            }
                            break;
                        default:    // 16 bit
                            ioValue.Use = true;
                            ioValue.Word = hexType ? data[index].ToString("X4") : data[index].ToString();
                            break;
                    }
                    index++;
                }
            } catch (Exception ex) {
                Log.E($"Exception: {ex.Message}");
            }
        }

        private void ChangeWordValue(object obj)
        {
            if (!_plc.IsActivated) {
                return;
            }

            /*
            // 사용자 권한에 따라서, 아예 해당 버튼을 disable 하는 방식으로 권한 검사를 처리함
            // 방어용으로 이중 처리 (삭제 가능함)
            var curPermissionLevel = ApplicationExt.PermissionLevel;
            if (curPermissionLevel > (ushort)Aurora.Api.PermissionLevel.LEVEL3) {   // 권한 부족
                return;
            }

            // PLC 가 Auto 모드이면 Write 불가
            if (PLC.CheckProcessAutoMode()) {
                return;
            }
            */

            // 비고. 리얼 모드에서는 입력의 수정 불가: 리얼모드 & Input 은 무시한다...
            if (_plc.IsSimul == false && IsThisInput) {
                return;
            }

            // 빈문자열도 체크해야 할까??
            if (SelectedWordItem == null || WORD_DATA == null) {
                return;
            }

            PLCBase.eSendResult eRet = PLCBase.eSendResult.OK;
            int iSendSize = 1;
            //string strSendData = WORD_DATA;
            string[] strSendData = { WORD_DATA };

            // display 옵션에 따른 구현
            // 32bit odd, even 은 무조건 현재 선택된 주소가 low word 이고, 다음 주소가 high word 임.
            string dataViewType = IsThisInput ? DataViewTypeInput : DataViewTypeOutput;
            bool hexType = IsThisInput ? IsCheckedDataViewHexInput : IsCheckedDataViewHexOutput;
            switch (dataViewType) {
                case PLCBase.DisplayFormat.Bit16: {
                        if (_plc.IsSimul && IsThisInput) {   // 시뮬 & 입력부분
                            eRet = _plc.WriteWordBlock(PLCBase.eDataType.Type_16Bit, SelectedWordItem.addrOffset, iSendSize, in strSendData, _deviceName, hexType, isOutput: false);
                        } else {
                            eRet = _plc.WriteWordBlock(PLCBase.eDataType.Type_16Bit, SelectedWordItem.addrOffset, iSendSize, in strSendData, _deviceName, hexType);
                        }
                        break;
                    }
                case PLCBase.DisplayFormat.ASCII: {
                        // LUKAS: ABCDEFGH 를 입력할 경우, AB 가 1워드에 들어감, A 가 lower word임

                        // 예외1. 빈 문자열이면, 어떻게 하지..??  일단은 선택된 메모리 주소만 널문자 주도록 하자 !!!
                        if (strSendData[0].Length == 0) {  // 빈 문자열이라면,
                            strSendData[0] = "\0\0";
                        }
                        // write 할 워드 수는 문자열 길이의 절반... 1워드에 2개의 문자가 가능함
                        // 1 문자 --> 1 워드
                        // 2 문자 --> 1 워드
                        // 3 문자 --> 2 워드
                        // 4 문자 --> 2 워드
                        // ==> 2로 나눈 후, 올림처리
                        //iSendSize = (int)Math.Round(strSendData.Length / 2.0 + 0.5);  // 오사오입 방식 반올림: 0.5 단위일 경우, 앞자리를 짝수로 만든다: 0.5 => 0, 1.5 = 2
                        iSendSize = (int)Math.Ceiling(strSendData[0].Length / 2.0);

                        // 예외 2. 보낼 워드 사이즈가 정의된 메모리 범위를 벗어날 경우, write 불가하고, 에러 로그를 남긴다.
                        if (_plc.IsSimul && IsThisInput) {   // 시뮬 & 입력부분
                            if (DigitalInputs.Last().addrOffset < SelectedWordItem.addrOffset + iSendSize - 1) {
                                Log.E("ASCII write is impossible: Out of Word Input address range");
                                break;
                            }
                            eRet = _plc.WriteWordBlockForAscii(SelectedWordItem.addrOffset, iSendSize, ref strSendData, _deviceName, isOutput: false);
                        } else {
                            if (DigitalOutputs.Last().addrOffset < SelectedWordItem.addrOffset + iSendSize - 1) {
                                Log.E("ASCII write is impossible: Out of Word Output address range");
                                break;
                            }
                            eRet = _plc.WriteWordBlockForAscii(SelectedWordItem.addrOffset, iSendSize, ref strSendData, _deviceName);
                        }
                        break;
                    }
                default:    // 32 bit = 2 워드
                    // 검토사항: Odd/Even 과 총 메모리 주소의 홀짝 여부에 따라서, 마지막 주소가 선택될 수 있는데, 이 경우, 메모리 주소를 벗어날 수 있다.
                    // 선택된 주소가 메모리의 마지막 주소인 경우는 write 불가 (정의된 메모리 범위를 벗어나서 write 를 하는 행위이므로..)
                    if (_plc.IsSimul && IsThisInput) {   // 시뮬 & 입력부분
                        if (DigitalInputs.Last().addrOffset == SelectedWordItem.addrOffset) {
                            Log.E("32bit write is impossible: upper word is out of address range");
                            break;
                        }
                        eRet = _plc.WriteWordBlock(PLCBase.eDataType.Type_32Bit, SelectedWordItem.addrOffset, iSendSize, in strSendData, _deviceName, hexType, isOutput: false);
                    } else {    // 리얼모드
                        // 만약 선택된 주소가 마지막 주소라면, write 불가
                        if (DigitalOutputs.Last().addrOffset == SelectedWordItem.addrOffset) {
                            Log.E("32bit write is impossible: upper word is out of address range");
                            break;
                        }
                        eRet = _plc.WriteWordBlock(PLCBase.eDataType.Type_32Bit, SelectedWordItem.addrOffset, iSendSize, in strSendData, _deviceName, hexType);
                    }
                    break;
            }

            switch (eRet) {
                case PLCBase.eSendResult.Error_NotActivated:
                    Log.E("PLC is not activated");
                    break;
                case PLCBase.eSendResult.Error_NotConnect:
                    Log.E("PLC is not connected");
                    break;
                case PLCBase.eSendResult.Error_Communication:
                    Log.E("PLC Comm Error");
                    break;
                case PLCBase.eSendResult.Error_DataIsNumeric:
                    Log.E("Only numeric input is allowed");
                    break;
                case PLCBase.eSendResult.Error_DataRange:
                    Log.E("Out of input range");
                    break;
                case PLCBase.eSendResult.Error_DataLength:
                    Log.E("Out of input max. length");
                    break;
                case PLCBase.eSendResult.Error_DataType:
                    Log.E("Input data type is invalid");
                    break;
                case PLCBase.eSendResult.Error_Exception:
                    Log.E("Exception is occured");
                    break;
            }
        }
    }
}