using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

using Cosmos.Common;
using Cosmos.BaseFrame;
using Cosmos.UserFrame;
using Cosmos.CommonManager;

/*-----------------------------------------------------------------------------------------------*/
// 설      명 : IC 리더기 제어
// 작  성  자 : 
// 변경  이력 : 
/*-----------------------------------------------------------------------------------------------*/
namespace Cosmos.OLEDevice
{
    /// <summary>
    /// IC 리더기 제어 CLASS
    /// </summary>
    public class DeviceICReader : IICReaderUs
    {
        #region SpcnPos.DLL 을 이용한 IC리더기 제어 함수


        /// <summary>
        /// 배출 요청 함수 
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderCardExhaust(int tranType, int mediaType, byte[] maintainType, byte[] backFeeding, byte[] etcData, byte[] output_msg);



        /// <summary>
        /// 승인 요청 함수 
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcPos(byte[] input_msg, int input_msg_len, byte[] signData, byte[] icData, byte[] oilData, byte[] authInfo, byte[] output_msg);

        /// <summary>
        /// 망취소 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnReversal(byte[] req_msg, byte[] res_msg, byte[] authInfo, byte[] output_msg);

        /// <summary>
        /// [IC리더기] 초기화 요청 함수 
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderInit();

        /// <summary>
        /// [IC리더기] 시간설정 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderSetTime();

        // 환경설정 정보 가져오기
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnGetFlag(byte[] appName, byte[] keyName, byte[] output, int outputMaxLen);

        // 환경설정 정보 설정하기
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnSetFlag(byte[] appName, byte[] keyName, byte[] value);

        /// <summary>
        /// [IC리더기] 상호인증 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderKeyDownload(byte[] inTrmlId, byte[] inAuthInfo);

        /// <summary>
        /// [IC리더기] 무결성검사 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderIntegrity(byte[] outResTime);

        /// <summary>
        /// [IC리더기] 상태확인 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderStatus(byte[] outHwStatus, byte[] outIntegrityStatus, byte[] outCardInStatus, byte[] outReaderName, byte[] outReaderVersion, byte[] outModuleId);

        /// <summary>
        /// [IC리더기] 카드 정보 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderCardInfo(int tranType, byte[] trmlId, int amount, byte[] output_msg);

        /// <summary>
        /// [IC리더기] 발급사 인증 요청 함수
        /// IcChipData는 ARC / (FS) / Additional Response Data / (FS) / Issuer Authentication Data / (FS) / Issuer Script 형태를 맞춰야 함
        /// 승인응답일 경우에는 정상적으로 데이터가 넘어오나 승인취소일 경우에는 ARC만 들어오므로 FS갯수만 맞추면 됨.
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderCardIssuer(byte[] inIcChipData, byte[] output_msg);

        /// <summary>
        /// [IC리더기] 카드번호 암호화 요청 함수
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderCardEncrypt(byte[] inCardNum, byte[] output_msg);

        // (RF) RF카드 정보 조회
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfPrepaidCardInfo(byte[] output_msg);

        /// <summary>
        /// (RF) 후불 결제 거래 카드 정보 요청
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfCreditCardInfo(byte[] terminalNo, byte[] samType, byte[] amount, byte[] msg1, byte[] msg2, byte[] msg3, byte[] output_msg);

        // (RF) [미보안] 후불 결제 거래 카드 정보 요청
        [DllImport("SpcnPosEx.dll")]
        public static extern int SpcnRfCreditCardInfoEx(byte[] terminalNo, byte[] samType, byte[] amount, byte[] msg1, byte[] msg2, byte[] msg3, byte[] output_msg);

        //20171013 dkshin 해피기프트(신) IC/RF 충전 및 승인
        /// <summary>
        /// (RF) 해피기프트카드(코나머니) 정보 읽기 조회
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfEtcCardInfo(byte[] terminalNo, byte[] samType, byte[] amount, byte[] msg1, byte[] msg2, byte[] msg3, byte[] output_msg);

        /// <summary>
        /// RF 초기화 요청 함수 
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfReaderInit();

        /// <summary>
        /// RF 시간 설정
        /// </summary>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfReaderSetTime();

        // RF 상호인증 요청
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfReaderKeyDownload(byte[] inTrmlId, byte[] inAuthInfo);

        // RF 무결성 요청
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfReaderIntegrity(byte[] outResTime);

        // RF 상태확인    
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfReaderStatus(byte[] outHwStatus, byte[] outIntegrityStatus, byte[] outCardInStatus, byte[] outReaderName, byte[] outReaderVersion, byte[] outModuleId);

        // RF 사원카드 정보 
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnRfEmployeeCardInfo(byte[] output);

