using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Platform.Common;
using Platform.Common.RunningParameters;
using Platform.Common.LogSystem;

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

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

            try
            {
                returnData = DoIntegrate(msg);
            }
            catch (Exception ex)
            {
                //写错误信息
                PlatformLogger.SystemErrorInfo("组包发生异常：", ex);
                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)
        {
            #region new
            ///*******************************************
            // * 组包规则：
            // * msgHeader         byte[68]   Tuxedo报文头
            // * msgData           byte[]     报文数据
            // * fileFlag          byte       是否发送附件 
            // * *****************************************/

            ////文件标志
            //byte fileFlag = (byte)(msg.FileFlag ? 0x7f : 0xff);
            ////报文数据
            //byte[] bitMapData;
            //var fdData = msg.IntegrateFd(out bitMapData);
            //byte[] msgKindData = PlatformSettings.Encoding.GetBytes(MsgParames.MsgType.PadLeft(5, '0'));
            //var msgData = new byte[msgKindData.Length + bitMapData.Length + fdData.Length];
            //msgKindData.CopyTo(msgData, 0);
            //bitMapData.CopyTo(msgData, msgKindData.Length);
            //fdData.CopyTo(msgData, msgKindData.Length + bitMapData.Length);
            ////加密报文数据
            //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(MsgParames.KeyStr), 1);
            ////报文头
            //var msgHeader = GetMsgT(msg, msgData.Length.ToString()).ToArray<byte>();
            ////组装报文
            //var totalData = new byte[msgHeader.Length + msgData.Length + 1];
            //msgHeader.CopyTo(totalData, 0);
            //msgData.CopyTo(totalData, msgHeader.Length);
            //totalData[totalData.Length - 1] = fileFlag;

            //return totalData;
            #endregion


            #region deleted
            //报文数据区
            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("00001");
                //组织报文数据区域信息，位图区，数据区
                //GetBitData(msg, bitMapByte, ref bitDataStr);
                //bitDataByte = PlatformSettings.Encoding.GetBytes(bitDataStr);
                bitDataByte = msg.IntegrateFd(out bitMapByte);

                //报文数据区长度
                msgDataLen = msgKindByte.Length + bitMapByte.Length + bitDataByte.Length;
                //报文总长度
                totalLen = msgDataLen + 68;
                //8位长度对应字符串
                strLen = Convert.ToString(totalLen).PadLeft(8, '0');
                //60位报文头
                msgTitle = GetMsgT(msg, msgDataLen.ToString());

                //合并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];
                    }
                }

                //MsgPackage.LogObj.Debug("加密前数据："+PlatformSettings.Encoding.GetString(msgData));
                //加密报文数据区
                MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr), 1);
                //MsgPackage.LogObj.Debug("加密后数据：" + PlatformSettings.Encoding.GetString(msgData));

                //合并组包数据
                //tuxedo报文头前面没有8位的报文长度
                byte[] len8 = new byte[0];
                //报文头字节数组
                byte[] msgTitleByte = PlatformSettings.Encoding.GetBytes(msgTitle);
                totalMsgData = new byte[len8.Length + msgTitleByte.Length + msgData.Length + 1];
                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;
                //MsgPackage.LogObj.Debug("报文整体数据：" + PlatformSettings.Encoding.GetString(totalMsgData));
            }
            catch (Exception ex)
            {
                //写错误信息
                PlatformLogger.SystemErrorInfo("组包发生异常！", ex);
                throw;
            }
            return totalMsgData;
            #endregion
        }

        /// <summary>
        /// 生成TUXEDO方式报文头
        /// </summary>
        /// <param name="msg">域信息</param>
        /// <param name="msgDataLen"></param>
        /// <returns></returns>
        private string GetMsgT(Message msg, string msgDataLen)
        {
            string clnm = "";                 //5位   空串
            string svcnm = "";                //15位  Tuxedo交易服务名
            string reqtype = "";              //1位   "4"
            string branchNo = "";             //5位   机构编号
            string tty = "";                  //9位   终端号
            string titaOr8583;                //1位   代码中的值 8’
            string cbs = "";                  //10位  空串
            string macflg = "";               //1位   空串
            string mac = "";                  //8位   空串
            string result = "";               //1位   '0'
            string len = "";                  //4位   8583数据区长度
            //TUXEDO方式报文头
            StringBuilder tmpMstTile = new StringBuilder();

            //设置对应变量的值
            clnm = "".PadLeft(5, ' ');
            tmpMstTile.Append(clnm);
            svcnm = "".PadLeft(15, ' ');
            tmpMstTile.Append(svcnm);
            reqtype = "4";
            tmpMstTile.Append(reqtype);
            //TODO:机构号扩展为10位，故报文大小变成68
            branchNo = msg.Fd3.PadLeft(10, ' ');
            tmpMstTile.Append(branchNo);
            //TODO:由于tty采用12位，故修改为12位（保证核心已经修改）
            //tty = msg.Fd10.PadLeft(9, ' ');
            tty = msg.Fd10.PadLeft(12, ' ');
            tmpMstTile.Append(tty);
            titaOr8583 = "8";
            tmpMstTile.Append(titaOr8583);
            cbs = "".PadLeft(10, ' ');
            tmpMstTile.Append(cbs);
            macflg = "".PadLeft(1, ' ');
            tmpMstTile.Append(macflg);
            mac = "".PadLeft(8, ' ');
            tmpMstTile.Append(mac);
            result = "0";
            tmpMstTile.Append(result);
            len = msgDataLen.PadLeft(4, '0');
            tmpMstTile.Append(len);

            return tmpMstTile.ToString();
        }

        #region 组包数据部分操作将封装到Message对象中
        ///// <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 = "";
        //            //取得当前域的数据
        //            var fdLogInfo = GetBitItemData(msg, i + 1, ref curData);
        //            //处理当前域位图信息
        //            //当前域值不为空时，对应位图为1.
        //            if (curData != "")
        //            {
        //                logStr.AppendLine(fdLogInfo);
        //                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("请求位图：" + bitStr);
        //        //写报文数据信息
        //        MsgPackage.LogObj.Info("\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)
        //    {
        //        //写错误信息
        //        MsgPackage.LogObj.Error(ex.Message);
        //        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 (!MsgBitMap.FdBitMap.ContainsKey(fdName))
        //        throw new ArgumentOutOfRangeException(string.Format("Fd报文定义集合中未找到Code等于[{0}]的域定义！", fdName));
        //    var fdItem = MsgBitMap.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
        #endregion

        #region 解包处理

        /// <summary>
        /// 解包操作
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="returnData"></param>
        /// <returns></returns>
        public void DoAnalyze(Message msg, byte[] returnData)
        {
            try
            {
                //报文前68位内容       
                byte[] msg60 = new byte[68];
                //报文数据区长度        
                int msgDataLen = 0;
                //报文数据区内容
                byte[] msgData;
                //报文有效数据内容
                byte[] msgDataReal;
                //报文位图区
                byte[] msgBit;
                string msgBitStr = "";

                //报文前60位（60位报文头）
                for (int i = 0; i < 68; i++)
                {
                    msg60[i] = returnData[i];
                }

                //报文数据区长度 
                byte[] tmpLen = new byte[4];
                Array.Copy(msg60, 64, tmpLen, 0, 4);
                msgDataLen = Convert.ToInt32(PlatformSettings.Encoding.GetString(tmpLen));

                //报文前60位字符串内容
                //MsgStr60 = Encoding.GetEncoding(CAppInfo.CodingStr).GetString(Msg60);

                //如果报文数据区第五位为0xff
                //总共报文数据区为4位应答码.
                if (returnData[72] == (byte)'\0')
                {
                    //应答码错误信息
                    byte[] tmpData = new byte[4];
                    //取得应答码错误信息内容
                    Array.Copy(returnData, 68, tmpData, 0, 4);
                    //返回应答码
                    msg.Fd12 = PlatformSettings.Encoding.GetString(tmpData);
                    return;
                }
                //取得报文数据区内容
                msgData = new byte[msgDataLen];
                Array.Copy(returnData, 68, msgData, 0, msgDataLen);
                //文件标志
                byte fileDataFlag = returnData[20];
                //解密数据区内容
                MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr),
                                   0);
                #region delete 解包封装
                ////报文数据区格式为 5位报文类型+16位位图区域+有效数据区
                ////报文位图区
                ////报文位图区存在2种情况，当位图区第1域为0时，位图长度为64（压缩为8位数据），否则为128（压缩为16位数据）
                ////标志位，是否采用128位位图
                //bool IsBitmap128 = Convert.ToString(msgData[5], 2).PadLeft(8, '0').StartsWith("1");

                //msgBit = new byte[IsBitmap128 ? 16 : 8];
                //Array.Copy(msgData, 5, msgBit, 0, msgBit.Length);
                ////扩展16位字符串转换为128位01格式的位图字符串
                //foreach (byte bytes in msgBit)
                //{
                //    msgBitStr += Convert.ToString(bytes, 2).PadLeft(8, '0');
                //}
                ////写调试日志
                ////MsgPackage.LogObj.Debug("\n返回位图:\n" + msgBitStr.Replace('\0', '\n'));
                ////报文数据内容
                //int startIndex = 5 + (IsBitmap128 ? 16 : 8);
                //msgDataReal = new byte[msgDataLen - startIndex];
                //Array.Copy(msgData, startIndex, msgDataReal, 0, msgDataReal.Length);
                ////写调试日志
                ////MsgPackage.LogObj.Debug("\n解包前应答数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal).Replace('\0', '\n'));

                ////详细解析每个域的信息
                ////Message tmpMsg = AnilyzeFd(msgBitStr, msgDataReal, msg);
                //if (!msg.AnilyzeFd(msgBitStr, msgDataReal))
                //{
                //    //解包失败
                //    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
                //}
                if (!msg.AnilyzeFd(msgData))
                {
                    //解包失败
                    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
                }
                #endregion
                //将解析后结果复制到当前交易对象中
                //MsgPackage.Clone(msg, tmpMsg);
                //有文件附件的处理
                if (fileDataFlag == (byte)57)
                {
                    //取得文件长度
                    //文件部分的格式为：tuxedo文件头长度为152
                    Int64 fileLen = returnData.Length - msgDataLen - 152 - 68;
                    //报文文件内容               
                    byte[] fileData = new byte[fileLen];
                    Array.Copy(returnData, msgDataLen + 220, fileData, 0, fileLen);
                    //返回解包后文件数据
                    msg.FileData = Message.Cconv(PlatformSettings.Encoding.GetString(fileData), false);//生僻字转义：文件解包处理
                    //写调试日志
                    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
                }
            }
            catch (Exception ex)
            {
                //写错误信息
                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, Message tmpMsg)
        //{
        //    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.FdBitMap.ContainsKey(fdName))
        //                {
        //                    continue;
        //                }
        //                var item = MsgBitMap.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;

        //                            //记录日志
        //                            var value = PlatformSettings.Encoding.GetString(tmp);
        //                            logStr.AppendLine(string.Format("FD{0}:[{1}]", item.Code, value));

        //                            if (item.Children == null || item.Children.Count == 0)
        //                            {
        //                                tmpMsg.SetFdValue(item.Code, value);
        //                            }
        //                            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;

        //                            //记录日志
        //                            var value = PlatformSettings.Encoding.GetString(tmp);
        //                            logStr.AppendLine(string.Format("FD{0}:[{1}]", item.Code, value));

        //                            if (item.Children == null || item.Children.Count == 0)
        //                            {
        //                                tmpMsg.SetFdValue(item.Code, value);
        //                            }
        //                            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 ex)
        //    {
        //        //写错误信息
        //        MsgPackage.LogObj.Error(ex.Message);
        //        //解包出错时将已经解析的数据域写入交易日志文件
        //        MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
        //        throw;
        //    }
        //    //解包完成后将解析数据写入交易日志文件
        //    MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
        //    return tmpMsg;
        //}
        #endregion
        #endregion

    }
}
