using System;
using System.Text;
using Platform.Common;
using Platform.Common.RunningParameters;
using Platform.Common.LogSystem;
using TellerSystem.Communication.MessageHelper;

namespace TellerSystem.Communication.Package
{
    /// <summary>
    /// 8583 128域类型报文，TCP通讯方式的组包，解包处理。
    /// </summary>
    class Msg858303 : IPackage
    {
        //定义静态实例
        public static Msg858303 Instance;
        /// <summary>
        ///静态实例初始化函数
        /// </summary>
        static public Msg858303 GetInstance()
        {
            if (Instance == null)
            {
                Instance = new Msg858303();
            }
            return Instance;
        }

        /// <summary>
        /// 组包操作
        /// </summary>
        /// <returns>报文数据包</returns>
        public byte[] Integrate(Message msg)
        {
            byte[] returnData = null;

            try
            {
                returnData = DoIntegrate(msg);
            }
            catch (Exception ex)
            {
                //写错误信息
                //MsgPackage.LogObj.Error(ex.Message);
                throw;
            }
            return returnData;
        }

        /// <summary>
        /// 解包操作
        /// </summary>
        /// <param name="msg">核心返回数据包</param>
        /// <param name="data">核心返回数据包</param>
        /// <returns></returns>
        public bool Analyze(Message msg, byte[] data)
        {
            try
            {
                //进行解包处理
                DoAnalyze(msg, data);
            }
            catch (Exception ex)
            {

                return false;
            }
            return true;
        }

        #region 组包处理

        /// <summary>
        /// 组包处理
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        private byte[] DoIntegrate(Message msg)
        {
            //报文数据区
            byte[] msgData;
            //报文总长度
            int totalLen;
            //8位长度对应字符串
            string strLen;
            //报文数据区的长度
            int msgDataLen;
            //60位报文头
            string msgTitle;
            //5报文类型
            byte[] msgKindByte;
            //位图区域
            byte[] bitMapByte = new byte[16];
            //有效数据内容
            string bitDataStr = string.Empty;
            byte[] bitDataByte;
            //组包数据包
            byte[] totalMsgData;

            //文件标志 0xff==no file   0x7f==file
            byte fileFlag;
            //根据当前交易附件标志设置文件标志
            if (msg.FileFlag)
            {
                fileFlag = 0x7f;
            }
            //无文件
            else
            {
                fileFlag = 0xff;
            }
            try
            {
                //报文类型
                msgKindByte = PlatformSettings.Encoding.GetBytes("     ");
                //组织报文数据区域信息，位图区，数据区
                //GetBitData(msg, bitMapByte, ref bitDataStr);
                //bitDataByte = PlatformSettings.Encoding.GetBytes(bitDataStr);
                bitDataByte = msg.IntegrateFd(out bitMapByte);

                //报文数据区长度
                msgDataLen = msgKindByte.Length + bitMapByte.Length + bitDataByte.Length;
                //报文总长度
                totalLen = msgDataLen + 63;
                //8位长度对应字符串
                strLen = Convert.ToString(totalLen).PadLeft(8, '0');
                //60位报文头
                msgTitle = Convert.ToString(msgDataLen).PadLeft(4, '0');
                //lianyintong 报文头要求
                //00:渠道编号,00:系统编号
                msgTitle = "0000" + "MDBS1" + "    ";

                msgTitle = msgTitle.PadRight(63, ' ');

                //合并5位报文类型，位图，数据区域
                msgData = new byte[msgDataLen];
                //合并操作
                for (int i = 0; i < msgData.Length; i++)
                {
                    if (i < msgKindByte.Length)
                    {
                        msgData[i] = msgKindByte[i];
                    }

                    if (i > msgKindByte.Length - 1 & i < msgKindByte.Length + bitMapByte.Length)
                    {
                        msgData[i] = bitMapByte[i - msgKindByte.Length];
                    }
                    if (i > msgKindByte.Length + bitMapByte.Length - 1)
                    {
                        msgData[i] = bitDataByte[i - msgKindByte.Length - bitMapByte.Length];
                    }
                }
                //合并组包数据
                byte[] len8 = PlatformSettings.Encoding.GetBytes(strLen);
                //报文头字节数组
                byte[] msgTitleByte = PlatformSettings.Encoding.GetBytes(msgTitle);
                totalMsgData = new byte[len8.Length + msgTitleByte.Length + msgData.Length];
                for (int j = 0; j < totalMsgData.Length - 1; j++)
                {
                    if (j < len8.Length)
                    {
                        totalMsgData[j] = len8[j];
                    }
                    if (j > len8.Length - 1 & j < len8.Length + msgTitleByte.Length)
                    {
                        totalMsgData[j] = msgTitleByte[j - len8.Length];
                    }
                    if (j > len8.Length + msgTitleByte.Length - 1)
                    {
                        totalMsgData[j] = msgData[j - len8.Length - msgTitleByte.Length];
                    }
                }
                //设置文件标志位
                //totalMsgData[totalMsgData.Length - 1] = fileFlag;
            }
            catch (Exception ex)
            {
                //写错误信息
                //MsgPackage.LogObj.Error(ex.Message);
                throw;
            }
            return totalMsgData;
        }