        /// <summary>
        /// IC 리더 콜백 호출 요청
        /// </summary>
        /// <param name="callback"></param>
        [DllImport("SpcnPos.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SpcnRegIcCallback(IntPtr callback);
        /// <summary>
        /// IC 리더 콜백 호출 해지
        /// </summary>
        [DllImport("SpcnPos.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SpcnUnRegIcCallback();
        /// <summary>
        /// IC 리더 설정
        /// </summary>
        /// <param name="type"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnIcReaderSettingDevice(byte[] type, byte[] value);
        /// <summary>
        /// MSR 신용카드 요청 - 미인증 POS 사용
        /// </summary>
        /// <param name="input_msg"></param>
        /// <param name="input_msg_len"></param>
        /// <param name="output_msg"></param>
        /// <returns></returns>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnPos(byte[] input_msg, int input_msg_len, byte[] output_msg);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        [DllImport("SpcnPos.dll")]
        public static extern int SpcnStopProcess(int type);

        /// <summary>
        /// IC 리더기 펌웨어 업데이트
        /// </summary>
        /// <param name="checkfwtout"></param>
        /// <param name="downfwtout"></param>
        /// <param name="nPort"></param>
        /// <param name="DCheck"></param>
        /// <returns></returns>
        [DllImport("DeFWDownloadDll.dll")]
        public static extern int DE_DownloadFW(int checkfwtout, int downfwtout, int nPort, byte[] DCheck);
        /// <summary>
        /// IC 리더기 펌웨어 이전 버전 업데이트
        /// </summary>
        /// <param name="checkfwtout"></param>
        /// <param name="downfwtout"></param>
        /// <param name="nPort"></param>
        /// <returns></returns>
        [DllImport("DeFWDownloadDll.dll")]
        public static extern int DE_BacktoFW(int checkfwtout, int downfwtout, int nPort);

        //#20171016 IC리더기 펌웨어 업데이트 Start, srlee
        /// <summary>
        /// IC 리더기 펌웨어 업데이트_NEW
        /// </summary>
        /// <param name="nPort"></param>
        /// <param name="nBaud"></param>
        /// <param name="cPW"></param>
        /// <param name="filepath"></param>
        /// <returns></returns>
        [DllImport("VANDeDownloadDll.dll")]
        public static extern int DE_FWDOWN(int nPort, int nBaud, byte[] cPW, byte[] filepath);
        /// <summary>
        /// IC 리더기 펌웨어 다운로드 상태 확인하는 callback 함수 등록
        /// </summary>
        /// <param name="callback"></param>
        /// <returns></returns>
        [DllImport("VANDeDownloadDll.dll")]
        public static extern void DE_CallBackFunReg(IntPtr callback);
        //#20171016 IC리더기 펌웨어 업데이트 End, srlee
        #endregion

        /// <summary>
        /// 등록제 정보
        /// (0~15 : IC리더기 정보, 16~31 : POS S/W명 과 Version)
        /// </summary>
        private StringBuilder m_sAuthInfo_IC = new StringBuilder();
        public StringBuilder AuthInfo_IC { get { return m_sAuthInfo_IC; } }

        /// <summary>
        /// 등록제 정보
        /// (0~15 : RF리더기 정보, 16~31 : POS S/W명 과 Version)
        /// </summary>
        private StringBuilder m_sAuthInfo_RF = new StringBuilder();
        public StringBuilder AuthInfo_RF { get { return m_sAuthInfo_RF; } }

        /// <summary>
        /// StateServer Object (StateServer 객체)
        /// </summary>
        public StateServer StateObject = (StateServer)StateServer.GetInstance();
        /// <summary>
        /// Device 상태 정보 객체
        /// </summary>
        public DeviceStatus m_cDevStatus = null;

        /// <summary>
        /// Pos 상태 정보 객체
        /// </summary>
        public PosStatus m_cPosStatus = null;

        // VAN IP, PORT Update 체크 여부
        private static bool m_bUpdateIni = false;

        /// <summary>
        /// IC리더 콜백 처리 여부
        /// </summary>
        private bool m_bIcReaderCallBack = false;

        //#20171024 START, PHJ
        
        private string m_sPAY_WAY_CD;
        /// <summary>
        /// 결제수단코드
        /// </summary>
        public string PAY_WAY_CD { set { this.m_sPAY_WAY_CD = value; } }

        private string m_sPAY_DTL_CD;
        /// <summary>
        /// 결제수단상세코드
        /// </summary>
        public string PAY_DTL_CD { set { this.m_sPAY_DTL_CD = value; } }
       
        //#20171024 END, PHJ

        /// <summary>
        /// 생성자
        /// </summary>
        public DeviceICReader()
        {
            try
            {
                m_cPosStatus = (PosStatus)StateObject.POS;
                m_cDevStatus = (DeviceStatus)StateObject.DEVICE;

                //InitializeDevice();
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
        }

        /// <summary>
        /// IC리더기 초기화 작업
        /// </summary>
        public void InitializeDevice()
        {
            //UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
            UpdateIniConfig();

            if (m_cDevStatus.ICReader.UseYn == true)
            {
                SetAuthInfoString(PosConst.POS_CARD_READER_DEVICE_TYPE.IC_READER);
            }


        }
        /// <summary>
        /// SpcnPos.dll 이 사용하는 SpcnPosCfg.ini 파일 update
        /// </summary>
        private void UpdateIniConfig()
        {
            StringBuilder sbGetText = new StringBuilder();
            CmMessage m_PosDevice = CmMessage.MakeMessageFromFile(BaseCom.NxIniPath + "PosDevice.INI");
            string sPortNumber = string.Empty;
            long lBaudrate = 0;
            bool bRtn = false;
            try
            {
                sPortNumber = CmUtil.StringNullEmpty(GetConfigInfo(m_PosDevice, "ICREADER", "SerialPortNumber"));
                lBaudrate = CmUtil.LongParse(CmUtil.StringNullEmpty(GetConfigInfo(m_PosDevice, "ICREADER", "SerialBaudRate")));

                if (sPortNumber.Length < 3 || lBaudrate <= 0)
                {
                    new Exception("PosDevice.INI IC리더기 설정 오류");
                    return;
                }

                sbGetText.Clear();
                WinAPI.GetPrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME,
                                               PosConst.POS_ICREADER_CONFIG.KEY_READER_PORT,
                                               string.Empty,
                                               sbGetText,
                                               64,
                                               BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);

                if (sbGetText.ToString() != sPortNumber.Substring(3, sPortNumber.Length - 3))//Yoo modify 20160613
                {
                    bRtn = WinAPI.WritePrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME,
                                                            PosConst.POS_ICREADER_CONFIG.KEY_READER_PORT,
                                                            sPortNumber.Substring(3, sPortNumber.Length - 3),
                                                            BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);//Yoo modify 20160613
                    if (bRtn == false)
                    {
                        UserLog.WriteLogFile(UserCom.LOG_IOS,
                                             UserCom.WARNING_LEVEL,
                                             System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                             System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                             System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                             PosConst.INI_FILE_NAME.ICReaderConfig + "/" + PosConst.POS_ICREADER_CONFIG.KEY_READER_PORT + " 쓰기 실패");
                    }
                }

                sbGetText.Clear();
                WinAPI.GetPrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME,
                                               PosConst.POS_ICREADER_CONFIG.KEY_READER_BAUDRATE,
                                               string.Empty,
                                               sbGetText,
                                               64,
                                               BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);
                if (sbGetText.ToString() != Convert.ToString(lBaudrate))
                {
                    bRtn = WinAPI.WritePrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME,
                                                            PosConst.POS_ICREADER_CONFIG.KEY_READER_BAUDRATE,
                                                            Convert.ToString(lBaudrate),
                                                            BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);
                    if (bRtn == false)
                    {
                        UserLog.WriteLogFile(UserCom.LOG_IOS,
                                             UserCom.WARNING_LEVEL,
                                             System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                             System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                             System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                             PosConst.INI_FILE_NAME.ICReaderConfig + "/" + PosConst.POS_ICREADER_CONFIG.KEY_READER_BAUDRATE + " 쓰기 실패");
                    }
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
        }
        public void UpdateIniConfig(string sSvrIP, string sPort)
        {
            StringBuilder sbGetText = new StringBuilder();
            CmMessage m_PosDevice = CmMessage.MakeMessageFromFile(BaseCom.NxIniPath + "PosDevice.INI");
            bool bRtn1 = false;
            bool bRtn2 = false;
            try
            {
                // IP, PORT 설정 (SPCN)
                if (sSvrIP.Trim() != "" && sPort.Trim() != "")
                {
                    bRtn1 = WinAPI.WritePrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME, "SPCN_IP",
                                                            sSvrIP.Trim(),
                                                            BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);
                    if (bRtn1 == false)
                    {
                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.WARNING_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                                             System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()",
                                             PosConst.INI_FILE_NAME.ICReaderConfig + "/" + sSvrIP + " SPCN_IP 쓰기 실패");
                    }

                    bRtn2 = WinAPI.WritePrivateProfileString(PosConst.POS_ICREADER_CONFIG.APPNAME, "SPCN_PORT",
                                                            sPort.Trim(),
                                                            BaseCom.NxBinPath + PosConst.INI_FILE_NAME.ICReaderConfig);
                    if (bRtn2 == false)
                    {
                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.WARNING_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                                             System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()",
                                             PosConst.INI_FILE_NAME.ICReaderConfig + "/" + sPort + " SPCN_PORT 쓰기 실패");
                    }

                    if (bRtn1 == true && bRtn2 == true)
                    {
                        // VAN IP, PORT Update flag 설정
                        m_bUpdateIni = true;
                    }
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
        }

        /// <summary>
        /// 설정 파일 읽기
        /// </summary>
        /// <param name="cCfgInfo"></param>
        /// <param name="sGroup"></param>
        /// <param name="sValueName"></param>
        /// <returns></returns>
        private string GetConfigInfo(CmMessage cCfgInfo, string sGroup, string sValueName)
        {
            return GetConfigInfo(cCfgInfo, sGroup, sValueName, "");
        }
        private string GetConfigInfo(CmMessage cCfgInfo, string sGroup, string sValueName, string sDefault)
        {
            try
            {
                string sValue = cCfgInfo.GetMessage(sGroup).GetMessageValue(sValueName);
                if (sValue == null)
                    return sDefault;
                else
                    return sValue;
            }
            catch { }

            return sDefault;
        }

        /// <summary>
        /// Byte배열을 string으로 변환 (Byte배열의 null(0x00)값 제거)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private string ByteToString(byte[] data)
        {
            int inx = Array.FindIndex(data, 0, (x) => x == 0x0);
            if (inx >= 0)
            {
                return Encoding.Default.GetString(data, 0, inx);
            }
            else
            {
                return Encoding.Default.GetString(data);
            }
        }

        /// <summary>
        /// Byte배열을 string으로 변환 (Byte배열의 null(0x00)값 제거) - 카드번호 전용
        /// </summary>
        /// <param name="data"></param>
        /// <param name="?"></param>
        /// <returns></returns>
        private void ByteToString(byte[] data, ref string sData)
        {
            int inx = Array.FindIndex(data, 0, (x) => x == 0x0);
            if (inx >= 0)
            {
                sData = Encoding.Default.GetString(data, 0, inx);
            }
            else
            {
                sData = Encoding.Default.GetString(data);
            }


        }

        /// <summary>
        /// 등록제 정보 설정
        /// </summary>
        /// <param name="sDeviceType"></param>
        /// <returns></returns>
        public StringBuilder SetAuthInfoString(string sDeviceType)
        {
            string[] arICReaderStatus = null;
            string sPosSwInfo = string.Empty;
            try
            {
                if (m_bUpdateIni == false)
                {
                    UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
                }

                arICReaderStatus = GetStatus_ICReader(sDeviceType);

                sPosSwInfo = m_cPosStatus.Base.Auth_POS_SW_Ver; //PosConst.IC_AUTH_POS_SW_INFO;
                sPosSwInfo = sPosSwInfo.PadLeft(16, '#');

                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    // RF리더기
                    m_sAuthInfo_RF = new StringBuilder();

                    // 무결성 실패시 리턴
                    if (arICReaderStatus[1] != "0") return m_sAuthInfo_RF;

                    m_sAuthInfo_RF.Clear();
                    m_sAuthInfo_RF.Append(arICReaderStatus[3].PadLeft(12, '#'));
                    m_sAuthInfo_RF.Append(arICReaderStatus[4]);
                    m_sAuthInfo_RF.Append(sPosSwInfo);
                }
                else
                {
                    // IC리더기
                    m_sAuthInfo_IC = new StringBuilder();

                    // 무결성 실패시 리턴
                    if (arICReaderStatus[1] != "0") return m_sAuthInfo_IC;

                    m_sAuthInfo_IC.Clear();
                    m_sAuthInfo_IC.Append(arICReaderStatus[3].PadLeft(12, '#'));
                    m_sAuthInfo_IC.Append(arICReaderStatus[4]);
                    m_sAuthInfo_IC.Append(sPosSwInfo);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                return m_sAuthInfo_RF;
            else
                return m_sAuthInfo_IC;
        }

        #region SpcnPos.DLL 모듈 호출 함수
        /// <summary>
        /// [IC리더기] 상태확인 요청
        /// </summary>
        /// <param name="sDeviceType"></param>
        /// <returns></returns>
        public string[] GetStatus_ICReader(string sDeviceType)
        {
            int iRet = 0;
            string[] arReturn = null;
            byte[] outHwStatus = new byte[2049];
            byte[] outIntegrityStatus = new byte[2049];
            byte[] outCardInStatus = new byte[2049];
            byte[] outReaderName = new byte[2049];
            byte[] outReaderVersion = new byte[2049];
            byte[] outModuleId = new byte[2049];

            try
            {
                if (m_bUpdateIni == false)
                {
                    UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
                }

                Array.Clear(outHwStatus, 0x0, outHwStatus.Length);
                Array.Clear(outIntegrityStatus, 0x0, outIntegrityStatus.Length);
                Array.Clear(outCardInStatus, 0x0, outCardInStatus.Length);
                Array.Clear(outReaderName, 0x0, outReaderName.Length);
                Array.Clear(outReaderVersion, 0x0, outReaderVersion.Length);
                Array.Clear(outModuleId, 0x0, outModuleId.Length);

                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnRfReaderStatus.Start.");

                    if (m_cDevStatus.SignPad.UseYn == false) return arReturn;

                    iRet = SpcnRfReaderStatus(outHwStatus, outIntegrityStatus, outCardInStatus, outReaderName, outReaderVersion, outModuleId);
                }
                else
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnIcReaderStatus.Start.");

                    if (m_cDevStatus.ICReader.UseYn == false) return arReturn;

                    iRet = SpcnIcReaderStatus(outHwStatus, outIntegrityStatus, outCardInStatus, outReaderName, outReaderVersion, outModuleId);
                }

                if (iRet > 0)
                {
                    arReturn = new string[] { ByteToString(outHwStatus)
                                            , ByteToString(outIntegrityStatus)
                                            , ByteToString(outCardInStatus)
                                            , ByteToString(outReaderName)
                                            , ByteToString(outReaderVersion)
                                            , ByteToString(outModuleId)};
                    
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Success. ");
                }
                else
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Error. " + iRet);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Exception. " + ex.Message);
            }

            return arReturn;
        }

