using System;
using System.IO.Ports;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace n5coredll
{

    [ClassInterface(ClassInterfaceType.AutoDual)]
    [Guid("92138541-8E7B-43FD-A4A4-748F28A934CD")]
    [ProgId("n5coredll.N5Core")]
    public class N5Core
    {
        private System.IO.Ports.SerialPort serialPort1;
        private int sendTime;
        private int mTotalRecvCount = 0;
        private Byte[] currReqByteArr;
        private string currResultJsonStr;
        private bool isSending = false;
        private int mRecvTimes;
        private byte[] mTotalRecvResult = new byte[10000];
        private int mRecvIndex = 0;

        private bool isReadyBack = false;
        private int timeOut = 1200000;
        private bool isGetACK = false;

        //for serial port config
        private string portName = null;
        private string baudRate = null;
        private string dataBits = null;
        private string stopBits = null;
        private string parity = null;

        private static String STATUS_NO_TXN = "13";
        private static String STATUS_SUCC = "00";
        private static String STATUS_PROCESSING = "03";
        private static String ERR_STATUS_FAIL = "10";

        private static String ERR_CODE_OPENCOM = "DLL_ERR_0001";
        private static String ERR_MSG_OPENCOM = "Open comport fail!";

        private static String ERR_CODE_ECHO = "DLL_ERR_0002";
        private static String ERR_MSG_ECHO = "Cannot connect terminal!";

        private static String ERR_CODE_TIMEOUT = "DLL_ERR_0003";
        private static String ERR_MSG_TIMEOUT = "Receive timeout!";

        private static String ERR_CODE_BUSY = "DLL_ERR_0004";
        private static String ERR_MSG_BUSY = "Last function has not returned yet!";

        private bool isProcessingSale = false;
        private static String ERR_CODE_PARAM = "DLL_ERR_0005";
        private static String ERR_MSG_PARAM = "Input params format error!";
        private Boolean ifBusy = false;
        private LogUtil logger;
        private static N5Core myInstance;

        public N5Core()
        {
            
        }

        public static N5Core getInstance()
        {
            if (myInstance == null)
                myInstance = new N5Core();
            return myInstance;
        }

        public int initN5Core(string portName, string baudRate, string dataBits, string stopBits, string parity, string timeOut, string logPath)
        {
            int returnResult = -1;
            logger = LogUtil.getInstance();
            logger.setLogPath(logPath);

            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [initN5Core] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [portName]: " + portName);
            logger.addRepeatLog("input param [baudRate]: " + baudRate);
            logger.addRepeatLog("input param [dataBits]: " + dataBits);
            logger.addRepeatLog("input param [stopBits]: " + stopBits);
            logger.addRepeatLog("input param [parity]: " + parity);
            logger.addRepeatLog("input param [timeOut]: " + timeOut);
            logger.addRepeatLog("input param [logPath]: " + logPath);
            if (portName != null && !portName.Equals(string.Empty))
                this.portName = portName;
            else
                this.portName = "COM1";

            if (baudRate != null && !baudRate.Equals(string.Empty))
                this.baudRate = baudRate;
            else
                this.baudRate = "9600";

            if (dataBits != null && !dataBits.Equals(string.Empty))
                this.dataBits = dataBits;
            else
                this.dataBits = "8";

            if (stopBits != null && !stopBits.Equals(string.Empty))
                this.stopBits = stopBits;
            else
                this.stopBits = "One";

            if (parity != null && !parity.Equals(string.Empty))
                this.parity = parity;
            else
                this.parity = "None";

            if (timeOut != null && !timeOut.Equals(string.Empty))
                try
                {
                    this.timeOut = int.Parse(timeOut);

                }
                catch {
                    this.timeOut = 120000;
                }

            else
                this.timeOut = 120000;
            bool result = openSerialPort();
            if (result)
            {
                String echoResult = sendLinkTestRequest();
                if (RequestResult.toReqResultFromJsonMsg(echoResult).Status == STATUS_SUCC)
                    returnResult = 0;
            }
            LogUtil.getInstance().addRepeatLog("[result]: " + returnResult);
            logger.addRepeatLog("<<<<<<<<<<<<<<<< End Event [initN5Core] <<<<<<<<<<<<<<<<");
            return returnResult;
        }

        private static string getTxnId()
        {
            StringBuilder txnIdSb = new StringBuilder();
            DateTime dt = DateTime.Now;
            txnIdSb.Append(dt.ToString("yyyyMMddHHmmssfff"));
            Console.WriteLine("txnIdSb = " + txnIdSb.ToString());
            int randomTime = 0;
            if (dt.Ticks.ToString().Length > 8)
            {
                Console.WriteLine("Ticks.Length > 8 = " + dt.Ticks.ToString());
                randomTime = int.Parse(dt.Ticks.ToString().Substring(0, 8));
            }
            else
            {
                randomTime = int.Parse(dt.Ticks.ToString());
            }

            if (randomTime > 0)
            {
                Random random = new Random();
                for (int i = 0; i < 15; i++)
                {
                    int thidRandom = random.Next(10);
                    txnIdSb.Append(thidRandom);
                }
                Console.WriteLine("txnIdSb.ToString = " + txnIdSb.ToString());
                return txnIdSb.ToString();
            }
            else
            {
                Console.WriteLine("randomTime is error = " + randomTime);
            }

            return "";
        }

        public string requestSale(string txnId, string txnAmt, string paymentType, string billType)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestSale] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnId]: " + txnId);
            logger.addRepeatLog("input param [txnAmt]: " + txnAmt);
            logger.addRepeatLog("input param [paymentType]: " + paymentType);
            logger.addRepeatLog("input param [billType]: " + billType);
            if (ifBusy)
                return RequestResult.createRespErrJson("requestSale","SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_BUSY,ERR_MSG_BUSY);
            ifBusy = true;
            if ((txnId == null || txnId.Equals(String.Empty))
                || (txnAmt == null || txnAmt.Equals(String.Empty))
                || (paymentType == null || paymentType.Equals(String.Empty))
                || (billType == null || billType.Equals(String.Empty))
                ) {
                Console.WriteLine("Error! Input empty");
                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }

            decimal dtxnAmt = decimal.Parse(txnAmt);
            if (dtxnAmt.CompareTo(decimal.Parse("0")) < 1 || dtxnAmt.CompareTo(decimal.Parse("99999999.99")) > 1)
            {
                Console.WriteLine("txnAmt must be from 0.00 to 99999999.99!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (txnId.Length > 15)
            {
                Console.WriteLine("txnId length must be 15");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt,ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (paymentType.Length != 3 || !paymentType.Equals("FPS"))
            {
                Console.WriteLine("paymentType length must be 3");               
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (billType.Length != 3)
            {
                Console.WriteLine("billType length must be 3");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt ,ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }

            if (openSerialPort())
            {
                isProcessingSale = true;

                String echoResult = sendInnerLinkTestRequest();
                if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
                {
                    Console.WriteLine("LinkTest failed!");
                    ifBusy = false;
                    isProcessingSale = false;
                    return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
                }
                Thread.Sleep(500);

                sendTime = 0;
                isSending = false;
                mRecvTimes = 0;
                isReadyBack = false;
                currReqByteArr = null;
                currResultJsonStr = null;
                isGetACK = false;
                string reqSaleStr = SaleResult.toJsonForSale(txnId, dtxnAmt, paymentType, billType);
                Console.WriteLine("reqSaleStr = " + reqSaleStr);
                if (reqSaleStr == null || "".Equals(reqSaleStr))
                {
                    Console.WriteLine("reqSaleStr is null. ");
                    closeSerialPort();
                    ifBusy = false;
                    isProcessingSale = false;
                    return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType,txnAmt,ERR_STATUS_FAIL,"","");
                }
                currReqByteArr = packReqMsg(reqSaleStr);
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    Console.WriteLine("currReqByteArr is null. ");
                    closeSerialPort();
                    ifBusy = false;
                    isProcessingSale = false;
                    return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, "", "");
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                Console.WriteLine("serialPort no open. ");
                closeSerialPort();
                ifBusy = false;
                isProcessingSale = false;
                return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL,ERR_CODE_OPENCOM,ERR_MSG_OPENCOM);
            }

            int sleepTime = timeOut / 1000;
            if (sleepTime > 210)
                sleepTime = 210;
            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            int inqCount = 0;
            DateTime lastInqTime = DateTime.Now;
            
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else if (!isProcessingSale)
                { 
                    closeSerialPort();
                    ifEnd = true;
                    String tmpResult = RequestResult.createRespProcessingJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, "F9994");
                    return tmpResult;
                }   
                else if (sp.TotalSeconds < 30)
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        //closeSerialPort();
                        String tmpJson = currResultJsonStr;
                        if (tmpJson != null && !"".Equals(tmpJson) && tmpJson.Contains("SALE_RESP"))
                        {
                            ifBusy = false;
                            ifEnd = true;
                            isProcessingSale = false;
                            SaleResult tmpSaleResult = SaleResult.toSaleResultFromJsonMsg(tmpJson);
                            LogUtil.getInstance().addRepeatLog("[result]: " + tmpJson);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSale] <<<<<<<<<<<<<<<<");
                            return tmpJson;
                        }
                    }
                }
                else
                {
                    //closeSerialPort();
                    TimeSpan txnInqSp = nowTime - lastInqTime;
                    if (inqCount == 0 || (inqCount > 0 && txnInqSp.TotalSeconds > 5))
                    {
                        string retrivReusltStr = requestInnerRetrieval(txnId);
                        if (retrivReusltStr != null && retrivReusltStr.Contains("ABORT_RESP"))
                        {
                            retrivReusltStr = requestInnerRetrieval(txnId);
                        }
                        inqCount++;
                        lastInqTime = DateTime.Now;
                        if (retrivReusltStr != null && !"".Equals(retrivReusltStr))
                        {
                            RetrievalResult retrievalResult = RetrievalResult.toRetrievalResultFromJsonMsg(retrivReusltStr);
                            if (retrievalResult.Status == STATUS_PROCESSING && (retrievalResult.RespCode != null && (retrievalResult.RespCode.Equals("F9994") || retrievalResult.RespCode.Equals("null"))))
                            {
                                ifBusy = false;
                                ifEnd = true;
                                isProcessingSale = false;
                                String tmpResult = RequestResult.createRespProcessingJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, "F9994");
                                return tmpResult;
                            }
                            else if (retrievalResult.Status == STATUS_SUCC || retrievalResult.Status == ERR_STATUS_FAIL)
                            {
                                retrivReusltStr = retrivReusltStr.Replace("\"STATUS\":\"00\"", "\"STATUS\":\"" + retrievalResult.Status + "\"");
                                ifBusy = false;
                                ifEnd = true;
                                isProcessingSale = false;
                                retrivReusltStr = retrivReusltStr.Replace("RETRIEVAL_RESP", "SALE_RESP");
                                LogUtil.getInstance().addRepeatLog("[result]: " + retrivReusltStr);
                                LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSale] <<<<<<<<<<<<<<<<");
                                return retrivReusltStr;
                            }
                            else if (retrievalResult.Status == STATUS_NO_TXN)
                            {
                                string saleResultStr = "{\"EVENT_NAME\":\"SALE_RESP\",\"STATUS\":\"10\",\"TXN_ID\":\"" + txnId + "\",\"TXN_AMT\":" + txnAmt + "}";

                                //String saleResultStr = "\"EVENT_NAME\":\"SALE_RESP\",\"STATUS\":\"10\"";
                               // retrivReusltStr = retrivReusltStr.Replace("RETRIEVAL_RESP", "SALE_RESP");
                                //retrivReusltStr = retrivReusltStr.Replace("\"STATUS\":\"13\"", "\"STATUS\":\"10\"");
                                ifBusy = false;
                                isProcessingSale = false;
                                ifEnd = true;
                                LogUtil.getInstance().addRepeatLog("[result]: " + saleResultStr);
                                LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSale] <<<<<<<<<<<<<<<<");
                                return saleResultStr;
                            }

                        }
                    }
                    isReadyBack = false;
                }
            }
          

            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            ifBusy = false;
            isProcessingSale = false;
            return RequestResult.createRespErrJson("requestSale", "SALE_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL,ERR_CODE_TIMEOUT,ERR_MSG_TIMEOUT);
        }

        public string requestCreateOrder(string txnId, string txnAmt, string paymentType, string billType)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestCreateOrder] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnId]: " + txnId);
            logger.addRepeatLog("input param [txnAmt]: " + txnAmt);
            logger.addRepeatLog("input param [paymentType]: " + paymentType);
            logger.addRepeatLog("input param [billType]: " + billType);
            if (ifBusy)
                return RequestResult.createRespErrJson("requestCreateOrder","CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);
            
            ifBusy = true;
            if ((txnId == null || txnId.Equals(String.Empty))
                || (txnAmt == null || txnAmt.Equals(String.Empty))
                || (paymentType == null || paymentType.Equals(String.Empty))
                || (billType == null || billType.Equals(String.Empty))
                )
            {
                Console.WriteLine("Error! Input empty");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM,ERR_CODE_PARAM);
            }

            decimal dtxnAmt = decimal.Parse(txnAmt);
            if (dtxnAmt.CompareTo(decimal.Parse("0")) < 1 || dtxnAmt.CompareTo(decimal.Parse("99999999.99")) > 1)
            {
                Console.WriteLine("txnAmt must be from 0.00 to 99999999.99!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_CODE_PARAM);
            }
            if (txnId.Length > 15)
            {
                Console.WriteLine("txnId length must be 15");               
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_CODE_PARAM);
            }
            if (paymentType.Length != 3 || !paymentType.Equals("FPS"))
            {
                Console.WriteLine("paymentType length must be 3");               
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_CODE_PARAM);
            }
            if (billType.Length != 3)
            {
                Console.WriteLine("billType length must be 3");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_CODE_PARAM);
            }
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                string reqSaleStr = RequestResult.toJsonForCreateOrder(txnId, dtxnAmt, paymentType, billType);
                Console.WriteLine("reqSaleStr = " + reqSaleStr);
                if (reqSaleStr == null || "".Equals(reqSaleStr))
                {
                    Console.WriteLine("reqSaleStr is null. ");
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL,"","");
                }
                currReqByteArr = packReqMsg(reqSaleStr);
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    Console.WriteLine("currReqByteArr is null. ");
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP", txnId, paymentType, txnAmt, ERR_STATUS_FAIL, "", "");
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                Console.WriteLine("serialPort no open. ");
                closeSerialPort();
                ifBusy = false;
                return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP",txnId, paymentType, txnAmt, ERR_STATUS_FAIL,ERR_CODE_OPENCOM,ERR_MSG_OPENCOM);
            }

            int sleepTime = 5000 / 1000;
            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestCreateOrder] <<<<<<<<<<<<<<<<");
                            return currResultJsonStr;
                        }
                    }
                }
            }
            ifBusy = false;
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            return RequestResult.createRespErrJson("requestCreateOrder", "CREATE_ORDER_RESP",txnId, paymentType, txnAmt, ERR_STATUS_FAIL,ERR_CODE_TIMEOUT,ERR_MSG_TIMEOUT);
        }

        public string sendLinkTestRequest()
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [sendLinkTestRequest] >>>>>>>>>>>>>>>>");

            if (isProcessingSale)
                return RequestResult.createRespErrJson("sendLinkTestRequest", "ECHO_RESP", ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);

            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForLinkTest());
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    closeSerialPort();
                    return RequestResult.createRespErrJson("ECHO_RESP", ERR_STATUS_FAIL); 
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                closeSerialPort();

                return RequestResult.createRespErrJson("sendLinkTestRequest","ECHO_RESP", ERR_STATUS_FAIL,ERR_CODE_OPENCOM,ERR_MSG_OPENCOM);
            }

            int sleepTime = 3000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [sendLinkTestRequest] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            return RequestResult.createRespErrJson("sendLinkTestRequest","ECHO_RESP", ERR_STATUS_FAIL,ERR_CODE_TIMEOUT,ERR_MSG_TIMEOUT);
        }

        private string sendInnerLinkTestRequest()
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [sendInnerLinkTestRequest] >>>>>>>>>>>>>>>>");

            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForLinkTest());

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();

                int sleepTime = 3000 / 1000;

                DateTime startTime = DateTime.Now;

                Boolean ifEnd = false;
                while (!ifEnd)
                {
                    DateTime nowTime = DateTime.Now;
                    TimeSpan sp = nowTime - startTime;
                    if (sp.TotalSeconds > sleepTime)
                        ifEnd = true;
                    else
                    {
                        if (!isSending && !isGetACK)
                            this.resendReqMsg();
                        if (isReadyBack)
                        {
                            if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                            {
                                LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                                LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [sendLinkTestRequest] <<<<<<<<<<<<<<<<");

                                return currResultJsonStr;
                            }
                        }
                    }
                }
            }

            
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            return RequestResult.createRespErrJson("sendInnerLinkTestRequest", "ECHO_RESP", ERR_STATUS_FAIL, ERR_CODE_TIMEOUT, ERR_MSG_TIMEOUT);
        }

        public string sendHealthCheckRequest()
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [sendHealthCheckRequest] >>>>>>>>>>>>>>>>");

            if (ifBusy)
                return RequestResult.createRespErrJson("sendHealthCheckRequest", "HEALTH_CHECK_RESP", ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("sendHealthCheckRequest","HEALTH_CHECK_RESP", ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            ifBusy = true;
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForHealthCheck());
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("HEALTH_CHECK_RESP", ERR_STATUS_FAIL);
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {

                closeSerialPort();
                ifBusy = false;
                return RequestResult.createRespErrJson("sendHealthCheckRequest","HEALTH_CHECK_RESP", ERR_STATUS_FAIL,ERR_CODE_OPENCOM,ERR_MSG_OPENCOM);
            }

            int sleepTime = 5000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [sendHealthCheckRequest] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }
            ifBusy = false;
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            return RequestResult.createRespErrJson("sendHealthCheckRequest","HEALTH_CHECK_RESP", ERR_STATUS_FAIL,ERR_MSG_TIMEOUT,ERR_CODE_TIMEOUT);
        }

        public string requestSettlement()
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestSettlement] >>>>>>>>>>>>>>>>");

            if (ifBusy)
                return RequestResult.createRespErrJson("requestSettlement","SETTLE_RESP", ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSettlement","SETTLE_RESP", ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            ifBusy = true;
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForSettlement());
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("SETTLE_RESP", ERR_STATUS_FAIL);
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                ifBusy = false;
                closeSerialPort();
                return RequestResult.createRespErrJson("requestSettlement","SETTLE_RESP", ERR_STATUS_FAIL,ERR_CODE_OPENCOM,ERR_MSG_TIMEOUT);
            }

            int sleepTime = 10000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSettlement] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }

            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            ifBusy = false;
            return RequestResult.createRespErrJson("requestSettlement","SETTLE_RESP", ERR_STATUS_FAIL,ERR_CODE_TIMEOUT,ERR_MSG_TIMEOUT);
        }

        public string requestSummaryEnquiry(String txnDateRange)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestSummaryEnquiry] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnDateRange]: " + txnDateRange);
            if (ifBusy)
                return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);
            if (txnDateRange == null || "".Equals(txnDateRange.Trim()))
            {
                Console.WriteLine("parameter error");                
                return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL,ERR_CODE_PARAM,ERR_MSG_PARAM);
            }
            if (txnDateRange.Length != 17)
            {
                Console.WriteLine("txnDateRange length must be 17");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL,ERR_CODE_PARAM,ERR_MSG_PARAM);
            }
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");                
                ifBusy = false;
                return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            ifBusy = true;
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForSummaryEnquiry(txnDateRange));
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL);
                    //return "Request failed: params error";
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                ifBusy = false;
                closeSerialPort();
                return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL, ERR_CODE_OPENCOM, ERR_MSG_OPENCOM);                
            }

            int sleepTime = 10000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSummaryEnquiry] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }

            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            ifBusy = false;
            return RequestResult.createRespErrJson("requestSummaryEnquiry","SUMMARY_ENQUIRY_RESP", ERR_STATUS_FAIL, ERR_CODE_TIMEOUT, ERR_MSG_TIMEOUT);
        }

        public string requestRetrieval(string txnId)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestRetrieval] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnId]: " + txnId);

            if (isProcessingSale)
                return RequestResult.createRespErrJson("requestRetrieval", "RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);


            if (txnId == null || "".Equals(txnId.Trim()))
            {
                Console.WriteLine("parameter error");
                return RequestResult.createRespErrJson("requestRetrieval","RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (txnId.Length > 15)
            {
                Console.WriteLine("txnId length must be 15");
                return RequestResult.createRespErrJson("requestRetrieval","RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");
                closeSerialPort();
                ifBusy = false;
                return RequestResult.createRespErrJson("requestRetrieval","RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;

            if (openSerialPort())
            {
                string reqRetrievalStr = RetrievalResult.toJsonForRetrieval(txnId);
                Console.WriteLine("reqRetrievalStr = " + reqRetrievalStr);
                if (reqRetrievalStr == null || "".Equals(reqRetrievalStr))
                {
                    Console.WriteLine("reqRetrievalStr is null. ");
                    closeSerialPort();
                    return RequestResult.createRespErrJson("RETRIEVAL_RESP", ERR_STATUS_FAIL);
                }
                currReqByteArr = packReqMsg(reqRetrievalStr);
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    Console.WriteLine("currReqByteArr is null. ");
                    closeSerialPort();
                    return RequestResult.createRespErrJson("RETRIEVAL_RESP", ERR_STATUS_FAIL);
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                Console.WriteLine("serialPort no open. ");
                closeSerialPort();
                return RequestResult.createRespErrJson("requestRetrieval","RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_OPENCOM, ERR_MSG_OPENCOM);
            }

            int sleepTime = 5000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else 
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestRetrieval] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }
            
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            return RequestResult.createRespErrJson("requestRetrieval","RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_TIMEOUT, ERR_MSG_TIMEOUT);
        }

        private int innerRetrievalTimeout = 4550;
        private string requestInnerRetrieval(string txnId)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestInnerRetrieval] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnId]: " + txnId);

            if (txnId == null || "".Equals(txnId.Trim()))
            {
                Console.WriteLine("parameter error");
                return RequestResult.createRespErrJson("requestInnerRetrieval", "RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (txnId.Length > 15)
            {
                Console.WriteLine("txnId length must be 15");
                return RequestResult.createRespErrJson("requestInnerRetrieval", "RETRIEVAL_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            if (openSerialPort())
            {
                string reqRetrievalStr = RetrievalResult.toJsonForRetrieval(txnId);
                Console.WriteLine("reqRetrievalStr = " + reqRetrievalStr);
                if (reqRetrievalStr == null || "".Equals(reqRetrievalStr))
                {
                    Console.WriteLine("reqRetrievalStr is null. ");
                    //closeSerialPort();
                    return RequestResult.createRespErrJson("RETRIEVAL_RESP", ERR_STATUS_FAIL);
                }
                currReqByteArr = packReqMsg(reqRetrievalStr);
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    Console.WriteLine("currReqByteArr is null. ");
                    //closeSerialPort();

                    return RequestResult.createRespErrJson("RETRIEVAL_RESP", ERR_STATUS_FAIL);
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                Console.WriteLine("serialPort no open. ");
                //closeSerialPort();
                return RequestResult.createRespErrJson("requestInnerRetrieval", "RETRIEVAL_RESP", txnId, STATUS_PROCESSING, ERR_CODE_OPENCOM, ERR_MSG_OPENCOM);
            }


            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            //isReadyBack = false;
            //currReqByteArr = null;
            //currResultJsonStr = null;
            isGetACK = false;


            int sleepTime = innerRetrievalTimeout / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        //closeSerialPort();
                        String tmpJson = currResultJsonStr;
                        if (tmpJson != null && !"".Equals(tmpJson) && tmpJson.Contains("RETRIEVAL_RESP"))
                        {
                            //ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + tmpJson);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestInnerRetrieval] <<<<<<<<<<<<<<<<");
                            sendTime = 0;
                            isSending = false;
                            mRecvTimes = 0;
                            return tmpJson;
                        }
                        else if (tmpJson != null && !"".Equals(tmpJson) && tmpJson.Contains("ABORT_RESP"))
                        {
                        }
                        else
                        {
                            currResultJsonStr = null;
                            isReadyBack = false;
                            isGetACK = false;
                        }
                    }
                }
            }

            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            //closeSerialPort();
            return RequestResult.createRespErrJson("requestInnerRetrieval", "RETRIEVAL_RESP", txnId, STATUS_PROCESSING, ERR_CODE_TIMEOUT, ERR_MSG_TIMEOUT);
        }

        private bool ifProcessingAbort = false;
        public string requestAbort()
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestAbort] >>>>>>>>>>>>>>>>");
            if (ifProcessingAbort)
                return RequestResult.createRespErrJson("requestAbort", "ABORT_RESP", ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            ifProcessingAbort = true;
            
           
            if (openSerialPort())
            {
                String echoResult = sendInnerLinkTestRequest();
                currResultJsonStr = null;
                if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
                {
                    Console.WriteLine("LinkTest failed!");
                    ifProcessingAbort = false;
                    return RequestResult.createRespErrJson("requestAbort", "ABORT_RESP", ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
                }
                Thread.Sleep(500);
                sendTime = 0;
                isSending = false;
                mRecvTimes = 0;
                isReadyBack = false;
                currReqByteArr = null;
                currResultJsonStr = null;
                isGetACK = false;
                string abortStr = RequestResult.toJsonForAbort();
                Console.WriteLine("abortStr = " + abortStr);
                if (abortStr == null || "".Equals(abortStr))
                {
                    Console.WriteLine("abortStr is null. ");
                    if (!isProcessingSale)
                        closeSerialPort();
                    ifProcessingAbort = false;
                    return RequestResult.createRespErrJson("ABORT_RESP", ERR_STATUS_FAIL);
                }
                currReqByteArr = packReqMsg(abortStr);
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    Console.WriteLine("currReqByteArr is null. ");
                    if (!isProcessingSale)
                        closeSerialPort();
                    ifProcessingAbort = false;
                    return RequestResult.createRespErrJson("ABORT_RESP", ERR_STATUS_FAIL);
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                Console.WriteLine("serialPort no open. ");
                if (!isProcessingSale)
                    closeSerialPort();
                ifProcessingAbort = false;
                return RequestResult.createRespErrJson("requestAbort","ABORT_RESP", ERR_STATUS_FAIL, ERR_CODE_OPENCOM,ERR_MSG_OPENCOM);
            }

            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;

            int sleepTime = 5000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        
                        String tmpJson = currResultJsonStr;
                        if (tmpJson != null && !"".Equals(tmpJson) && tmpJson.Contains("ABORT_RESP"))
                        {
                            LogUtil.getInstance().addRepeatLog("[result]: " + tmpJson);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestAbort] <<<<<<<<<<<<<<<<");
                            ifProcessingAbort = false;
                            if (tmpJson.Contains("{\"EVENT_NAME\":\"ABORT_RESP\",\"STATUS\":\"00\"}") && isProcessingSale)
                            {
                                ifBusy = false;
                                isProcessingSale = false;
                            }
                            sendTime = 0;
                            isSending = false;
                            mRecvTimes = 0;
                            //isReadyBack = false;
                            //currResultJsonStr = null;
                            isGetACK = false;
                            if (!isProcessingSale)
                                closeSerialPort();
                            return tmpJson;
                        }
                        else if (tmpJson != null && !"".Equals(tmpJson) && tmpJson.Contains("RETRIEVAL_RESP"))
                        {
                        }
                        else
                        {
                            currResultJsonStr = null;
                            isReadyBack = false;
                            isGetACK = false;
                        }
                    }
                }
            }
            /*
            for (int i = 0; i < sleepTime; i++)
            {
                Console.WriteLine("retrievalResult = " + retrievalResult);
                if (!isReadyBack)
                {
                    if (i > 9 && i % 10 == 0 && !isGetACK)
                    {
                        this.resendReqMsg();
                    }
                    Console.WriteLine("Sleep i = " + i + ", " + DateTime.Now.ToString());
                    System.Threading.Thread.Sleep(1000);
                }
                else
                {
                    closeSerialPort();
                    if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                    {
                        return currResultJsonStr;
                    }
                    else
                    {
                        //return "Request failed: sytem error";
                        return RequestResult.createRespErrJson("RETRIEVAL_RESP", ERR_STATUS_SYSTEM);
                    }
                
                }
            }*/

            //
            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            closeSerialPort();
            ifProcessingAbort = false;
            return RequestResult.createRespErrJson("requestAbort","ABORT_RESP", ERR_STATUS_FAIL, ERR_CODE_TIMEOUT, ERR_MSG_TIMEOUT);
        }

        public string requestPrint(String txnId)
        {
            logger.addRepeatLog(">>>>>>>>>>>>>>>> Start Event [requestPrint] >>>>>>>>>>>>>>>>");
            logger.addRepeatLog("input param [txnId]: " + txnId);

            if (ifBusy)
                return RequestResult.createRespErrJson("requestPrint","PRINT_RESP",txnId, ERR_STATUS_FAIL, ERR_CODE_BUSY, ERR_MSG_BUSY);
            if (txnId == null || "".Equals(txnId.Trim()))
            {
                Console.WriteLine("parameter error");
                return RequestResult.createRespErrJson("requestPrint","PRINT_RESP", txnId, ERR_STATUS_FAIL,ERR_CODE_PARAM,ERR_MSG_PARAM);
            }
            if (txnId.Length > 15)
            {
                Console.WriteLine("txnId length must be 15");
                ifBusy = false;
                return RequestResult.createRespErrJson("requestPrint","PRINT_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_PARAM, ERR_MSG_PARAM);
            }
            String echoResult = sendInnerLinkTestRequest();
            if (RequestResult.toReqResultFromJsonMsg(echoResult).Status != STATUS_SUCC)
            {
                Console.WriteLine("LinkTest failed!");
                ifBusy = false;
                return RequestResult.createRespErrJson("requestPrint","PRINT_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_ECHO, ERR_MSG_ECHO);
            }
            Thread.Sleep(500);
            ifBusy = true;
            sendTime = 0;
            isSending = false;
            mRecvTimes = 0;
            isReadyBack = false;
            currReqByteArr = null;
            currResultJsonStr = null;
            isGetACK = false;
            if (openSerialPort())
            {
                currReqByteArr = this.packReqMsg(RequestResult.toJsonForReprint(txnId));
                if (currReqByteArr == null || currReqByteArr.Length == 0)
                {
                    closeSerialPort();
                    ifBusy = false;
                    return RequestResult.createRespErrJson("PRINT_RESP", ERR_STATUS_FAIL);
                    //return "Request failed: params error";
                }

                Console.WriteLine("currReqByteArr = " + currReqByteArr);
                Console.WriteLine("currReqByteArr.Length = " + currReqByteArr.Length);
                this.sendReqMsg();
            }
            else
            {
                ifBusy = false;
                closeSerialPort();
                return RequestResult.createRespErrJson("requestPrint","PRINT_RESP", txnId, ERR_STATUS_FAIL, ERR_CODE_OPENCOM, ERR_MSG_OPENCOM);
            }

            int sleepTime = 10000 / 1000;

            DateTime startTime = DateTime.Now;

            Boolean ifEnd = false;
            while (!ifEnd)
            {
                DateTime nowTime = DateTime.Now;
                TimeSpan sp = nowTime - startTime;
                if (sp.TotalSeconds > sleepTime)
                    ifEnd = true;
                else
                {
                    if (!isSending && !isGetACK)
                        this.resendReqMsg();
                    if (isReadyBack)
                    {
                        closeSerialPort();
                        if (currResultJsonStr != null && !"".Equals(currResultJsonStr))
                        {
                            ifBusy = false;
                            LogUtil.getInstance().addRepeatLog("[result]: " + currResultJsonStr);
                            LogUtil.getInstance().addRepeatLog("<<<<<<<<<<<<<<<< End Event [requestSettlement] <<<<<<<<<<<<<<<<");

                            return currResultJsonStr;
                        }
                    }
                }
            }

            Console.WriteLine("Timeout return : " + DateTime.Now.ToString());
            ifBusy = false;
            return RequestResult.createRespErrJson("requestPrint","PRINT_RESP", ERR_STATUS_FAIL,ERR_CODE_TIMEOUT,ERR_MSG_TIMEOUT);
        }

        private void closeSerialPort()
        {
            if (serialPort1 != null && serialPort1.IsOpen)
            {
                try
                {
                    Console.WriteLine("SerialPort Close ");
                    serialPort1.Close();
                }
                catch (Exception ex) { }
            }
        }

        private bool openSerialPort()
        {
            if (serialPort1 != null && serialPort1.IsOpen)
            {
                return true;
            }

            Console.WriteLine("portName = " + portName + ", baudRate = " + baudRate + ", dataBits = " + dataBits + ", stopBits = " + stopBits + ", parity = " + parity);
            if (ObjectUtil.isNull(portName) || ObjectUtil.isNull(baudRate) || ObjectUtil.isNull(dataBits) || ObjectUtil.isNull(stopBits) || ObjectUtil.isNull(parity))
            {
                Console.WriteLine("No config data.");
                return false;
            }

            try
            {
                if (serialPort1 == null)
                    serialPort1 = new System.IO.Ports.SerialPort();

                serialPort1.PortName = portName;
                Console.WriteLine("serialPort1.PortName = " + serialPort1.PortName);
                serialPort1.BaudRate = Convert.ToInt32(baudRate);
                serialPort1.DataBits = Convert.ToInt32(dataBits);
                serialPort1.StopBits = (StopBits)Enum.Parse(typeof(StopBits), stopBits);
                serialPort1.Parity = (Parity)Enum.Parse(typeof(Parity), parity);
                serialPort1.ReceivedBytesThreshold = 1;
                serialPort1.DataReceived += new SerialDataReceivedEventHandler(m_DataReceived);
               
                if (!serialPort1.IsOpen)
                {
                    serialPort1.Open();
                }
                return true;
            }
            catch (Exception err)
            {
                Console.WriteLine("Exception = " + err);

                serialPort1 = null;
                return false;
            }
        }

        private void m_DataReceived(object sender, SerialDataReceivedEventArgs eventArgs)
        {
            Console.WriteLine("****** m_DataReceived *******");
            try
            {
                if (serialPort1.IsOpen)
                {
                    int recvCount = serialPort1.BytesToRead;
                    Console.WriteLine("recvCount = " + recvCount);
                    if (recvCount > 0)
                    {
                        mRecvTimes++;
                        Console.WriteLine("mRecvTimes = " + mRecvTimes);
                        byte[] recvResult = new byte[recvCount];

                        serialPort1.Read(recvResult, 0, recvCount);

                        Console.WriteLine("**********recvResult.Length = " + recvResult.Length);
                        StringBuilder recvResultSB = new StringBuilder();
                        for (int i = 0; i < recvResult.Length; i++)
                        {
                            if (recvResult[i].ToString().Length == 1)
                            {
                                recvResultSB.Append("0");
                            }
                            recvResultSB.Append(recvResult[i].ToString());
                        }
                        Console.WriteLine("**********recvResult = " + recvResultSB.ToString());
                        // string recvResultStr = System.Text.Encoding.Default.GetString(recvResult);
                        //Console.WriteLine("read result = " + recvResultStr);
                        //int thisRecvInt = Int32.Parse(recvResultStr, System.Globalization.NumberStyles.HexNumber);

                        mTotalRecvCount += recvCount;
                        Console.WriteLine("mTotalRecvCount = " + mTotalRecvCount);

                        if (recvResult[0] == 0x06 && mRecvTimes ==1)
                        {
                            isGetACK = true;
                            Console.WriteLine("ACK!");
                            reset();
                            if (isSending)
                            {
                                sendTime = 0;
                                isSending = false;
                            }
                            return;
                        }
                        if (recvResult[0] == 0x15)
                        {
                            Console.WriteLine("NAK!");

                            reset();
                            resendReqMsg();
                            return;
                        }
                        if (mRecvTimes == 1)
                        {
                            if (recvResult[0] == 0x02)
                            {
                                Console.WriteLine("STX found!");
                            }
                            else
                            {
                                Console.WriteLine("STX not found!");
                                sendNak();
                                reset();
                                return;
                            }
                        }
                        if (mTotalRecvCount > 4 && (recvResult[recvCount - 1] == 0x03 || (recvCount > 1 && recvResult[recvCount - 2] == 0x03)))
                        {
                            if (recvResult[recvCount - 1] == 0x03)
                            {
                                Console.WriteLine("ETX found but has no LRC!");

                                System.Array.Copy(recvResult, 0, mTotalRecvResult, mRecvIndex, recvCount);
                                mRecvIndex += recvCount;

                                byte[] lrcRecvResult = new byte[1];
                                int lrcRecvCount = readFromSerialPort(lrcRecvResult);
                                if (lrcRecvCount > 0)
                                {
                                    mRecvTimes += 1;

                                    Console.WriteLine("LRC found!");
                                    Console.WriteLine("Total receive times is " + mRecvTimes);

                                    System.Array.Copy(lrcRecvResult, 0, mTotalRecvResult, mRecvIndex, lrcRecvCount);
                                }
                            }
                            else if (recvCount > 1 && recvResult[recvCount - 2] == 0x03)
                            {
                                Console.WriteLine("ETX found!");
                                Console.WriteLine("Total receive times is " + mRecvTimes);

                                System.Array.Copy(recvResult, 0, mTotalRecvResult, mRecvIndex, recvCount);
                            }

                            byte[] len = new byte[] { mTotalRecvResult[1], mTotalRecvResult[2] };
                            int length = 0;
                            String lenStr = ObjectUtil.bcd2Str(len);
                            Console.WriteLine("Length string is [" + lenStr + "]");
                            try
                            {
                                length = int.Parse(lenStr);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine("Msg length format has error : " + e);
                                sendNak();
                                reset();
                                return;
                            }
                            if (length != mTotalRecvCount - 5)
                            {
                                Console.WriteLine("Length not match! length = " + length + ", mTotalRecvCount = " + mTotalRecvCount);
                                Console.WriteLine("msg: " + System.Text.Encoding.Default.GetString(mTotalRecvResult));
                                sendNak();
                                reset();
                                return;
                            }
                            byte[] msg = new byte[length];
                            for (int i = 3; i < length + 3; i++)
                            {
                                msg[i - 3] = mTotalRecvResult[i];
                            }
                            byte olrc = mTotalRecvResult[4 + length];
                            byte[] lrcMsg = new byte[1 + len.Length + msg.Length]; // including ETX, no STX
                            System.Array.Copy(mTotalRecvResult, 1, lrcMsg, 0, lrcMsg.Length);
                            byte nlrc = ObjectUtil.lrc(lrcMsg);
                            if (nlrc == olrc)
                            {
                                Console.WriteLine("Check LRC success! LRC is [" + ObjectUtil.desToHex(new byte[] { nlrc }) + "]");
                                sendAck();
                                string jsonMsg = System.Text.Encoding.Default.GetString(msg);

                                onMsgReceived(jsonMsg);
                                reset();
                                return;
                            }
                            else
                            {
                                Console.WriteLine("Check LRC failed! LRC is [" + ObjectUtil.desToHex(new byte[] { nlrc }) + "]");
                                sendNak();
                                reset();
                                return;
                            }
                        }
                        else
                        {
                            Console.WriteLine("ETX not found!");

                            System.Array.Copy(recvResult, 0, mTotalRecvResult, mRecvIndex, recvCount);
                            mRecvIndex += recvCount;
                        }

                        System.Threading.Thread.Sleep(100);
                    }
                }
            }
            catch { }
        }
       
        private void reset()
        {
            mTotalRecvResult = new byte[4096];
            mTotalRecvCount = 0;
            mRecvIndex = 0;
            mRecvTimes = 0;
        }

        private void sendToSerialPort(byte[] msg)
        {
            try
            {
                serialPort1.Write(msg, 0, msg.Length);
            }
            catch (Exception err)
            {
                //logger.addRepeatLog("serialPort1 Write error " + err.Message);
            }
        }

        private void resendReqMsg()
        {
            if (!isSending || sendTime > 3)
            {
                this.isReadyBack = true;
                return;
            }
            sendReqMsg();
        }

        private void sendAck()
        {
            Console.WriteLine("Execute sendAck!");

            sendToSerialPort(new byte[] { 0x06 });
        }

        private void sendNak()
        {
            Console.WriteLine("Execute sendNak!");

            sendToSerialPort(new byte[] { 0x15 });
        }

        private void sendReqMsg()
        {
            try
            {
                sendTime++;
                Console.WriteLine("serialPort1 Write start ");
                isSending = true;
                serialPort1.Write(currReqByteArr, 0, currReqByteArr.Length);
            }
            catch (Exception err)
            {
                //logger.addRepeatLog("serialPort1 Write error " + err.Message);
                try
                {
                    if (currReqByteArr != null)
                    {
                        if (serialPort1.IsOpen)
                            serialPort1.Write(currReqByteArr, 0, currReqByteArr.Length);
                        else
                        {
                            serialPort1.Open();
                            serialPort1.Write(currReqByteArr, 0, currReqByteArr.Length);
                        }
                    }
                }
                catch (Exception ex) { }
            };
            Console.WriteLine("serialPort1 Write end ");
        }

        private Byte[] packReqMsg(string reqJson)
        {
            Console.WriteLine("packReqMsg -> " + reqJson);
            byte[] bytesJsonReq = System.Text.Encoding.Default.GetBytes(reqJson);

            //Step 1: Add STX 0x02 in 1st byte and msgLength with BCD format in 2-3 byte
            int msgLength = bytesJsonReq.Length;
            string msgLengthStrWithZeorLeft = msgLength.ToString().PadLeft(4, '0');
            Byte[] msgLengthBCD = ObjectUtil.ConvertFrom(msgLengthStrWithZeorLeft);
            byte[] bytesAddSTXAddMsgLenReq = new byte[bytesJsonReq.Length + 1 + 2];
            bytesAddSTXAddMsgLenReq[0] = 0x02;
            bytesAddSTXAddMsgLenReq[1] = msgLengthBCD[0];
            bytesAddSTXAddMsgLenReq[2] = msgLengthBCD[1];
            System.Array.Copy(bytesJsonReq, 0, bytesAddSTXAddMsgLenReq, 3, bytesJsonReq.Length);

            //Step 2: calculate LRC
            byte[] bytesAddETXAddMsgLenReq = new byte[bytesJsonReq.Length + 1 + 2];

            bytesAddETXAddMsgLenReq[0] = msgLengthBCD[0];
            bytesAddETXAddMsgLenReq[1] = msgLengthBCD[1];
            System.Array.Copy(bytesJsonReq, 0, bytesAddETXAddMsgLenReq, 2, bytesJsonReq.Length);
            bytesAddETXAddMsgLenReq[bytesAddETXAddMsgLenReq.Length - 1] = 0x03;
            Byte result_lrc = ObjectUtil.lrc(bytesAddETXAddMsgLenReq);

            //Step 3: pack
            byte[] finalMsg = new byte[bytesJsonReq.Length + 5];
            System.Array.Copy(bytesAddSTXAddMsgLenReq, 0, finalMsg, 0, bytesAddSTXAddMsgLenReq.Length);
            finalMsg[finalMsg.Length - 2] = 0x03;
            finalMsg[finalMsg.Length - 1] = result_lrc;

            StringBuilder reqMsgSb = new StringBuilder();
            for (int i = 0; i < finalMsg.Length; i++)
            {
                if (finalMsg[i].ToString().Length == 1)
                {
                    reqMsgSb.Append("0");
                }
                reqMsgSb.Append(finalMsg[i].ToString());
            }
            Console.WriteLine("finalMsg = " + reqMsgSb.ToString());
            return finalMsg;
        }

        private int readFromSerialPort(byte[] msg)
        {
            Console.WriteLine("Execute readFromSerialPort!");
            int recvCount = serialPort1.BytesToRead;

            if (recvCount > 0)
            {
                byte[] recvResult = new byte[recvCount];
                serialPort1.Read(recvResult, 0, recvCount);
                string recvResultStr = System.Text.Encoding.Default.GetString(recvResult);

                System.Array.Copy(recvResult, 0, msg, 0, recvCount);
            }

            return recvCount;
        }

        private void onMsgReceived(string msgReceived)
        {
            Console.WriteLine("msgReceived = " + msgReceived);
            this.currResultJsonStr = msgReceived;
            this.isReadyBack = true;
        }

    }
}