        /// <summary>
        /// 生成报文位图区，数据区
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="bitMap"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        private void GetBitData(Message msg, byte[] bitMap, ref string data)
        {
            //当前域数据
            string curData = "";
            StringBuilder tmpStr = new StringBuilder();
            StringBuilder logStr = new StringBuilder();
            try
            {
                //位图字符串
                //初始化位图区域(都为零)
                string bitStr = "0".PadLeft(128, '0'); ;
                //128位位图数组
                byte[] bitByte = PlatformSettings.Encoding.GetBytes(bitStr);
                //8583(128)类型报文第一位图值为1
                bitByte[0] = Convert.ToByte('1');

                //设置对应位图值
                for (int i = 1; i < 128; i++)
                {
                    curData = "";
                    //取得当前域的数据
                    logStr.Append(GetBitItemData(msg, i + 1, ref curData));

                    //处理当前域位图信息
                    //当前域值不为空时，对应位图为1.
                    if (curData != "")
                    {
                        bitByte[i] = Convert.ToByte('1');
                        //处理当前域的数据信息
                        //每个域的内容里不允许有‘\0'和'\r'，将‘\0’替换为‘ ’
                        curData = curData.Replace('\0', ' ').Replace('\n', ' ').Replace('\r', ' ');
                        tmpStr.Append(curData);
                    }
                }
                //位图字符串
                bitStr = PlatformSettings.Encoding.GetString(bitByte);
                //写位图信息
                //MsgPackage . LogObj.Debug("\n请求位图：\n" + bitStr.Replace( '\0','\n'));
                //写报文数据信息
                //MsgPackage.LogObj.Info("\n请求数据：\n" + logStr.ToString());
                PlatformLogger.CommunicationInfo("\n请求数据：\n" + logStr.ToString());
                //转换为16位字符串)));))
                for (int j = 0; j < 16; j++)
                {
                    int k = (j) * 8;
                    bitMap[j] = Convert.ToByte(Convert.ToInt32(bitStr.Substring(k, 8), 2));
                }
            }
            catch (Exception ex)
            {
                //写错误信息
                PlatformLogger.SystemErrorInfo("获取8583位图数据出现异常！", ex);
                throw;
            }
            data = tmpStr.ToString();
        }