        /// <summary>
        /// 카드번호 암호화
        /// </summary>
        //#20170913 현금영수증, 포인트카드 마스킹 미적용 start
        //기존
        //public string GetEncryptedCardNo(string sPlainCardNo)
        //변경
        public string GetEncryptedCardNo(string sPlainCardNo, string sEncGB = "1")
        //#20170913 현금영수증, 포인트카드 마스킹 미적용 end
        {
            int iRtn = -1;
            string sRtn = string.Empty;
            byte[] outEncryptedCardNo;
            try
            {
                outEncryptedCardNo = new byte[2049];
                Array.Clear(outEncryptedCardNo, 0x0, outEncryptedCardNo.Length);

#if !DEVICE_MSR_VER
                // 무결성 실패후 진행시 오류 메시지 표시
                if (m_cDevStatus.ICReader.UseYn == false)
                {
                    Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                    return sRtn;
                }
                if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                {
                    Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                    return sRtn;
                }

                //#20171024 START, PHJ
                
                if (
                    (m_sPAY_WAY_CD == ItemConst.TR_ITEM_ID.ETC_INFO_ITEM) && 
                    (m_sPAY_DTL_CD == ItemConst.TR_ITEM_ID.ETC_INFO.CASHBILL) &&
                    (sPlainCardNo.Length >= 16) &&
                    (sPlainCardNo.StartsWith(PosConst.HP_CARD_PRIFIX)))
                {
                    sPlainCardNo = CmUtil.MidH(sPlainCardNo, 0, 16);

                    //#20171024 START, PHJ - 20171027
                    m_sPAY_WAY_CD = "";
                    m_sPAY_DTL_CD = "";
                    //#20171024 END, PHJ - 20171027
                }
                
                //#20171024 END, PHJ

                iRtn = SpcnIcReaderCardEncrypt(Encoding.Default.GetBytes(sPlainCardNo), outEncryptedCardNo);
                if (iRtn == -161 || iRtn == -162)
                {
                    SpcnStopProcess(0);         // 이전 진행중인 처리가 있다면 중지 후 암호화 처리(2017.06.01)
                    iRtn = SpcnIcReaderCardEncrypt(Encoding.Default.GetBytes(sPlainCardNo), outEncryptedCardNo);
                }
                if (iRtn <= 0) return sRtn;

                sRtn = ByteToString(outEncryptedCardNo);

                //#20171123 서명패드로 입력받는 경우 마스킹 미처리 start
                
                if (sEncGB == "0")
                {
                    sRtn = CmUtil.MidH(sRtn, 0, 514) + sPlainCardNo;
                }
                
                //#20171123 서명패드로 입력받는 경우 마스킹 미처리 end

#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.UseYn == false)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                        return sRtn;
                    }
                    if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                        return sRtn;
                    }

                    //#20171024 START, PHJ
                   
                    if (
                        (m_sPAY_WAY_CD == ItemConst.TR_ITEM_ID.ETC_INFO_ITEM) &&
                        (m_sPAY_DTL_CD == ItemConst.TR_ITEM_ID.ETC_INFO.CASHBILL) &&
                        (sPlainCardNo.Length >= 16) &&
                        (sPlainCardNo.StartsWith(PosConst.HP_CARD_PRIFIX)))
                    { 
                        sPlainCardNo = CmUtil.MidH(sPlainCardNo, 0, 16);

                        //#20171024 START, PHJ - 20171027
                        m_sPAY_WAY_CD = "";
                        m_sPAY_DTL_CD = "";
                        //#20171024 END, PHJ - 20171027
                    } 
                   
                    //#20171024 END, PHJ

                    iRtn = SpcnIcReaderCardEncrypt(Encoding.Default.GetBytes(sPlainCardNo), outEncryptedCardNo);
                    if (iRtn == -161 || iRtn == -162)
                    {
                        SpcnStopProcess(0);         // 이전 진행중인 처리가 있다면 중지 시킨다.
                        iRtn = SpcnIcReaderCardEncrypt(Encoding.Default.GetBytes(sPlainCardNo), outEncryptedCardNo);
                    }
                    if (iRtn <= 0) return sRtn;

                    sRtn = ByteToString(outEncryptedCardNo);
                }
                else
                {
                    // MSR
                    string sInputType = "";
                    
                    //#20171024 START, PHJ
                    //기존
                    //sPlainCardNo = MSR_CardNoCheck(sPlainCardNo, "", ref sInputType);

                    //변경
                    sPlainCardNo = MSR_CardNoCheck(sPlainCardNo, "", ref sInputType, m_sPAY_WAY_CD, m_sPAY_DTL_CD);
                    //#20171024 END, PHJ

                    //#20170913 현금영수증, 포인트카드 마스킹 미적용 start
                    //기존
                    //sRtn = "00" + CmUtil.MidH(sPlainCardNo, 0, 512) + CmUtil.MidH(sPlainCardNo, 0, 6) + "********";
                    //변경
                    
                    if (sEncGB == "0")
                    {
                        sRtn = "00" + CmUtil.MidH(sPlainCardNo, 0, 512) + sPlainCardNo;
                    }
                    else
                    {
                        sRtn = "00" + CmUtil.MidH(sPlainCardNo, 0, 512) + CmUtil.MidH(sPlainCardNo, 0, 6) + "********";
                    }
                    
                    //#20170913 현금영수증, 포인트카드 마스킹 미적용 end
                }
#endif
            }
            catch (Exception ex)
            {
                sRtn = sPlainCardNo;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return sRtn;
        }


        /// <summary>
        /// [IC리더기] 배출 요청
        /// </summary>
        public bool Exhaust_ICCard()
        {
            int iRtn = 0;
            bool bRtn = false;

            byte[] maintainType = Encoding.Default.GetBytes("2");
            byte[] backFeeding = Encoding.Default.GetBytes("00");
            byte[] etcData = Encoding.Default.GetBytes("");
            byte[] output_msg = Encoding.Default.GetBytes("");

             iRtn = SpcnIcReaderCardExhaust(3, 0, maintainType,  backFeeding,  etcData, output_msg);
            if (iRtn > 0)
            {
                bRtn = true;
            }
            return bRtn;
        }


        /// <summary>
        /// [IC리더기] 초기화 요청
        /// </summary>
        public bool Init_ICReader(string sDeviceType)
        {
            int iRtn = 0;
            bool bRtn = false;

            try
            {
                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    // 서명패드 초기화
                    iRtn = SpcnRfReaderInit();
                }
                else
                {
                    if (m_bUpdateIni == false)
                    {
                        UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
                    }

                    // IC 리더기 초기화
                    iRtn = SpcnIcReaderInit();
                }
                if (iRtn > 0)
                {
                    bRtn = true;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// [IC리더기] 시간설정 요청
        /// </summary>
        public bool SetTime_ICReader(string sDeviceType)
        {
            int iRtn = 0;
            bool bRtn = false;

            try
            {
                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    if (m_cDevStatus.SignPad.UseYn != true) return bRtn;

                    // 서명패드 시간설정 요청
                    iRtn = SpcnRfReaderSetTime();
                }
                else
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return bRtn;

                    // IC 리더기 시간설정 요청
                    iRtn = SpcnIcReaderSetTime();
                }
                if (iRtn > 0)
                {
                    bRtn = true;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// [IC리더기] 상호인증 요청
        /// </summary>
        /// <param name="sDeviceType"></param>
        /// <param name="sTerminerID"></param>
        /// <returns></returns>
        public string KeyDownload_ICReader(string sDeviceType, string sTerminerID)
        {
            int iRtn = 0;
            string sRet = UserCom.RST_ERR;

            try
            {
                // 서명패드 무결성 검사시
                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    if (m_cDevStatus.SignPad.UseYn == false) return sRet;

                    // 상태 확인
                    SetAuthInfoString(sDeviceType);

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnRfReaderKeyDownload.Start. " + AuthInfo_RF.ToString());
                    // 상호인증
                    iRtn = SpcnRfReaderKeyDownload(Encoding.Default.GetBytes(sTerminerID), Encoding.Default.GetBytes(AuthInfo_RF.ToString()));
                }
                else
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return sRet;

                    if (m_bUpdateIni == false)
                    {
                        UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
                    }

                    // 상태 확인
                    SetAuthInfoString(sDeviceType);

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnIcReaderKeyDownload.Start. " + AuthInfo_IC.ToString());

                    // 상호인증
                    iRtn = SpcnIcReaderKeyDownload(Encoding.Default.GetBytes(sTerminerID), Encoding.Default.GetBytes(AuthInfo_IC.ToString()));
                }

                if (iRtn > 0)
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Success. ");
                    sRet = UserCom.RST_OK;
                }
                else
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Error. " + iRtn);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return sRet;
        }

        /// <summary>
        /// [IC리더기] 무결성검사 요청
        /// </summary>
        /// <param name="sDeviceType">장비구분:IC/ SignPad</param>
        /// <param name="sRsltTime">응답 결과 시간</param>
        /// <returns>true:정상처리, false:에러</returns>
        public string IntegrityCheck_ICReader(string sDeviceType, ref string sRsltTime)
        {
            int iRtn = 0;
            string sRet = UserCom.RST_ERR;
            byte[] outResTime = new byte[2049];

            // 무결성 검사 상태값 설정
            DeviceStatus m_cDevStatus = (DeviceStatus)StateObject.DEVICE;

            try
            {
                sRsltTime = string.Empty;
                Array.Clear(outResTime, 0x0, outResTime.Length);

                // 상태 확인
                SetAuthInfoString(sDeviceType);

                // 시간설정
                SetTime_ICReader(sDeviceType);

                // 서명패드 무결성 검사시
                if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                {
                    if (m_cDevStatus.SignPad.UseYn == false) return sRet;

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnRfReaderIntegrity.Start. ");
                    // 무결성 검사
                    iRtn = SpcnRfReaderIntegrity(outResTime);
                }
                else
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return sRet;

                    if (m_bUpdateIni == false)
                    {
                        UpdateIniConfig(m_cDevStatus.ICReader.VanIP, m_cDevStatus.ICReader.VanPort);
                    }

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnIcReaderIntegrity.Start. ");
                    // 무결성 검사
                    iRtn = SpcnIcReaderIntegrity(outResTime);
                }

                if (iRtn > 0)
                {
                    sRsltTime = ByteToString(outResTime);
                    sRet = UserCom.RST_OK;

                    if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.IC_READER) m_cDevStatus.ICReader.Integrity_IC_Status = true;
                    else if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD) m_cDevStatus.ICReader.Integrity_SignPad_Status = true;

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Success. ");
                }
                else
                {
                    sRsltTime = string.Empty;

                    // 무결성 실패시 인증번호 삭제
                    if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.IC_READER)
                    {
                        m_sAuthInfo_IC.Clear();
                        m_cDevStatus.ICReader.Integrity_IC_Status = false;
                    }
                    else if (sDeviceType == PosConst.POS_CARD_READER_DEVICE_TYPE.SAIGNPAD)
                    {
                        m_sAuthInfo_RF.Clear();
                        m_cDevStatus.ICReader.Integrity_SignPad_Status = false;
                    }

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Error. " + iRtn);
                }
            }
            catch (Exception ex)
            {
                sRsltTime = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return sRet;
        }

        /// <summary>
        /// [IC리더기] 카드 정보 요청
        /// </summary>
        public bool GetCardInfo_ICReader(int iTranType, int iAmount, ref string sRsltMsg)
        {
            return GetCardInfo_ICReader(iTranType, iAmount, ref sRsltMsg, false);
        }
        public bool GetCardInfo_ICReader(int iTranType, int iAmount, ref string sRsltMsg, bool bMask)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[4096];

            try
            {
#if !DEVICE_MSR_VER
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                // 무결성 실패후 진행시 오류 메시지 표시
                if (m_cDevStatus.ICReader.UseYn == false)
                {
                    //Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                    return bRtn;
                }
                else if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                {
                    //Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                    return bRtn;
                }

                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "SpcnIcReaderCardInfo.Start. ");

                iRtn = SpcnIcReaderCardInfo(iTranType, Encoding.Default.GetBytes(m_cPosStatus.Base.OlePosICReaderSerialNumber), iAmount, outMsg);
                if (iRtn > 0)
                {
                    //카드번호 뒷 4자리 *로 치환 - 여전법대응! (마스킹 필요한 카드 필요시 사용)
                    if (outMsg.Length > 1046 && bMask == false)
                    {
                        for (int iRow = 1042; iRow < 1046; iRow++)
                        {
                            if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                            {
                                outMsg[iRow] = (byte)0x2A;  //*로 치환
                            }
                        }
                    }

                    ByteToString(outMsg, ref sRsltMsg);
                    bRtn = true;

                    UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Success. ");
                }
                else
                {
                    //Block된 카드인경우 에러 메세지!
                    //if (iRtn == -144)
                    //    WinManager.ErrorMessage(ErrCodeToMsg(iRtn));

                    if (iRtn != -118)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        //Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    else
                    {
                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn);
                    }
                    sRsltMsg = string.Empty;
                }
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    sRsltMsg = string.Empty;
                    Array.Clear(outMsg, 0x0, outMsg.Length);

                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.UseYn == false)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                        return bRtn;
                    }
                    else if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                        return bRtn;
                    }
                   
                    iRtn = SpcnIcReaderCardInfo(iTranType, Encoding.Default.GetBytes(m_cPosStatus.Base.OlePosICReaderSerialNumber), iAmount, outMsg);
                    if (iRtn > 0)
                    {
                        //카드번호 뒷 4자리 *로 치환 - 여전법대응! (마스킹 필요한 카드 필요시 사용)
                        if (outMsg.Length > 1046 && bMask == false)
                        {
                            for (int iRow = 1042; iRow < 1046; iRow++)
                            {
                                if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                                {
                                    outMsg[iRow] = (byte)0x2A;  //*로 치환
                                }
                            }
                        }

                        ByteToString(outMsg, ref sRsltMsg);
                        bRtn = true;
                    }
                    else
                    {
                        //Block된 카드인경우 에러 메세지!
                        //if (iRtn == -144)
                        //    WinManager.ErrorMessage(ErrCodeToMsg(iRtn));

                        if (iRtn != -118)
                        {
                            string sErrMsg = ErrCodeToMsg(iRtn);
                            Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                            UserLog.WriteLogFile(UserCom.LOG_ERROR, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                                , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                                , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                        }
                        sRsltMsg = string.Empty;
                    }
                }
#endif
            }
            catch (Exception ex)
            {
                sRsltMsg = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// [IC리더기] 발급사 인증 요청
        /// </summary>
        public bool CardIssuer_ICReader(string sIcChipData, ref string sRsltMsg)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[2049];

            try
            {
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                iRtn = SpcnIcReaderCardIssuer(Encoding.Default.GetBytes(sIcChipData), outMsg);

                if (iRtn > 0)
                {
                    sRsltMsg = ByteToString(outMsg);

                    if (CmUtil.MidH(sRsltMsg, 0, 2) == "00")
                    {
                        bRtn = true;
                    }
                    else
                    {
                        bRtn = false;
                        UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     "Error - IssuerRecvValue : " + sRsltMsg);
                    }

                }
                else
                {
                    sRsltMsg = string.Empty;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return bRtn;
        }

        /// <summary>
        /// 승인 요청
        /// </summary>        
        public int SpcnCommPos(string sInputMsg, string sSignData, string sIcData, string sOilData, string m_sAuthInfo, ref string sRecvData)
        {
            int nReturn = -99;

            try
            {
                byte[] bytInputMsg = null;
                byte[] bytSignData = null;
                byte[] bytIcData = null;
                byte[] bytOilData = null;
                byte[] bytAuthInfo = null;

                byte[] bytOutput = new byte[4096];

                sRecvData = string.Empty;
                Array.Clear(bytOutput, 0, bytOutput.Length);

                //// 무결성 실패후 진행시 오류 메시지 표시
                //if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cPosStatus.Base.OlePosICReaderUseFlag == "1")
                //{
                //    Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                //    return nReturn;
                //}

                bytInputMsg = Encoding.Default.GetBytes(sInputMsg);
                bytSignData = Encoding.Default.GetBytes(sSignData);
                bytIcData = Encoding.Default.GetBytes(sIcData);

                //#20180827 유가보조/면세유 미사용 start
                //기존
                bytOilData = Encoding.Default.GetBytes(sOilData);
                //변경
                /*
                UserLog.WriteLogFile(UserCom.LOG_SOCK, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()",
                    "[sOilData:" + sOilData);

                sOilData = "";
                bytOilData = Encoding.Default.GetBytes(sOilData);
                */
                //#20180827 유가보조/면세유 미사용 end

                if (m_sAuthInfo == PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_RF)
                {
                    bytAuthInfo = Encoding.Default.GetBytes(AuthInfo_RF.ToString());
                }
                else
                {
                    bytAuthInfo = Encoding.Default.GetBytes(AuthInfo_IC.ToString());
                }

#if !DEVICE_MSR_VER
                nReturn = SpcnIcPos(bytInputMsg, sInputMsg.Length, bytSignData, bytIcData, bytOilData, bytAuthInfo, bytOutput);   // IC 승인조회
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    nReturn = SpcnIcPos(bytInputMsg, sInputMsg.Length, bytSignData, bytIcData, bytOilData, bytAuthInfo, bytOutput);   // IC 승인조회
                }
                else
                {
                    //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 Start
                    // 기존
                    //nReturn = SpcnPos(bytInputMsg, sInputMsg.Length, bytOutput);   // MSR 승인조회

                    if ((sIcData != "" || sIcData != null) && m_sAuthInfo == PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_RF) // 해피기프트(신) MS에서 RF 승인 시
                        nReturn = SpcnIcPos(bytInputMsg, sInputMsg.Length, bytSignData, bytIcData, bytOilData, bytAuthInfo, bytOutput);   // IC 승인조회
                    else
                        nReturn = SpcnPos(bytInputMsg, sInputMsg.Length, bytOutput);   // MSR 승인조회
                    //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 End
                }             
#endif
                if (nReturn < 0)       //승인실퍠
                {
                    // 실패경우
                    sRecvData = ErrCodeToMsg(nReturn);
                }
                else
                {
                    sRecvData = ByteToString(bytOutput);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return nReturn;
        }
        /// <summary>
        /// 망취소 요청
        /// </summary>
        /// <param name="sReqMsg">직전 승인 요청전문</param>
        /// <param name="sResMsg">직전 승인 응답전문</param>
        /// <param name="sRecvData">응답전문</param>
        /// <returns></returns>
        public int SpcnCommPosForNetCancel(string sReqMsg, string sResMsg, ref string sRecvData)
        {
            int nReturn = -99;

            try
            {
                byte[] bytReqMsg = Encoding.Default.GetBytes(sReqMsg);
                byte[] bytResMsg = Encoding.Default.GetBytes(sResMsg);
                byte[] bytOutput = new byte[2049];

                sRecvData = string.Empty;
                Array.Clear(bytOutput, 0, bytOutput.Length);

#if !DEVICE_MSR_VER
                // 무결성 실패후 진행시 오류 메시지 표시
                if (m_cDevStatus.ICReader.UseYn == false)
                {
                    Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                    return nReturn;
                }
                if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                {
                    Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                    return nReturn;
                }

                nReturn = SpcnReversal(bytReqMsg, bytResMsg, Encoding.Default.GetBytes(AuthInfo_IC.ToString()), bytOutput);
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.UseYn == false)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0389);
                        return nReturn;
                    }
                    if (m_cDevStatus.ICReader.Integrity_IC_Status != true)
                    {
                        Cosmos.CommonManager.WinManager.ErrorMessage(Cosmos.CommonManager.POS_MESSAGE.ERROR.MSG_0386);
                        return nReturn;
                    }

                    nReturn = SpcnReversal(bytReqMsg, bytResMsg, Encoding.Default.GetBytes(AuthInfo_IC.ToString()), bytOutput);
                }
                else
                {
                    // MSR 망취소 함수 확인 필요
                    //nReturn = SpcnReversal(bytReqMsg, bytResMsg, Encoding.Default.GetBytes(AuthInfo_IC.ToString()), bytOutput);
                }               
#endif

                if (nReturn < 0)       //승인실퍠
                {
                    //실패경우
                    sRecvData = ErrCodeToMsg(nReturn);
                }
                else
                {
                    sRecvData = ByteToString(bytOutput);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return nReturn;
        }

        /// <summary>
        /// RF 카드 정보 요청
        /// </summary>
        /// <param name="sSamType"></param>
        /// <param name="sAmount"></param>
        /// <param name="sMsg1"></param>
        /// <param name="sMsg2"></param>
        /// <param name="sMsg3"></param>
        /// <param name="sRsltMsg"></param>
        /// <returns></returns>
        public bool GetRfCreditCardInfo(string sSamType, string sAmount, string sMsg1, string sMsg2, string sMsg3, ref string sRsltMsg)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[2049];

            try
            {
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                DeviceStatus m_cDevStatus = (DeviceStatus)StateObject.DEVICE;
                if (m_cDevStatus.SignPad.UseYn != true)
                {
                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0390);
                    return false;
                }