        /// <summary>
        /// 处理某一域的数据内容
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="i">当前域序号</param>
        /// <param name="curData">当前域数据</param>
        /// <returns>日志信息</returns>
        private static string GetBitItemData(Message msg, int i, ref string curData)
        {
            #region 采用新的报文结构
            //MsgBitMap msgBitMap = new MsgBitMap();
            ////取得当前域的数据内容
            //string tmpStr00 = string.Empty;
            //string tmpStr01 = "Fd" + Convert.ToString(i + 1);
            //string tmpFalg01 = "Flag" + Convert.ToString(i + 1);
            //string tmpStr02 = "Bit" + Convert.ToString(i + 1);
            //string length = MsgBitMap.BitMap[i, 0];
            //int tmpLen = 0;
            //string tmpData = "";
            //bool tmpFlag = false;
            //string[,] bitMap;
            //string returnStr = "";
            //string tmpStr = "";
            //switch (length)
            //{
            //    //停用
            //    case "-1":
            //        {
            //            break;
            //        }
            //    //定长
            //    case "0":
            //        {
            //            //无子域
            //            if (MsgBitMap.BitMap[i, 3] == "0")
            //            {
            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr01).GetValue(msg, null), "").ToString();
            //                //当前域有数据
            //                if (tmpData != "")
            //                {
            //                    curData = CommomFunctions.GetLenStr(tmpData, Convert.ToInt32(MsgBitMap.BitMap[i, 1]), false);
            //                    //日志信息
            //                    returnStr = tmpStr01 + ":[" + curData + "]\n";
            //                }
            //            }
            //            //有子域
            //            else if (MsgBitMap.BitMap[i, 3] == "1")
            //            {
            //                tmpStr00 = tmpStr01 + "_00";
            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr00).GetValue(msg, null), "").ToString();
            //                if (tmpData != "")
            //                {
            //                    tmpFlag = true;
            //                    curData = tmpData;
            //                    //日志信息
            //                    returnStr = tmpStr00 + ":[" + curData + "]\n";
            //                }
            //                else
            //                {
            //                    tmpFlag =
            //                        Convert.ToBoolean(
            //                            CommomFunctions.NVL(msg.GetType().GetProperty(tmpFalg01).GetValue(msg, null), ""));
            //                    if (tmpFlag)
            //                    {
            //                        bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
            //                        for (int j = 0; j < (bitMap.Length / 3); j++)
            //                        {
            //                            //定长
            //                            if (bitMap[j, 0] == "0")
            //                            {
            //                                //取得当前子域的数据
            //                                string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
            //                                tmpStr = CommomFunctions.GetLenStr(
            //                                    CommomFunctions.NVL(
            //                                        msg.GetType().GetProperty(tmpStr01Sub).GetValue(msg, null), "").
            //                                        ToString
            //                                        (), Convert.ToInt32(bitMap[j, 1]), false);
            //                                curData += tmpStr;
            //                                //日志信息
            //                                returnStr += tmpStr01Sub + ":[" + tmpStr + "]\n";
            //                            }
            //                            //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
            //                            else
            //                            {
            //                            }
            //                        }
            //                    }
            //                }
            //                curData = CommomFunctions.GetLenStr(curData, Convert.ToInt32(MsgBitMap.BitMap[i, 1]),
            //                                                           false);
            //            }
            //            break;
            //        }
            //    //变长
            //    default:
            //        {
            //            //无子域
            //            if (MsgBitMap.BitMap[i, 3] == "0")
            //            {
            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr01).GetValue(msg, null), "").ToString();
            //                //当前域有数据
            //                if (tmpData != "")
            //                {
            //                    tmpFlag = true;
            //                    curData = tmpData;
            //                    //日志信息
            //                    returnStr = tmpStr01 + ":[" + curData + "]\n";
            //                }
            //            }
            //            //有子域
            //            else if (MsgBitMap.BitMap[i, 3] == "1")
            //            {
            //                tmpStr00 = tmpStr01 + "_00";
            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr00).GetValue(msg, null), "").ToString();
            //                if (tmpData != "")
            //                {
            //                    tmpFlag = true;
            //                    curData = tmpData;
            //                    //日志信息
            //                    returnStr = tmpStr00 + ":[" + curData + "]\n";
            //                }
            //                else
            //                {
            //                    tmpFlag =
            //                        Convert.ToBoolean(
            //                            CommomFunctions.NVL(msg.GetType().GetProperty(tmpFalg01).GetValue(msg, null), ""));
            //                    //当前域有数据
            //                    if (tmpFlag)
            //                    {
            //                        bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
            //                        for (int j = 0; j < (bitMap.Length / 3); j++)
            //                        {
            //                            //定长
            //                            if (bitMap[j, 0] == "0")
            //                            {
            //                                //取得当前子域的数据
            //                                string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
            //                                tmpStr = CommomFunctions.GetLenStr(
            //                                    CommomFunctions.NVL(
            //                                        msg.GetType().GetProperty(tmpStr01Sub).GetValue(msg, null), "").
            //                                        ToString
            //                                        (), Convert.ToInt32(bitMap[j, 1]), false);
            //                                curData += tmpStr;
            //                                //日志信息
            //                                returnStr += tmpStr01Sub + ":[" + tmpStr + "]\n";
            //                            }
            //                            //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
            //                            else
            //                            {
            //                            }
            //                        }
            //                    }
            //                }
            //            }
            //            if (tmpFlag)
            //            {
            //                //长度大于最大长度
            //                tmpLen = PlatformSettings.Encoding.GetByteCount(curData);
            //                if (tmpLen > Convert.ToInt32(MsgBitMap.BitMap[i, 1]))
            //                {
            //                    //从开始位置截取变量，变量长度不允许大于最大长度
            //                    curData = CommomFunctions.GetLenStr(curData,
            //                                                        Convert.ToInt32(MsgBitMap.BitMap[i, 1]),
            //                                                        false);
            //                }
            //                //生成当前域内容
            //                curData = tmpLen.ToString().PadLeft(Convert.ToInt16(length), '0') + curData;
            //            }
            //            break;
            //        }
            //}

            //return returnStr;
            #endregion

            #region 新的处理方法
            var result = string.Empty;
            var fdName = i.ToString().PadLeft(3, '0') + "0";
            if (!msg.BitMapInstance.FdBitMap.ContainsKey(fdName))
                throw new ArgumentOutOfRangeException(string.Format("Fd报文定义集合中未找到Code等于[{0}]的域定义！", fdName));
            var fdItem = msg.BitMapInstance.FdBitMap[fdName];

            if (fdItem.Children == null || fdItem.Children.Count == 0)
            {
                //无子域
                result = msg.GetFdFormatValue(fdItem.Code);
            }
            else
            {
                //有子域，子域暂时只存在定长域
                var child = new StringBuilder();
                foreach (var item in fdItem.Children)
                {
                    child.Append(msg.GetFdFormatValue(item.Code));
                }
                result = child.ToString();
            }
            switch (fdItem.FieldType)
            {
                case "-1":
                    {
                        //不使用该域
                        result = string.Empty;
                        break;
                    }
                case "0":
                    {
                        //定长域
                        //判断长度，暂时不考虑子域合集长度与大域长度不一致的情况
                        break;
                    }
                default:
                    {
                        //变长域
                        var len = int.Parse(fdItem.FieldType);
                        var data = PlatformSettings.Encoding.GetBytes(result);
                        if (data.Length > 0)
                        {
                            if (data.Length > fdItem.Length)
                            {
                                byte[] tmp = new byte[fdItem.Length];
                                Array.Copy(data, tmp, fdItem.Length);
                                data = tmp;
                            }
                            var length = data.Length.ToString().PadLeft(len, '0');
                            result = length + PlatformSettings.Encoding.GetString(data);
                        }
                        break;
                    }
            }
            //组装返回域内容和日志信息
            curData = result;
            return string.Format("FD{0}:[{1}]", fdItem.Code, result);
            #endregion
        }

        #endregion

        #region 解包处理

        /// <summary>
        /// 解包操作
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="returnData"></param>
        /// <returns></returns>
        public void DoAnalyze(Message msg, byte[] returnData)
        {
            try
            {
                //报文前68位内容       
                byte[] msg68 = new byte[71];
                string msgStr68 = "";
                //报文总长度
                int msgTotalLen = 0;
                //报文数据区长度        
                int msgDataLen = 0;
                //报文数据区内容
                byte[] msgData;
                //报文有效数据内容
                byte[] msgDataReal;
                //报文位图区
                byte[] msgBit;
                string msgBitStr = "";
                //报文前68位（8位报文长度+60位报文头）
                for (int i = 0; i < 71; i++)
                {
                    msg68[i] = returnData[i];
                }
                //报文前68位字符串内容
                msgStr68 = PlatformSettings.Encoding.GetString(msg68);
                //报文总长度              
                msgTotalLen = Convert.ToInt32(msgStr68.Substring(0, 8));
                //报文有效数据内容长度
                msgDataLen = msgTotalLen - 63;
                //取得报文数据区内容
                msgData = new byte[msgDataLen];
                Array.Copy(returnData, 71, msgData, 0, msgTotalLen - 63);

                //文件标志
                //byte fileDataFlag = returnData[msgTotalLen + 8];

                #region delete 解包封装
                ////报文数据区格式为 5位报文类型+16位位图区域+有效数据区
                ////报文位图区
                //msgBit = new byte[16];
                //Array.Copy(msgData, 5, msgBit, 0, 16);
                ////扩展16位字符串转换为128位01格式的位图字符串
                //foreach (byte bytes in msgBit)
                //{
                //    msgBitStr += Convert.ToString(bytes, 2).PadLeft(8, '0');
                //}
                ////写调试日志
                ////MsgPackage.LogObj.Debug("\n位图:\n" + msgBitStr);
                //PlatformLogger.CommunicationInfo("\n位图:\n" + msgBitStr);
                ////报文数据内容
                //msgDataReal = new byte[msgDataLen - 21];
                //Array.Copy(msgData, 21, msgDataReal, 0, msgDataLen - 21);
                ////写调试日志
                ////MsgPackage.LogObj.Debug("数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal));
                //PlatformLogger.CommunicationInfo("数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal));
                ////详细解析每个域的信息
                ////Message tmpMsg = AnilyzeFd(msgBitStr, msgDataReal);
                //if (!msg.AnilyzeFd(msgBitStr, msgDataReal))
                //{
                //    //解包失败
                //    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
                //}
                if (!msg.AnilyzeFd(msgData))
                {
                    //解包失败
                    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
                }
                #endregion

                //将解析后结果复制到当前交易对象中
                //MsgPackage.Clone(msg, tmpMsg);
                //有文件附件的处理
                //if (fileDataFlag == 0x7f)
                //{
                //    //取得文件长度
                //    //文件部分的格式为：30位的文件名+8位的文件长度+文件内容
                //    Int64 fileLen = returnData.Length - msgTotalLen - 9 - 30 - 8;
                //    //报文文件内容               
                //    byte[] fileData = new byte[fileLen];
                //    Array.Copy(returnData, msgTotalLen + 47, fileData, 0, fileLen);
                //    //返回解包后文件数据
                //    msg.FileData = PlatformSettings.Encoding.GetString(fileData);
                //    //写调试日志
                //    //MsgPackage.LogObj.Debug("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
                //    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
                //}
            }
            catch (Exception ex)
            {
                //写错误信息
                //MsgPackage.LogObj.Error(ex.Message);
                PlatformLogger.SystemErrorInfo("报文解包出现异常！", ex);
                throw;
            }
        }

        #region 解包域数据部分将封装到Message对象中去
        ///// <summary>
        ///// 解析数据域详细数据
        ///// </summary>
        ///// <param name="bitMapValue"></param>
        ///// <param name="data"></param>
        ///// <returns></returns>
        //private Message AnilyzeFd(string bitMapValue, byte[] data)
        //{
        //    Int64 curPosition = 0;
        //    //临时数据存储对象
        //    Message tmpMsg = new Message();
        //    //MsgBitMap msgBitMap = new MsgBitMap();
        //    string[,] bitMap;
        //    StringBuilder logStr = new StringBuilder();
        //    try
        //    {
        //        for (int i = 0; i < bitMapValue.Length; i++)
        //        {
        //            if (bitMapValue[i] == '1')
        //            {
        //                //第一位为标志位
        //                if (i + 1 == 1)
        //                {
        //                    continue;
        //                }

        //                #region 旧的处理方案
        //                ////当前域的类型
        //                //string length = MsgBitMap.BitMap[i, 0];
        //                ////取得当前域的数据内容
        //                //string tmpStr01 = "Fd" + Convert.ToString(i + 1);
        //                //string tmpStr02 = "Bit" + Convert.ToString(i + 1);
        //                //switch (length)
        //                //{
        //                //    //停用
        //                //    case "-1":
        //                //        {
        //                //            break;
        //                //        }
        //                //    //定长
        //                //    case "0":
        //                //        {
        //                //            Int64 tmpLen = Convert.ToInt64(MsgBitMap.BitMap[i, 1]);
        //                //            //初始化字节数组
        //                //            byte[] tmpData = new byte[tmpLen];
        //                //            //取得当前域字节数据
        //                //            for (int n = 0; n < tmpLen; n++)
        //                //            {
        //                //                tmpData[n] = data[curPosition + n];
        //                //            }
        //                //            //新位置
        //                //            curPosition = curPosition + tmpLen;

        //                //            //无子域))
        //                //            if (MsgBitMap.BitMap[i, 3] == "0")
        //                //            {
        //                //                tmpMsg.GetType().GetProperty(tmpStr01).SetValue(tmpMsg,
        //                //                                                             Encoding.GetEncoding(
        //                //                                                                 CommonParames.Coding).GetString(
        //                //                                                                     tmpData), null);
        //                //                //日志信息
        //                //                logStr.Append(tmpStr01 + ":[" + Encoding.GetEncoding(
        //                //                    CommonParames.Coding).GetString(
        //                //                        tmpData) + "]\n");
        //                //            }
        //                //            //有子域
        //                //            else if (MsgBitMap.BitMap[i, 3] == "1")
        //                //            {
        //                //                //取得0子域的数据
        //                //                string tmpStr01Sub0 = tmpStr01 + "_" + "".PadLeft(2, '0');
        //                //                tmpMsg.GetType().GetProperty(tmpStr01Sub0).SetValue(tmpMsg,
        //                //                                                             Encoding.GetEncoding(
        //                //                                                                 CommonParames.Coding).GetString(
        //                //                                                                     tmpData), null);
        //                //                //日志信息
        //                //                logStr.Append(tmpStr01Sub0 + ":[" + Encoding.GetEncoding(
        //                //                    CommonParames.Coding).GetString(
        //                //                        tmpData) + "]\n");

        //                //                Int64 tempPosition = 0;
        //                //                bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
        //                //                for (int j = 0; j < (bitMap.Length / 3); j++)
        //                //                {
        //                //                    //定长
        //                //                    if (bitMap[j, 0] == "0")
        //                //                    {
        //                //                        //取得当前子域的数据
        //                //                        string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');

        //                //                        byte[] tmpCurData = new byte[Convert.ToInt64(bitMap[j, 1])];
        //                //                        Array.Copy(tmpData, tempPosition, tmpCurData, 0,
        //                //                                   Convert.ToInt64(bitMap[j, 1]));
        //                //                        //给对应子域赋值
        //                //                        tmpMsg.GetType().GetProperty(tmpStr01Sub).SetValue(tmpMsg,
        //                //                                                                     Encoding.GetEncoding(
        //                //                                                                         CommonParames.Coding).
        //                //                                                                         GetString(tmpCurData), null);
        //                //                        //日志信息
        //                //                        logStr.Append(tmpStr01Sub + ":[" + Encoding.GetEncoding(
        //                //                                                                         CommonParames.Coding).
        //                //                                                                         GetString(tmpCurData) + "]\n");

        //                //                        tempPosition += Convert.ToInt64(bitMap[j, 1]);

        //                //                    }
        //                //                    //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
        //                //                    else
        //                //                    {
        //                //                    }
        //                //                }
        //                //            }
        //                //            break;
        //                //        }
        //                //    //变长
        //                //    default:
        //                //        {
        //                //            //获取变长长度
        //                //            Int32 tmpLen = Convert.ToInt32(MsgBitMap.BitMap[i, 0]);
        //                //            //初始化字节数组
        //                //            byte[] tmpData = new byte[tmpLen];
        //                //            //取得当前域字节数据
        //                //            for (int n = 0; n < tmpLen; n++)
        //                //            {
        //                //                tmpData[n] = data[curPosition + n];
        //                //            }
        //                //            //新位置
        //                //            curPosition = curPosition + tmpLen;

        //                //            tmpLen = Convert.ToInt32(CommomFunctions.NVL(PlatformSettings.Encoding.GetString(tmpData), 0));
        //                //            //初始化字节数组
        //                //            tmpData = new byte[tmpLen];
        //                //            //取得当前域字节数据
        //                //            for (int m = 0; m < tmpLen; m++)
        //                //            {
        //                //                tmpData[m] = data[curPosition + m];
        //                //            }
        //                //            //新位置
        //                //            curPosition = curPosition + tmpLen;

        //                //            //无子域))
        //                //            if (MsgBitMap.BitMap[i, 3] == "0")
        //                //            {
        //                //                tmpMsg.GetType().GetProperty(tmpStr01).SetValue(tmpMsg,
        //                //                                                             Encoding.GetEncoding(
        //                //                                                                 CommonParames.Coding).GetString(
        //                //                                                                     tmpData), null);
        //                //                //日志信息
        //                //                logStr.Append(tmpStr01 + ":[" + Encoding.GetEncoding(
        //                //                    CommonParames.Coding).GetString(
        //                //                        tmpData) + "]\n");
        //                //            }
        //                //            //有子域
        //                //            else if (MsgBitMap.BitMap[i, 3] == "1")
        //                //            {
        //                //                //取得0子域的数据
        //                //                string tmpStr01Sub0 = tmpStr01 + "_" + "".PadLeft(2, '0');
        //                //                tmpMsg.GetType().GetProperty(tmpStr01Sub0).SetValue(tmpMsg,
        //                //                                                             Encoding.GetEncoding(
        //                //                                                                 CommonParames.Coding).GetString(
        //                //                                                                     tmpData), null);
        //                //                //日志信息
        //                //                logStr.Append(tmpStr01Sub0 + ":[" + Encoding.GetEncoding(
        //                //                    CommonParames.Coding).GetString(
        //                //                        tmpData) + "]\n");

        //                //                Int64 tempPosition = 0;
        //                //                bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
        //                //                for (int j = 0; j < (bitMap.Length / 3); j++)
        //                //                {
        //                //                    //定长
        //                //                    if (bitMap[j, 0] == "0")
        //                //                    {
        //                //                        //取得当前子域的数据
        //                //                        string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');

        //                //                        byte[] tmpCurData = new byte[Convert.ToInt64(bitMap[j, 1])];
        //                //                        //当前域数据长度不够定长子域的长度时执行
        //                //                        if ((tmpData.Length - tempPosition) < tmpCurData.Length)
        //                //                        {
        //                //                            break;
        //                //                        }
        //                //                        Array.Copy(tmpData, tempPosition, tmpCurData, 0,
        //                //                                   Convert.ToInt64(bitMap[j, 1]));
        //                //                        //给对应子域赋值
        //                //                        tmpMsg.GetType().GetProperty(tmpStr01Sub).SetValue(tmpMsg,
        //                //                                                                     Encoding.GetEncoding(
        //                //                                                                         CommonParames.Coding).
        //                //                                                                         GetString(tmpCurData), null);
        //                //                        //日志信息
        //                //                        logStr.Append(tmpStr01Sub + ":[" + Encoding.GetEncoding(
        //                //                                                                         CommonParames.Coding).
        //                //                                                                         GetString(tmpCurData) + "]\n");

        //                //                        tempPosition += Convert.ToInt64(bitMap[j, 1]);
        //                //                    }
        //                //                    //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
        //                //                    else
        //                //                    {
        //                //                    }
        //                //                }
        //                //            }
        //                //            break;
        //                //        }
        //                //}
        //                #endregion

        //                #region 新的处理方案
        //                var fdName = (i + 1).ToString().PadLeft(3, '0') + "0";
        //                if (!MsgBitMap.Instance.FdBitMap.ContainsKey(fdName))
        //                {
        //                    continue;
        //                }
        //                var item = MsgBitMap.Instance.FdBitMap[fdName];
        //                switch (item.FieldType)
        //                {
        //                    case "-1":
        //                        {
        //                            break;
        //                        }
        //                    case "0":
        //                        {
        //                            //定长域
        //                            var tmp = new byte[item.Length];
        //                            //截取数据区域，判定新位置
        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
        //                            curPosition = curPosition + tmp.Length;

        //                            if (item.Children == null || item.Children.Count == 0)
        //                            {
        //                                tmpMsg.SetFdValue(item.Code, PlatformSettings.Encoding.GetString(tmp));
        //                            }
        //                            else
        //                            {
        //                                //循环给子域赋值，子域暂时只存在定长域
        //                                int index = 0;
        //                                foreach (var child in item.Children)
        //                                {
        //                                    //子域为定长
        //                                    var childData = new byte[child.Length];
        //                                    Array.Copy(tmp, index, childData, 0, childData.Length);
        //                                    index += childData.Length;
        //                                    tmpMsg.SetFdValue(child.Code, PlatformSettings.Encoding.GetString(childData));
        //                                }
        //                            }
        //                            break;
        //                        }
        //                    default:
        //                        {
        //                            //变长域
        //                            //获取数据长度
        //                            var len = int.Parse(item.FieldType);
        //                            var tmp = new byte[len];
        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
        //                            curPosition = curPosition + tmp.Length;
        //                            //获取数据部分
        //                            var length = int.Parse(PlatformSettings.Encoding.GetString(tmp));
        //                            tmp = new byte[length];
        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
        //                            curPosition = curPosition + tmp.Length;

        //                            if (item.Children == null || item.Children.Count == 0)
        //                            {
        //                                tmpMsg.SetFdValue(item.Code, PlatformSettings.Encoding.GetString(tmp));
        //                            }
        //                            else
        //                            {
        //                                //循环给子域赋值，子域暂时只存在定长域
        //                                int index = 0;
        //                                foreach (var child in item.Children)
        //                                {
        //                                    //子域为定长
        //                                    var childData = new byte[child.Length];
        //                                    Array.Copy(tmp, index, childData, 0, childData.Length);
        //                                    index += childData.Length;
        //                                    tmpMsg.SetFdValue(child.Code, PlatformSettings.Encoding.GetString(childData));
        //                                }
        //                            }
        //                            break;
        //                        }
        //                }
        //                #endregion
        //            }
        //        }
        //    }
        //    catch (Exception)
        //    {
        //        //解包出错时将已经解析的数据域写入交易日志文件
        //        //MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
        //        PlatformLogger.CommunicationInfo("\n应答数据:\n" + logStr.ToString());
        //        throw;
        //    }
        //    //解包完成后将解析数据写入交易日志文件
        //    //MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
        //    PlatformLogger.CommunicationInfo("\n应答数据:\n" + logStr.ToString());
        //    return tmpMsg;
        //}
        #endregion
        #endregion

    }

}