#if !DEVICE_MSR_VER
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
                    {
                        //#20171208, RF버튼 선택 시에만 서명패드 무결성 체크하도록 수정 Start
                        //sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0385);
                        //#20171208, RF버튼 선택 시에만 서명패드 무결성 체크하도록 수정 End
                        return false;
                    }
                }

                // 터미널 ID가져오기
                string sTerminalNo = PosMstManager.GetMstVan(ItemConst.TR_ITEM_ID.CREDITCARD_ITEM, ItemConst.TR_ITEM_ID.CREDITCARD.CREDIT_CARD, PosMst.MST_VAN.DATA.APPR_ID);

                byte[] bytTerminalNo = Encoding.Default.GetBytes(sTerminalNo);
                byte[] bytSamType = Encoding.Default.GetBytes(sSamType);
                byte[] bytAmount = Encoding.Default.GetBytes(sAmount);
                byte[] bytsMsg1 = Encoding.Default.GetBytes(sMsg1);
                byte[] bytsMsg2 = Encoding.Default.GetBytes(sMsg2);
                byte[] bytsMsg3 = Encoding.Default.GetBytes(sMsg3);

                iRtn = SpcnRfCreditCardInfo(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                if (iRtn <= 0)
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    return false;
                }

                //카드번호 뒷 4자리 *로 치환 - 여전법대응!
                if (outMsg.Length > 526)
                {
                    for (int iRow = 526; iRow < 530; iRow++)
                    {
                        if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                        {
                            outMsg[iRow] = (byte)0x2A;  //*로 치환
                        }
                    }
                }

                ByteToString(outMsg, ref sRsltMsg);
                bRtn = true;
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
                    {
                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
                        return false;
                    }

                }
                // 터미널 ID가져오기
                string sTerminalNo = PosMstManager.GetMstVan(ItemConst.TR_ITEM_ID.CREDITCARD_ITEM, ItemConst.TR_ITEM_ID.CREDITCARD.CREDIT_CARD, PosMst.MST_VAN.DATA.APPR_ID);

                byte[] bytTerminalNo = Encoding.Default.GetBytes(sTerminalNo);
                byte[] bytSamType = Encoding.Default.GetBytes(sSamType);
                byte[] bytAmount = Encoding.Default.GetBytes(sAmount);
                byte[] bytsMsg1 = Encoding.Default.GetBytes(sMsg1);
                byte[] bytsMsg2 = Encoding.Default.GetBytes(sMsg2);
                byte[] bytsMsg3 = Encoding.Default.GetBytes(sMsg3);

                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                    iRtn = SpcnRfCreditCardInfo(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                else
                    iRtn = SpcnRfCreditCardInfoEx(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                if (iRtn <= 0)
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_ERROR, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    return false;
                }

                string sTempData = ByteToString(outMsg);

                //미인증 데이터 인증 데이터 포멧으로 변환
                //카드구분(1)+카드방식(1)+신용Track데이터(40)+포인트Track데이터(42)+IC Chip 데이터(512)
                //카드구분(1)+카드방식(1)+카드정보(512)+마스킹카드번호(40)+서비스코드(5)+포인트카드정보(512)+포인트마스킹(40)+포인트서비스코드(5)+IC CHIP(512)+삼성페이 서비스(40)

                sRsltMsg = CmUtil.LeftH(CmUtil.MidH(sTempData, 0, 42), 514);
                sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 2, 6) + (CmUtil.MidH(sTempData, 8, 10).Replace("=", "").Trim().Length == 9 ? "*********" : "**********"), 40);
                sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 34, 5), 5);
                sRsltMsg += CmUtil.LeftH("", 557);
                sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 84, 512), 512);
                sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 42, 40), 40);
                

                ////카드번호 뒷 4자리 *로 치환 - 여전법대응!
                //if (outMsg.Length > 526)
                //{
                //    for (int iRow = 526; iRow < 530; iRow++)
                //    {
                //        if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                //        {
                //            outMsg[iRow] = (byte)0x2A;  //*로 치환
                //        }
                //    }

                //    if (m_cDevStatus.ICReader.UseYn != true)         // 여전법 인증여부(0:MSR, 1:IC)
                //    {
                //        for (int iRow = 0; iRow < 16; iRow++)
                //        {
                //            if (iRow >= 0 && iRow < 6)
                //                outMsg[514 + iRow] = outMsg[2 + iRow];      // 카드 bin
                //            else if (iRow >= 6 && iRow < 16)
                //                outMsg[514 + iRow] = (byte)0x2A;            // 7~16 *로 변환
                //        }

                //        for (int iRow = 34; iRow < 40; iRow++)
                //        {
                //            outMsg[555 + (iRow-35)] = outMsg[iRow];         // 서비스 코드
                //        }

                //    }
                //}

                //ByteToString(outMsg, ref sRsltMsg);
                bRtn = true;
#endif
            }
            catch (Exception ex)
            {
                sRsltMsg = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        //20171013 dkshin 해피기프트(신) IC/RF 충전 및 승인
        /// <summary>
        /// RF 코나머니카드 정보 요청
        /// </summary>
        /// <param name="sSamType"></param>
        /// <param name="sAmount"></param>
        /// <param name="sMsg1"></param>
        /// <param name="sMsg2"></param>
        /// <param name="sMsg3"></param>
        /// <param name="sRsltMsg"></param>
        /// <returns></returns>
        public bool GetRfEtcCardInfo(string sSamType, string sAmount, string sMsg1, string sMsg2, string sMsg3, ref string sRsltMsg)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[2049];

            try
            {
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                DeviceStatus m_cDevStatus = (DeviceStatus)StateObject.DEVICE;
                if (m_cDevStatus.SignPad.UseYn != true)
                {
                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0390);
                    return false;
                }

#if !DEVICE_MSR_VER
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
                    {
                        //#20171208, RF버튼 선택 시에만 서명패드 무결성 체크하도록 수정 Start
                        //sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0385);
                        //#20171208, RF버튼 선택 시에만 서명패드 무결성 체크하도록 수정 End
                        return false;
                    }
                }

                // 터미널 ID가져오기
                string sTerminalNo = PosMstManager.GetMstVan(ItemConst.TR_ITEM_ID.CREDITCARD_ITEM, ItemConst.TR_ITEM_ID.CREDITCARD.CREDIT_CARD, PosMst.MST_VAN.DATA.APPR_ID);

                byte[] bytTerminalNo = Encoding.Default.GetBytes(sTerminalNo);
                byte[] bytSamType = Encoding.Default.GetBytes(sSamType);
                byte[] bytAmount = Encoding.Default.GetBytes(sAmount);
                byte[] bytsMsg1 = Encoding.Default.GetBytes(sMsg1);
                byte[] bytsMsg2 = Encoding.Default.GetBytes(sMsg2);
                byte[] bytsMsg3 = Encoding.Default.GetBytes(sMsg3);

                iRtn = SpcnRfEtcCardInfo(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                if (iRtn <= 0)
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    return false;
                }

                //카드번호 뒷 4자리 *로 치환 - 여전법대응!
                if (outMsg.Length > 526)
                {
                    for (int iRow = 526; iRow < 530; iRow++)
                    {
                        if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                        {
                            outMsg[iRow] = (byte)0x2A;  //*로 치환
                        }
                    }
                }

                ByteToString(outMsg, ref sRsltMsg);
                bRtn = true;
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    // 무결성 실패후 진행시 오류 메시지 표시
                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
                    {
                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
                        return false;
                    }

                }
                // 터미널 ID가져오기
                string sTerminalNo = PosMstManager.GetMstVan(ItemConst.TR_ITEM_ID.CREDITCARD_ITEM, ItemConst.TR_ITEM_ID.CREDITCARD.CREDIT_CARD, PosMst.MST_VAN.DATA.APPR_ID);

                byte[] bytTerminalNo = Encoding.Default.GetBytes(sTerminalNo);
                byte[] bytSamType = Encoding.Default.GetBytes(sSamType);
                byte[] bytAmount = Encoding.Default.GetBytes(sAmount);
                byte[] bytsMsg1 = Encoding.Default.GetBytes(sMsg1);
                byte[] bytsMsg2 = Encoding.Default.GetBytes(sMsg2);
                byte[] bytsMsg3 = Encoding.Default.GetBytes(sMsg3);

                //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 Start
                //if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                //    iRtn = SpcnRfCreditCardInfo(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                //else
                //    iRtn = SpcnRfCreditCardInfoEx(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);

                iRtn = SpcnRfEtcCardInfo(bytTerminalNo, bytSamType, bytAmount, bytsMsg1, bytsMsg2, bytsMsg3, outMsg);
                //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 End

                if (iRtn <= 0)
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_ERROR, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    return false;
                }

                //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 Start
                // 기존
                //string sTempData = ByteToString(outMsg);

                //미인증 데이터 인증 데이터 포멧으로 변환
                //카드구분(1)+카드방식(1)+신용Track데이터(40)+포인트Track데이터(42)+IC Chip 데이터(512)
                //카드구분(1)+카드방식(1)+카드정보(512)+마스킹카드번호(40)+서비스코드(5)+포인트카드정보(512)+포인트마스킹(40)+포인트서비스코드(5)+IC CHIP(512)+삼성페이 서비스(40)

                //sRsltMsg = CmUtil.LeftH(CmUtil.MidH(sTempData, 0, 42), 514);
                //sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 2, 6) + (CmUtil.MidH(sTempData, 8, 10).Replace("=", "").Trim().Length == 9 ? "*********" : "**********"), 40);
                //sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 34, 5), 5);
                //sRsltMsg += CmUtil.LeftH("", 557);
                //sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 84, 512), 512);
                //sRsltMsg += CmUtil.LeftH(CmUtil.MidH(sTempData, 42, 40), 40);

                // 변경
                if (outMsg.Length > 526)
                {
                    for (int iRow = 526; iRow < 530; iRow++)
                    {
                        if (outMsg[iRow] != ((byte)0x20))   //스페이스 아니면!
                        {
                            outMsg[iRow] = (byte)0x2A;  //*로 치환
                        }
                    }
                }

                ByteToString(outMsg, ref sRsltMsg);
                //#20171129, 해피기프트(신) MS매장 RF카드 IC승인되도록 수정 End
                bRtn = true;
#endif
            }
            catch (Exception ex)
            {
                sRsltMsg = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// SPC 사원 카드 정보 읽기
        /// </summary>
        /// <param name="sRsltMsg"></param>
        /// <returns></returns>
        public bool GetSpcEmpCardInfo(ref string sRsltMsg)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[2049];

            try
            {
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                DeviceStatus m_cDevStatus = (DeviceStatus)StateObject.DEVICE;
                if (m_cDevStatus.SignPad.UseYn != true)
                {
                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0390);
                    return false;
                }

//#if !DEVICE_MSR_VER
//                // 무결성 실패후 진행시 오류 메시지 표시
//                if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
//                {
//                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
//                    return false;
//                }
//#else
//                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
//                {
//                    // 무결성 실패후 진행시 오류 메시지 표시
//                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
//                    {
//                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
//                        return false;
//                    }
//                }
//#endif
                iRtn = SpcnRfEmployeeCardInfo(outMsg);
                if (iRtn > 0)
                {
                    ByteToString(outMsg, ref sRsltMsg);
                    bRtn = true;
                }
                else
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    sRsltMsg = string.Empty;
                }
            }
            catch (Exception ex)
            {
                sRsltMsg = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// 선불카드 조회
        /// </summary>
        /// <returns></returns>
        public bool RfPrepaidCardInfo(ref string sRsltMsg)
        {
            int iRtn = 0;
            bool bRtn = false;
            byte[] outMsg = new byte[2049];

            try
            {
                sRsltMsg = string.Empty;
                Array.Clear(outMsg, 0x0, outMsg.Length);

                DeviceStatus m_cDevStatus = (DeviceStatus)StateObject.DEVICE;
                if (m_cDevStatus.SignPad.UseYn != true)
                {
                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0390);
                    return false;
                }
//#if !DEVICE_MSR_VER
//                // 무결성 실패후 진행시 오류 메시지 표시
//                if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
//                {
//                    sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
//                    return false;
//                }
//#else
//                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
//                {
//                    // 무결성 실패후 진행시 오류 메시지 표시
//                    if (m_cDevStatus.ICReader.Integrity_SignPad_Status != true)
//                    {
//                        sRsltMsg = MessageManager.GetErrorMessage(POS_MESSAGE.ERROR.MSG_0387);
//                        return false;
//                    }
//                }
//#endif
                iRtn = SpcnRfPrepaidCardInfo(outMsg);
                if (iRtn > 0)
                {
                    ByteToString(outMsg, ref sRsltMsg);
                    bRtn = true;
                }
                else
                {
                    if (iRtn != -84)
                    {
                        string sErrMsg = ErrCodeToMsg(iRtn);
                        Cosmos.CommonManager.WinManager.ErrorMessage(sErrMsg);

                        UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "ERROR => CODE : " + iRtn + "=" + sErrMsg);
                    }
                    return false;
                }
            }
            catch (Exception ex)
            {
                sRsltMsg = string.Empty;
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }

            return bRtn;
        }

        /// <summary>
        /// IC 콜백 요청
        /// </summary>
        /// <param name="delegateReader"></param>
        /// <returns></returns>
        public bool RegIcCallback(PosOLEDevice.DelegateIcReader delegateReader)
        {
            try
            {
                // return true;        // 콜백 제거(2017.05.15)
#if !DEVICE_MSR_VER
                if (m_cDevStatus.ICReader.UseYn == false) return false;
                if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnRegIcCallback.Start");

                GCHandle gch = GCHandle.Alloc(delegateReader);
                IntPtr intptr_delegate = Marshal.GetFunctionPointerForDelegate(delegateReader);
                SpcnStopProcess(0);
                SpcnRegIcCallback(intptr_delegate);
                gch.Free();

                m_bIcReaderCallBack = true;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnRegIcCallback.Success");              
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return false;
                    if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                    GCHandle gch = GCHandle.Alloc(delegateReader);
                    IntPtr intptr_delegate = Marshal.GetFunctionPointerForDelegate(delegateReader);
                    SpcnRegIcCallback(intptr_delegate);
                    gch.Free();

                    m_bIcReaderCallBack = true;    
                }
#endif
                return true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return false;
        }

        /// <summary>
        /// IC 콜백 해지
        /// </summary>
        /// <returns></returns>
        public bool UnRegIcCallback()
        {
            try
            {
                // return true;        // 콜백 제거(2017.05.15)
#if !DEVICE_MSR_VER
                if (m_cDevStatus.ICReader.UseYn == false) return false;
                if (m_bIcReaderCallBack == false) return false;
                //if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnUnRegIcCallback.Start");

                SpcnUnRegIcCallback();

                m_bIcReaderCallBack = false;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnUnRegIcCallback.Success");
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return false;
                    if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                    SpcnUnRegIcCallback();

                    m_bIcReaderCallBack = false;
                }
#endif
                return true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return false;
        }


        /// <summary>
        /// IC 콜백 설정
        /// </summary>
        /// <returns></returns>
        public bool IcReaderSettingDevice(bool bEnable)
        {
            try
            {
                // return true;        // 콜백 제거(2017.05.15)
#if !DEVICE_MSR_VER
                if (m_cDevStatus.ICReader.UseYn == false) return false;
                if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                StringBuilder a = new StringBuilder();
                StringBuilder b = new StringBuilder();
                byte[] by_a = new byte[3];
                byte[] by_b = new byte[3];
                int rc = 0;

                if (bEnable == true)
                {
                    a.Append("U1");
                    b.Append("1");
                }
                else
                {
                    a.Append("U1");
                    b.Append("0");
                }

                by_a = System.Text.Encoding.UTF8.GetBytes(a.ToString());
                by_b = System.Text.Encoding.UTF8.GetBytes(b.ToString());

                rc = SpcnIcReaderSettingDevice(by_a, by_b);
#else
                if (m_cDevStatus.ICReader.UseYn == true)         // 여전법 인증여부(0:MSR, 1:IC)
                {
                    if (m_cDevStatus.ICReader.UseYn == false) return false;
                    if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                    StringBuilder a = new StringBuilder();
                    StringBuilder b = new StringBuilder();
                    byte[] by_a = new byte[3];
                    byte[] by_b = new byte[3];
                    int rc = 0;

                    if (bEnable == true)
                    {
                        a.Append("U1");
                        b.Append("1");
                    }
                    else
                    {
                        a.Append("U1");
                        b.Append("0");
                    }

                    by_a = System.Text.Encoding.UTF8.GetBytes(a.ToString());
                    by_b = System.Text.Encoding.UTF8.GetBytes(b.ToString());

                    rc = SpcnIcReaderSettingDevice(by_a, by_b);
                }
#endif
                return true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return false;
        }

        /// <summary>
        /// 문자열을 바이트열로 변환
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        private byte[] GetByteArrayFromString(string src)
        {
            return System.Text.Encoding.Default.GetBytes(src);
        }

        /// <summary>
        /// 응답코드 
        /// </summary>
        /// <param name="nErrCode"></param>
        /// <returns></returns>
        private string ErrCodeToMsg(int nErrCode)
        {
            string sMsg = string.Empty;

            try
            {
                switch (nErrCode)
                {
                    case -3: sMsg = "암호화오류(전문생성오류)"; break;
                    case -4: sMsg = "암호화오류(전문생성오류)"; break;
                    case -5: sMsg = "암호화오류 (전문오류)"; break;
                    case -6: sMsg = "암호화오류 (전문오류)"; break;
                    case -7: sMsg = "암호화오류 (키생성)"; break;
                    case -8: sMsg = "암호화오류 (키생성)"; break;
                    case -9: sMsg = "암호화오류 (키생성)"; break;
                    case -10: sMsg = "요청 IP 오류"; break;
                    case -11: sMsg = "암호화 구분 2 붙인 전문 오류"; break;
                    case -12: sMsg = "전자서명 전문일 경우 전문길이 필드 없는 오류"; break;
                    case -13: sMsg = "전자서명 전문일 경우 전문길이 필드 없는 오류"; break;
                    case -14: sMsg = "전문 전체길이 체크 오류"; break;
                    case -15: sMsg = "파라미터 오류 (접속 IP 오류)"; break;
                    case -16: sMsg = "파라미터 오류 (요청전문 오류)"; break;
                    case -17: sMsg = "전자서명 암호화 오류"; break;
                    case -18: sMsg = "개시거래 요망"; break;
                    case -20: sMsg = "SOCKET CONNECT 오류"; break;
                    case -21: sMsg = "SOCKET SELECT 오류"; break;
                    case -22: sMsg = "SOCKET RECV SELECT 오류"; break;
                    case -23: sMsg = "SOCKET RECV SELECT 오류"; break;
                    case -24: sMsg = "SOCKET RECV 오류"; break;
                    case -25: sMsg = "SOCKET RECV 오류"; break;
                    case -26: sMsg = "SOCKET SEND 오류"; break;
                    case -30: sMsg = "전문오류 (전자서명 필요없는 거래)"; break;
                    case -31: sMsg = "전문오류 (전자서명 데이터 구조 오류)"; break;
                    case -32: sMsg = "전문오류 (CR 없음)"; break;
                    case -33: sMsg = "전문오류 (ETX 없음)"; break;
                    case -34: sMsg = "전문오류(FS2 없음)"; break;
                    case -35: sMsg = "전자서명오류 (암호화 오류)"; break;
                    case -36: sMsg = "전자서명 길이 오류 (모바일)"; break;
                    case -37: sMsg = "IC데이터 오류 (FS오류)"; break;
                    case -38: sMsg = "IC데이터 오류(IC데이터/등록정보 오류)"; break;
                    case -40: sMsg = "EOT 미수신 (수신X)"; break;
                    case -41: sMsg = "EOT 미수신 (수신오류)"; break;
                    case -42: sMsg = "SOCKET 초기화 오류"; break;
                    case -43: sMsg = "SOCKET CONNECT 오류"; break;
                    case -44: sMsg = "SOCKET SEND 오류 (암호화)"; break;
                    case -45: sMsg = "SOCKET SEND 오류 (전문)"; break;
                    case -46: sMsg = "SOCKET RECV 오류 (헤더)"; break;
                    case -47: sMsg = "SOCKET RECV 오류 (전문)"; break;
                    case -48: sMsg = "SOCKET RECV 오류 (암호화)"; break;
                    case -49: sMsg = "SOCKET RECV 오류 (CHECK)"; break;
                    case -50: sMsg = "SOCKET SEND 오류 (ACK)"; break;
                    case -60: sMsg = "(모바일)SOCKET 생성 오류"; break;
                    case -61: sMsg = "(모바일)SOCKET CONNECT 오류"; break;
                    case -62: sMsg = "(모바일)SOCKET SELECT 오류"; break;
                    case -63: sMsg = "(모바일)SOCKET 옵션 설정 오류"; break;
                    case -64: sMsg = "(모바일)SOCKET 옵션 설정 오류"; break;
                    case -65: sMsg = "(모바일)SOCKET 오류"; break;
                    case -66: sMsg = "(모바일)SOCKET RECV 오류"; break;
                    case -67: sMsg = "(모바일)SOCKET RECV SELECT 오류"; break;
                    case -68: sMsg = "(모바일)SOCKET RECV SELECT 오류"; break;
                    case -69: sMsg = "(모바일)SOCKET SEND 오류"; break;
                    case -70: sMsg = "(모바일)SOCKET SEND SELECT 오류"; break;
                    case -79: sMsg = "시리얼 클래스 생성 오류"; break;
                    case -80: sMsg = "INI 파일 오류 (TYPE 구분 설정요망)"; break;
                    case -81: sMsg = "싸인패드 포트 오류"; break;
                    case -82: sMsg = "싸인패드 포트 오류"; break;
                    case -83: sMsg = "싸인패드 통신 오류"; break;
                    case -84: sMsg = "싸인패드 사용자 취소"; break;
                    case -85: sMsg = "싸인패드 타임아웃 오류"; break;
                    case -86: sMsg = "싸인패드 오픈 오류"; break;
                    case -87: sMsg = "싸인패드 초기화 오류"; break;
                    case -88: sMsg = "싸인패드 요청 오류"; break;
                    case -89: sMsg = "싸인패드 통신 오류"; break;
                    case -90: sMsg = "요청전문오류 (헤더 메시지 길이 오류)"; break;
                    case -91: sMsg = "요청전문오류 (거래구분 코드 오류)"; break;
                    case -92: sMsg = "미지원 전문"; break;
                    case -93: sMsg = "요청전문 필수 항목 누락"; break;
                    case -94: sMsg = "버퍼 초과"; break;
                    case -95: sMsg = "핀블럭 길이 오류"; break;
                    case -96: sMsg = "(전자서명생성) 이미지 파일 미존재"; break;
                    case -97: sMsg = "(전자서명생성) 이미지 파일 읽기 오류"; break;
                    case -98: sMsg = "(전자서명생성) 이미지 파일 크기 오류"; break;
                    case -99: sMsg = "(전자서명생성) 이미지 파일 데이터 오류"; break;
                    case -101: sMsg = "IC리더기 포트 설정 오류"; break;
                    case -102: sMsg = "IC리더기 오픈 오류"; break;
                    case -103: sMsg = "IC리더기 시리얼 생성 오류"; break;
                    case -104: sMsg = "IC리더기 파라미터 오류"; break;
                    case -105: sMsg = "IC리더기 쓰기 오류"; break;
                    case -106: sMsg = "보안표준키 다운로드 항목 오류(K2)"; break;
                    case -107: sMsg = "보안표준키 다운로드 승인 거절(K2)"; break;
                    case -108: sMsg = "보안표준키 다운로드 항목 오류(K4)"; break;
                    case -109: sMsg = "보안표준키 다운로드 승인 거절(K4)"; break;
                    case -110: sMsg = "IC리더기 응답 오류(Class 생성 오류)"; break;
                    case -111: sMsg = "IC리더기 응답 오류(길이 정보 수신 오류)"; break;
                    case -112: sMsg = "IC리더기 응답 오류(STX 오류)"; break;
                    case -113: sMsg = "IC리더기 응답 오류(수신 오류)"; break;
                    case -114: sMsg = "IC리더기 응답전문 오류(STX 오류)"; break;
                    case -115: sMsg = "IC리더기 응답전문 오류(ETX 오류)"; break;
                    case -116: sMsg = "IC리더기 응답전문 오류(LRC 오류)"; break;
                    case -117: sMsg = "IC리더기 초기화 오류"; break;
                    case -118: sMsg = "IC리더기 사용자 취소"; break;
                    case -119: sMsg = "IC리더기 타임아웃 오류"; break;
                    case -120: sMsg = "IC리더기 통신 오류"; break;
                    case -121: sMsg = "카드발급사 인증요청 IC CHIP DATA 오류"; break;
                    case -122: sMsg = "카드발급사 인증요청 데이터 오류"; break;
                    case -123: sMsg = "카드발급사 등록제 정보 데이터 오류"; break;
                    case -124: sMsg = "카드발급사 응답전문 데이터 오류"; break;
                    case -125: sMsg = "카드발급사 전문 구분 데이터 오류"; break;
                    case -126: sMsg = "카드발급사 전문버젼 데이터 오류"; break;
                    case -127: sMsg = "카드발급사 응답전문 미승인 오류"; break;
                    case -128: sMsg = "카드발급사 응답전문 GS 데이터 오류"; break;
                    case -129: sMsg = "카드발급사 인증 거절 (망취소 거절) - POS 망취소 요망"; break;
                    case -130: sMsg = "카드발급사 인증 거절 (망취소 완료)"; break;
                    case -131: sMsg = "망취소 실패(GS 없음) - POS에서 망취소 요망"; break;
                    case -132: sMsg = "망취소 실패(서버 거절) - POS에서 망취소 요망"; break;
                    case -133: sMsg = "망취소 실패(통신오류) - POS에서 망취소 요망"; break;
                    case -134: sMsg = "망취소 대상 아님"; break;
                    case -140: sMsg = "IC리더기 카드 읽기 오류 (거래매체 유형 미지정 오류)"; break;
                    case -141: sMsg = "IC리더기 카드 읽기 오류 (거래매체 유형 예외 오류)"; break;
                    case -142: sMsg = "IC리더기 카드 읽기 오류 (IC거래 구분 오류)"; break;
                    case -143: sMsg = "IC리더기 거래중 카드 제거 오류"; break;
                    case -144: sMsg = "IC리더기 거래가 거절된 카드 오류"; break;
                    case -145: sMsg = "IC리더기 기타 오류"; break;
                    case -146: sMsg = "IC리더기 거래 요청 전 카드 삽입 오류"; break;
                    case -147: sMsg = "IC리더기 상호인증 미완료 후 거래 시도 오류"; break;
                    case -148: sMsg = "IC리더기 무결성 미성공 후 거래 시도 오류"; break;
                    case -149: sMsg = "IC리더기 에러 코드 발생 오류"; break;
                    case -150: sMsg = "IC리더기 Fallback 진행 오류"; break;
                    case -151: sMsg = "IC리더기 거래 중 오류 (비정상 응답)"; break;
                    case -161: sMsg = "IC 거래 진행 중"; break;
                    case -162: sMsg = "SIGNPAD 거래 진행 중"; break;
                    case -2243: sMsg = "여러장의 카드가 입력됨"; break;
                    case -2150: sMsg = "지원 불가 카드입니다."; break;
                    default: sMsg = "정의되어 있지 않은 메세지" + "[" + nErrCode + "]"; break;
                }

                //sMsg = string.Format("ErrCd:{0} Desc:{1}", nErrCode, sMsg);
            }
            catch { }
            return sMsg;
        }
        #endregion

        #region 카드번호 첫자리와 끝자리 체크하여 문자인 경우 스페이스로 치환
        /// <summary>
        /// 카드번호 첫자리와 끝자리 체크하여 문자인 경우 스페이스로 치환
        /// </summary>
        /// <param name="sCardNo"></param>
        /// <returns></returns>

        //#20171024 START, PHJ
        //기존
        //private string MSR_CardNoCheck(string sCardNo, string sValidDate, ref string sInputType)
        
        //변경
        private string MSR_CardNoCheck(string sCardNo, string sValidDate, ref string sInputType, string sPayWayCd = "", string sPayDtlCd = "")
        //#20171024 END, PHJ
        
        {
            string sRet = "";
            string sFirst = CmUtil.MidH(sCardNo, 0, 1);
            string sLast = CmUtil.MidH(sCardNo, CmUtil.LenH(sCardNo.Trim()) - 1, 1);

            try
            {
                if (sFirst.Contains("^") == true)
                    return "";
                else if (sFirst.Contains("%") == true)
                    return "";

                sCardNo = sCardNo.Trim();

                if (sFirst.Contains(m_cDevStatus.Msr.STX) == true && m_cDevStatus.Msr.STX.Trim() != "")
                {
                    // 첫자리가 ;, ? 경우 치환
                    sCardNo = CmUtil.MidH(sCardNo, 1, CmUtil.LenH(sCardNo.Trim()));
                }
                else if (CmUtil.IsNumber(sFirst) != true)
                {
                    // 첫자리가 숫자가 아닌 경우 치환
                    sCardNo = CmUtil.MidH(sCardNo, 1, CmUtil.LenH(sCardNo.Trim()));
                }

                if (sLast.Contains(m_cDevStatus.Msr.ETX) == true && m_cDevStatus.Msr.ETX.Trim() != "")
                {
                    // 끝자리가 ? 경우 치환
                    sCardNo = CmUtil.MidH(sCardNo, 0, CmUtil.LenH(sCardNo.Trim()) - 1);
                }

                if (sCardNo.IndexOf("=") > 0)
                {
                    if (sCardNo.Trim().Length >= 37)
                        sCardNo = CmUtil.MidH(sCardNo, 0, 37);

                    sInputType = PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_SWIP;
                }
                else if (sValidDate != null && sValidDate.Trim() != "")
                {
                    sCardNo = sCardNo + "=" + sValidDate;
                    sInputType = PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_KEYIN;
                }
                else
                {
                    //#20171024 START, PHJ
                    //기존
                    //sInputType = PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_KEYIN;

                    //변경
                    if (
                        (m_sPAY_WAY_CD == ItemConst.TR_ITEM_ID.ETC_INFO_ITEM) &&
                        (m_sPAY_DTL_CD == ItemConst.TR_ITEM_ID.ETC_INFO.CASHBILL) &&
                        (sCardNo.Length >= 16) &&
                        (sCardNo.StartsWith(PosConst.HP_CARD_PRIFIX)))
                    {
                        sInputType = PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_SWIP;
                        sCardNo = CmUtil.MidH(sCardNo, 0, 16);

                        m_sPAY_WAY_CD = "";
                        m_sPAY_DTL_CD = "";
                    }
                    else
                    {
                        sInputType = PosConst.POS_VAN_MASTER.INPUT_TYPE.VAN_KEYIN;
                    }
                    //#20171024 END, PHJ
                }

                sRet = sCardNo;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return sRet;
        }
        #endregion

        #region IC리더기 펌웨어 업데이트 요청
        /// <summary>
        /// IC리더기 펌웨어 업데이트 요청
        /// </summary>
        /// <param name="checkfwtout"></param>
        /// <param name="downfwtout"></param>
        /// <param name="nPort"></param>
        /// <param name="DllCheck"></param>
        /// <param name="sMsg"></param>
        /// <returns></returns>
        public bool SetDE_DownloadFW(int checkfwtout, int downfwtout, int nPort, byte[] DllCheck, ref string sMsg)
        {
            int iRtn = 0;
            bool bRtn = false;

            try
            {
                if (m_cDevStatus.ICReader.UseYn == false) return true;

                // IC리더기 펌웨어 업데이트 요청
                iRtn = DE_DownloadFW(checkfwtout, downfwtout, nPort, DllCheck);

                // 응답값
                sMsg = GetReturn_DE_DownloadFW(iRtn);

                // 업데이트 성공 또는 업데이트 필요없으면 정상 리턴
                if (iRtn == 1000 || iRtn == 1001) bRtn = true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message + "\n" + sMsg );
            }

            return bRtn;
        }

        //#20171016 IC리더기 펌웨어 업데이트 Start, srlee
        /// <summary>
        /// IC 리더기 펌웨어 업데이트_NEW
        /// </summary>
        /// <param name="nPort"></param>
        /// <param name="nBaud"></param>
        /// <param name="filepath"></param>
        /// <param name="callBackFunc"></param>
        /// <returns></returns>
        public int SetDE_FWDOWN(int nPort, int nBaud, byte[] filepath, IntPtr callBackFunc)
        {
            int iRtn = -99;
            byte[] cPW = Encoding.UTF8.GetBytes("FC28CCCE3C301E274E135435C54A46CC");

            try
            {
                DE_CallBackFunReg(callBackFunc);

                // IC리더기 펌웨어 업데이트 요청
                iRtn = DE_FWDOWN(nPort, nBaud, cPW, filepath);

                if (iRtn != 0) // 0:정상
                {
                    UserLog.WriteLogFile(UserCom.LOG_IOS, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                 , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                 , "ICREADER FW ERROR => CODE : " + iRtn);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return iRtn;
        }
        //#20171016 IC리더기 펌웨어 업데이트 End, srlee
        #endregion 

        #region IC리더기 펌웨어 업데이트 상태 응답값
        /// <summary>
        /// IC리더기 펌웨어 업데이트 상태 응답값
        /// </summary>
        /// <param name="ret"></param>
        /// <returns></returns>
        private string GetReturn_DE_DownloadFW(int ret)
        {
            string sMsg = "";
            try
            {
                switch (ret)
                {
                    case 1000:
                        sMsg = "성공하였습니다.";
                        break;
                    case 1001:
                        sMsg = "업데이트가 필요없습니다.";
                        break;
                    case 1002:
                        sMsg = "업데이트가 필요합니다.";
                        break;
                    case 1003:
                        sMsg = "다운로드 체크 프로그램에서 응답을 못받았습니다.";
                        break;
                    case 1005:
                        sMsg = "다운로드 체크 프로그램에서 응답 받는 환경 생성 실패하였습니다.";
                        break;
                    case 1006:
                        sMsg = "업데이트 프로그램이 실행 안되어있습니다.";
                        break;
                    case 1:
                        sMsg = "서버에 연결하지 않고 펌웨어 업데이트를 시도하였습니다.";
                        break;
                    case 2:
                        sMsg = "다운로드할 단말기를 못찾았습니다.";
                        break;
                    case 3:
                        sMsg = "FTP 연결에 실패하였습니다.";
                        break;
                    case 4:
                        sMsg = "리더기 정보 및 서버 체크 중입니다.";
                        break;
                    case 5:
                        sMsg = "업데이트 정보 파일 가져오기를 실패하였습니다.";
                        break;
                    case 6:
                        sMsg = "업데이트 할 펌웨어 파일이 없습니다.";
                        break;
                    case 7:
                        sMsg = "업데이트 할 펌웨어 파일 가져오기에 실패하였습니다.";
                        break;
                    case 8:
                        sMsg = "펌웨어 인증에 실패하였습니다.(1)";
                        break;
                    case 9:
                        sMsg = "펌웨어 인증에 실패하였습니다.(2)";
                        break;
                    case 10:
                        sMsg = "펌웨어 인증에 실패하였습니다.(3)";
                        break;
                    case 11:
                        sMsg = "펌웨어 파일의 버전 조회에 실패하였습니다.";
                        break;
                    case 12:
                        sMsg = "BIOS 인증에 실패하였습니다.";
                        break;
                    case 13:
                        sMsg = "펌웨어 파일 읽기에 실패하였습니다.";
                        break;
                    case 14:
                        sMsg = "펌웨어 파일 다운로드 도중에 실패하였습니다.";
                        break;
                    case 15:
                        sMsg = "펌웨어 파일 다운로드 완료 후 실패하였습니다.";
                        break;
                    case 16:
                        sMsg = "펌웨어 파일 다운로드 완료 후 펌웨어 확인에 실패하였습니다.";
                        break;
                    case 17:
                        sMsg = "단말기 포트 연결에 실패하였습니다.";
                        break;
                    case 18:
                        sMsg = "펌웨어 파일 다운로드 중입니다.";
                        break;
                    case 19:
                        sMsg = "잘못된 펌웨어 버전 정보입니다.";
                        break;
                    case 20:
                        sMsg = "서버에서 다운로드 받은 버전과 다운로드 완료한 펌웨어 파일의 버전 정보가 일치하지 않습니다.";
                        break;
                    case 21:
                        sMsg = "서버 확인 로그 파일 저장에 실패하였습니다.";
                        break;
                    case 22:
                        sMsg = "서버 확인 로그 파일 저장에 실패하였습니다.";
                        break;
                    case 23:
                        sMsg = "서버 확인 로그 파일 저장에 실패하였습니다.(년도 폴더 생성 실패)";
                        break;
                    case 24:
                        sMsg = "서버 확인 로그 파일 저장에 실패하였습니다.(월 폴더 생성 실패)";
                        break;
                    case 25:
                        sMsg = "다운로드 받은 펌웨어 파일의 버전 확인에 실패하였습니다.";
                        break;
                    case 26:
                        sMsg = "다운로드 도중 타임아웃 실패하였습니다.";
                        break;
                    case 27:
                        sMsg = "이전 버전의 파일이 없습니다.";
                        break;
                    case 28:
                        sMsg = "이전버전 파일 다운로드 도중 실패하였습니다.";
                        break;
                    case 29:
                        sMsg = "펌웨어와 호환되지않는 DLL입니다.";
                        break;
                    case 1008:
                        sMsg = "파일을 실행할 수 없습니다. 관리자에게 문의하십시오.";
                        break;
                    case 30:
                        sMsg = "DualPayUpdater를 실행할 수 없습니다.";
                        break;
                    case 31:
                        sMsg = "이전 버전의 펌웨어 파일이 존재하지 않습니다.";
                        break;
                    case 32:
                        sMsg = "다운받은 펌웨어 파일이 존재하지 않습니다.";
                        break;
                    case 33:
                        sMsg = "이전 버전의 펌웨어 파일의 버전 확인을 실패하였습니다.";
                        break;
                    case 1007:
                        sMsg = "업데이트할 FW 파일이 없습니다.";
                        break;
                    case 1009:
                        sMsg = "이전 버전의 펌웨어 파일이 존재합니다.";
                        break;
                    case 34:
                        sMsg = "업데이트를 하지 않았습니다.";
                        break;
                    default:
                        sMsg = "에러가 발생하였습니다.";
                        break;
                }
            }
            catch (Exception)
            {

                throw;
            }
            return sMsg;
        }
        #endregion 


        [DllImport("SpcnPos.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int SpcnIcReaderCardInfo_RegCallback(int tranType, byte[] trmlId, int amount, int timeout_sec, IntPtr callback);

        [DllImport("SpcnPos.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int SpcnIcReaderCardInfo_UnRegCallback();

        /// <summary>
        /// IC 콜백 요청(CARD INFO)
        /// </summary>
        /// <param name="sTmrId"></param>
        /// <param name="nCardAmt"></param>
        /// <param name="delegateIcReader"></param>
        /// <returns></returns>
        public bool RegIcCallbackCardInfo(string sTmrId, int nCardAmt, PosOLEDevice.CallbackIc delegateIcReader)
        {
            try
            {
                if (m_cDevStatus.ICReader.UseYn == false) return false;
                if (m_cDevStatus.ICReader.Integrity_IC_Status != true && m_cDevStatus.ICReader.UseYn == true) return false;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnIcReaderCardInfo_RegCallback.Start");
                int rc = 0;
                GCHandle gch = GCHandle.Alloc(delegateIcReader);


                

                IntPtr intptr_delegate = Marshal.GetFunctionPointerForDelegate(delegateIcReader);
                rc = SpcnIcReaderCardInfo_RegCallback(0, GetByteArrayFromString(sTmrId), nCardAmt, 60, intptr_delegate);
                gch.Free();

                m_bIcReaderCallBack = true;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnIcReaderCardInfo_RegCallback.Success");

                return true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return false;
        }

        /// <summary>
        /// IC 콜백 해지(CARD INFO)
        /// </summary>
        /// <returns></returns>
        public bool UnRegIcCallbackCardInfo()
        {
            try
            {

                if (m_cDevStatus.ICReader.UseYn == false) return false;
                if (m_bIcReaderCallBack == false) return false;
                
                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnIcReaderCardInfo_UnRegCallback.Start");

                int rc = SpcnIcReaderCardInfo_UnRegCallback();
                
                m_bIcReaderCallBack = false;

                UserLog.WriteLogFile(UserCom.LOG_IOS, UserCom.INFO_LEVEL, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name
                                            , System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
                                            , "SpcnIcReaderCardInfo_UnRegCallback.Success " + rc);

                return true;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_IOS,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
            return false;
        }
    }
}