using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using LYFZ.Network.EnumerateLibrary;

namespace LYFZ.Network
{
    /// <summary>
    /// 远程数据处理类 被动模式
    /// </summary>
    public class TCP_RemoteDataHandlerPassiveMode
    {
       

        #region 服务端接收到客户端指令后的处理程序

        public TCP_RemoteDataHandlerPassiveMode()
        {

        }
        HPSocketCS.TcpPackClient hpClient;
        /// <summary>
        /// 新的网络对象
        /// </summary>
        public HPSocketCS.TcpPackClient HpClient
        {
            get { return hpClient; }
            set { hpClient = value; }
        }
        public TCP_RemoteDataHandlerPassiveMode(HPSocketCS.TcpPackClient client)
        {
            this.hpClient = client;


        }


        static string _ServerBasePath = LYFZ.WinAPI.CustomPublicMethod.BasePath;
        /// <summary>
        /// 服务器端根目录
        /// </summary>
        public static string ServerBasePath
        {
            get { return _ServerBasePath; }
            set { _ServerBasePath = value; }
        }
        /// <summary>
        /// 获取客户端发送的参数
        /// </summary>
        /// <param name="ParametersString"></param>
        /// <returns></returns>
        string[] GetParameters(string ParametersString)
        {
            string[] mParameters = ParametersString.Split('|');
            return mParameters;
        }

        static string BackupRecordsDateDay = "";
        static string BackupRecordsStringText = "";



        /// <summary>
        /// 获取备份记录
        /// </summary>
        /// <param name="protocol"></param>
        /// <returns></returns>
        public TCP_FileProtocol GetBackupRecords(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            returnProtocol = GetToClientFileProtocol("GetOK&"+false.ToString());
            if (BackupRecordsDateDay == DateTime.Now.ToString("yyyy-MM-dd"))
            {
                returnProtocol = GetToClientFileProtocol(BackupRecordsStringText);
            }
            else
            {
                try
                {

                    string BackupRecordsDir = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath(LYFZ.WinAPI.CustomPublicMethod.BasePath) + "DB\\BackupRecords\\";

                    string PhotoBackupRecordsPath = BackupRecordsDir + "PhotoBackupRecords.txt";//相片

                    

                    //相片备份记录
                    string PhotoBackupRecords = "";
                    string PhotoBackupRecordsText = "";
                    if (System.IO.File.Exists(PhotoBackupRecordsPath))
                    {
                        PhotoBackupRecordsText = System.IO.File.ReadAllText(PhotoBackupRecordsPath, Encoding.UTF8);
                    }
                    bool isBackupOK = true;
                    for (int i = 1; i <= 7; i++)
                    {

                        string tempBackupText = "OK|";
                        if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|原片|备份成功|"))
                        {
                            if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|原片|备份成功|已备份到:"))
                            {
                                tempBackupText = "OK|";
                            }
                            else
                            {
                                tempBackupText = "No|";
                            }
                            PhotoBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|原片|备份成功|" + tempBackupText + "#";
                           
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }
                        if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|初修片|备份成功|"))
                        {
                            if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|初修片|备份成功|已备份到:"))
                            {
                                tempBackupText = "OK|";
                            }
                            else
                            {
                                tempBackupText = "No|";
                            }
                            PhotoBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|初修片|备份成功|" + tempBackupText + "#";
                            
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }
                        if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|精修片|备份成功|"))
                        {
                            if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|精修片|备份成功|已备份到:"))
                            {
                                tempBackupText = "OK|";
                            }
                            else
                            {
                                tempBackupText = "No|";
                            }
                            PhotoBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|精修片|备份成功|" + tempBackupText + "#";
                            
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }
                        if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|设计片|备份成功|"))
                        {
                            if (PhotoBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|设计片|备份成功|已备份到:"))
                            {
                                tempBackupText = "OK|";
                            }
                            else
                            {
                                tempBackupText = "No|";
                            }
                            PhotoBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|设计片|备份成功|" + tempBackupText + "#";
                            
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }
                    }

                    returnProtocol = GetToClientFileProtocol("GetOK&"+isBackupOK.ToString() +  "&" + PhotoBackupRecords);
                    BackupRecordsDateDay = DateTime.Now.ToString("yyyy-MM-dd");
                    BackupRecordsStringText = returnProtocol.Content;
                }
                catch { }
            }
            return returnProtocol;
        }

        static string MainShopBackupRecordsDateDay = "";
        static string MainShopBackupRecordsStringText = "";

        /// <summary>
        /// 获取总店数据库备份记录
        /// </summary>
        /// <param name="protocol"></param>
        /// <returns></returns>
        public TCP_FileProtocol GetMainShopBackupRecords(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            returnProtocol = GetToClientFileProtocol("GetOK&" + false.ToString());
           /* if (MainShopBackupRecordsDateDay == DateTime.Now.ToString("yyyy-MM-dd"))
            {
                returnProtocol = GetToClientFileProtocol(MainShopBackupRecordsStringText);
            }
            else*/
            {
                try
                {
                  

                    string BackupRecordsDir = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath(LYFZ.WinAPI.CustomPublicMethod.BasePath) + "DB\\BackupRecords\\";
                    string DataBaseBackupRecordsPath = BackupRecordsDir + "DataBaseBackupRecords.txt";//数据库

                    string DataFileBackupRecordsPath = BackupRecordsDir + "DataFileBackupRecords.txt";//资料文件

                    //资料文件备份记录
                    string DataFileBackupRecords = "";
                    string DataFileBackupRecordsText = "";
                    if (System.IO.File.Exists(DataFileBackupRecordsPath))
                    {
                        DataFileBackupRecordsText = System.IO.File.ReadAllText(DataFileBackupRecordsPath, Encoding.UTF8);

                    }
                   
                    //数据库备份记录信息
                    string DataBaseBackupRecords = "";

                    string DataBaseBackupRecordsText = "";
                    if (System.IO.File.Exists(DataBaseBackupRecordsPath))
                    {
                        DataBaseBackupRecordsText = System.IO.File.ReadAllText(DataBaseBackupRecordsPath, Encoding.UTF8);
                    }

                   
                    bool isBackupOK = true;
                    for (int i = 1; i <= 7; i++)
                    {
                        if (DataBaseBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|数据库|备份成功|"))
                        {
                            DataBaseBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|数据库|备份成功|#";
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }

                        if (DataFileBackupRecordsText.Contains(DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|资料文件|备份成功|"))
                        {
                            DataFileBackupRecords += DateTime.Now.AddDays(-i).ToString("yyyy-MM-dd") + "|资料文件|备份成功|#";
                        }
                        else
                        {
                            if (i == 1)
                            {
                                isBackupOK = false;
                            }
                        }

                    }

                    returnProtocol = GetToClientFileProtocol("GetOK&" + isBackupOK.ToString() + "&" + DataBaseBackupRecords+"&" + DataFileBackupRecords);
                    MainShopBackupRecordsDateDay = DateTime.Now.ToString("yyyy-MM-dd");
                    MainShopBackupRecordsStringText = returnProtocol.Content;
                }
                catch { }
            }
            return returnProtocol;
        }
        
       



       


        /// <summary>
        /// 获取返回到客户端的TCP_FileProtocol对象
        /// </summary>
        /// <param name="value">要返回的内容</param>
        /// <param name="extraInfo">附加信息</param>
        /// <returns></returns>
        public TCP_FileProtocol GetToClientFileProtocol(string value, string extraInfo = "")
        {
            return new Network.TCP_FileProtocol(value, extraInfo);
        }

        #region 服务器端命令处理方法
      
        public static string _UserAvatarSaveFilePath = "";
        /// <summary>
        /// 服务器端用户头像保存目录
        /// </summary>
        public static string UserAvatarSaveFilePath
        {
            get { return ServerBasePath + "\\Resources\\Avatar\\User\\"; }
            set { _UserAvatarSaveFilePath = value; }
        }


        /// <summary>
        /// 删除服务器上的文件
        /// </summary>
        /// <returns></returns>
        public TCP_FileProtocol DeleteFile(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();

            string[] tempValues = protocol.Content.Split('?');
            string[] delFiles = tempValues[0].Split('|');

            //服务器端文件路径
            string saveFilePath = "";

            try
            {
                foreach (string delfile in delFiles)
                {
                    if (delfile.Trim().Length > 0)
                    {
                        saveFilePath = delfile;
                        if (delfile.Contains(":"))
                        {
                            saveFilePath = delfile;
                        }
                        else
                        {
                            saveFilePath = ServerBasePath + "\\" + delfile.TrimStart('\\');
                        }
                        if (System.IO.File.Exists(saveFilePath))
                        {
                            System.IO.File.Delete(saveFilePath);
                        }
                    }
                }
                returnProtocol = GetToClientFileProtocol("删除成功");
                //  returnProtocol = GetToClientFileProtocol("删除失败,服务器上找不到“" + protocol.FileName + "”文件!");

            }
            catch (Exception ex)
            {
                returnProtocol = GetToClientFileProtocol("删除失败,原因：“" + ex.Message + "”");
            }

            return returnProtocol;
        }

        /// <summary>
        /// 获取服务器上指定目录下的文件列表
        /// </summary>
        /// <returns></returns>
        public TCP_FileProtocol GeTFileList(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            string[] Parameters = protocol.Content.Split('|');
            if (Parameters.Length >= 3)
            {
                string dirPath = Parameters[0];
                if (!dirPath.Contains(":"))
                {
                    dirPath = ServerBasePath + "\\" + dirPath.TrimStart('\\');
                }
                bool isSearchSubfolder = false;//是否搜索子目录
                try
                {
                    isSearchSubfolder = Convert.ToBoolean(Parameters[1]);
                }
                catch { }
                string searchPattern = Parameters[2];
                
                    try
                    {
                        if (System.IO.Directory.Exists(dirPath))
                        {
                            string[] retFiles = null;
                            if (isSearchSubfolder)
                            {
                                retFiles = System.IO.Directory.GetFiles(dirPath, searchPattern, SearchOption.AllDirectories);
                            }
                            else
                            {
                                retFiles = System.IO.Directory.GetFiles(dirPath, searchPattern, SearchOption.TopDirectoryOnly);
                            }
                            StringBuilder retFilesString = new StringBuilder();
                            foreach (string file in retFiles)
                            {
                                retFilesString.Append(file.Replace(ServerBasePath, "") + "|");
                            }
                            returnProtocol = GetToClientFileProtocol("获取成功", retFilesString.ToString());
                            retFilesString.Clear();
                        }
                        else
                        {
                            returnProtocol = GetToClientFileProtocol("指定的目录“" + dirPath + "”在服务器上不存在。");
                        }

                    }
                    catch (Exception ex)
                    {
                        returnProtocol = GetToClientFileProtocol("获取失败,原因：“" + ex.Message + "”");
                    }
                
            }
            else
            {
                returnProtocol = GetToClientFileProtocol("参数不正确");
            }
            return returnProtocol;
        }
        /// <summary>
        /// 获取服务器上指定目录下的目录列表
        /// </summary>
        /// <returns></returns>
        public TCP_FileProtocol GetDirectoryList(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            string[] Parameters = protocol.Content.Split('|');
            if (Parameters.Length >= 3)
            {
                string dirPath = Parameters[0];
                if (!dirPath.Contains(":"))
                {
                    dirPath = ServerBasePath + "\\" + dirPath.TrimStart('\\');
                }
                bool isSearchSubfolder = false;//是否搜索子目录
                try
                {
                    isSearchSubfolder = Convert.ToBoolean(Parameters[1]);
                }
                catch { }
                string searchPattern = Parameters[2];
                
                    try
                    {
                        if (System.IO.Directory.Exists(dirPath))
                        {
                            string[] retDirs = null;
                            if (isSearchSubfolder)
                            {
                                retDirs = System.IO.Directory.GetDirectories(dirPath, searchPattern, SearchOption.AllDirectories);
                            }
                            else
                            {
                                retDirs = System.IO.Directory.GetDirectories(dirPath, searchPattern, SearchOption.TopDirectoryOnly);
                            }
                            StringBuilder retDirString = new StringBuilder();
                            foreach (string dir in retDirs)
                            {
                                retDirString.Append(dir.Replace(ServerBasePath, "") + "|");
                            }
                            returnProtocol = GetToClientFileProtocol("获取成功", retDirString.ToString());
                            retDirString.Clear();
                        }
                        else
                        {
                            returnProtocol = GetToClientFileProtocol("获取失败,指定的目录“" + dirPath + "”在服务器上不存在。");
                        }

                    }
                    catch (Exception ex)
                    {
                        returnProtocol = GetToClientFileProtocol("获取失败,原因：“" + ex.Message + "”");
                    }
                
            }
            else
            {
                returnProtocol = GetToClientFileProtocol("获取失败,参数不正确");
            }
            return returnProtocol;
        }
        /// <summary>
        /// 删除服务器上的目录
        /// </summary>
        /// <returns></returns>
        public TCP_FileProtocol DeleteDirectory(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            string[] Parameters = protocol.Content.Split('|');
            if (Parameters.Length >= 2)
            {
                string dirPath = Parameters[0];
               
                if (!dirPath.Contains(":"))
                {
                    dirPath = ServerBasePath + "\\" + dirPath.TrimStart('\\');
                }
                bool isDelAllFiles = false;//是否删除目录下的所以文件
                try
                {
                    isDelAllFiles = Convert.ToBoolean(Parameters[1]);
                }
                catch { }
               
                    try
                    {
                        if (System.IO.Directory.Exists(dirPath))
                        {
                            try
                            {
                                System.IO.Directory.Delete(dirPath);
                                returnProtocol = GetToClientFileProtocol("删除成功");
                            }
                            catch (Exception ex)
                            {
                                returnProtocol = GetToClientFileProtocol("删除失败，原因：" + ex.Message);
                            }

                        }
                        else
                        {
                            returnProtocol = GetToClientFileProtocol("指定的目录“" + dirPath + "”在服务器上不存在。");
                        }

                    }
                    catch (Exception ex)
                    {
                        returnProtocol = GetToClientFileProtocol("获取失败,原因：“" + ex.Message + "”");
                    }
                
            }
            else
            {
                returnProtocol = GetToClientFileProtocol("参数不正确");
            }
            return returnProtocol;
        }

        /// <summary>
        /// 获取服务器指定文件的信息
        /// </summary>
        /// <returns></returns>
        public TCP_FileProtocol GetFileInfo(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            //服务器端文件路径
            string saveFilePath = protocol.Content;
            if (!protocol.Content.Contains(":"))
            {
                saveFilePath = HPSocketCS.Extended.CommonLibrary.GetFullDirectoryPath(HPSocketCS.Extended.CommonLibrary.BasePath) + protocol.Content;
            }
            
            ServerFileInfo retfileInfo = new ServerFileInfo();
          
            if (!retfileInfo.IsExists&&System.IO.File.Exists(saveFilePath))
            {
                System.IO.FileInfo fInfo = new FileInfo(saveFilePath);
                retfileInfo.GetMsg = "成功获取指定文件信息";
                retfileInfo.FileName = fInfo.FullName;
                retfileInfo.FileSize = fInfo.Length;
                retfileInfo.IsExists = true;
                retfileInfo.CreateDatetime = fInfo.CreationTime;
                retfileInfo.UpdateDatetime = fInfo.LastWriteTime;
                if (retfileInfo.FileSize < HPSocketCS.Sdk.FileMD5VerifySize)
                {
                    retfileInfo.FileMd5 = LYFZ.WinAPI.SDKSecurity.GetMD5HashFromFile(fInfo.FullName);
                }
            }
            else if (!retfileInfo.IsExists)
            {
                retfileInfo.GetMsg = "服务器上没有找到你请求的“" + protocol.Content + "”文件";
            }
            returnProtocol = GetToClientFileProtocol(retfileInfo.ToString());
            return returnProtocol;
        }

        //Import Photos

        static List<ClientRequestObject> _ImportPhotosRequestList = new List<ClientRequestObject>();
        /// <summary>
        /// 客户端导入相片请求集合
        /// </summary>
        public static List<ClientRequestObject> ImportPhotosRequestList
        {
            get { return TCP_RemoteDataHandlerPassiveMode._ImportPhotosRequestList; }
            set { TCP_RemoteDataHandlerPassiveMode._ImportPhotosRequestList = value; }
        }
        /// <summary>
        /// 检查对象在集合中是否存在
        /// </summary>
        /// <param name="requestObject"></param>
        /// <returns></returns>
        bool ImportPhotosRequestExist(ClientRequestObject requestObject)
        {
            bool bl = false;
            foreach (ClientRequestObject obj in ImportPhotosRequestList)
            {
                if (obj.Key == requestObject.Key)
                {
                    bl = true;
                    break;
                }
            }
            return bl;
        }

        /// <summary>
        /// 开始导入相片
        /// </summary>
        /// <param name="protocol"></param>
        /// <returns></returns>
        public TCP_FileProtocol StartImportPhotos(TCP_FileProtocol protocol)
        {
            TCP_FileProtocol returnProtocol = new TCP_FileProtocol();
            ClientRequestObject requestObject = new ClientRequestObject(protocol.Content);
            TCP_ClientConnectInfo cInfo = new TCP_ClientConnectInfo(protocol.ClientInfo);
            requestObject.IP = cInfo.IP;
            requestObject.Prot = cInfo.Port;
            requestObject.HostIdentity = cInfo.HostIdentity;
            requestObject.ConnID = cInfo.ConnId;
            if (!ImportPhotosRequestExist(requestObject))
            {

            }
            returnProtocol = GetToClientFileProtocol("Start");
            return returnProtocol;
        }


        static List<ClientRequestObject> _GenerateThumbnailsRequestList = new List<ClientRequestObject>();
        /// <summary>
        /// 生成缩略图请求集合
        /// </summary>
        public static List<ClientRequestObject> GenerateThumbnailsRequestList
        {
            get { return TCP_RemoteDataHandlerPassiveMode._GenerateThumbnailsRequestList; }
            set { TCP_RemoteDataHandlerPassiveMode._GenerateThumbnailsRequestList = value; }
        }
        /// <summary>
        /// 检查对象在生成缩略图请求集合中是否存在
        /// </summary>
        /// <param name="requestObject"></param>
        /// <returns></returns>
        bool GenerateThumbnailsRequestExist(ClientRequestObject requestObject)
        {
            bool bl = false;
            lock (GenerateThumbnailsRequestList)
            {
                foreach (ClientRequestObject obj in GenerateThumbnailsRequestList)
                {
                    if (obj.Key == requestObject.Key)
                    {
                        bl = true;
                        break;
                    }
                }
            }
            return bl;
        }
        public static void RemoveGenerateThumbnailsRequest(ClientRequestObject requestObject)
        {
            lock (GenerateThumbnailsRequestList)
            {
                List<ClientRequestObject> delObjList = new List<ClientRequestObject>();
                foreach (ClientRequestObject obj in GenerateThumbnailsRequestList)
                {
                    if (obj.ConnID == requestObject.ConnID)
                    {
                        delObjList.Add(obj);
                    }
                }

                foreach (ClientRequestObject obj in delObjList)
                {
                    GenerateThumbnailsRequestList.Remove(obj);
                }
            }
        }
      

       

        static int _RegConnCount = 0;
        /// <summary>
        /// 客户端坐席注册数
        /// </summary>
        public static int RegConnCount
        {
            get { return TCP_RemoteDataHandlerPassiveMode._RegConnCount; }
            set { TCP_RemoteDataHandlerPassiveMode._RegConnCount = value; }
        }

       

      

       
        private static string _ServerGlobalIDKey = "";

        public static string ServerGlobalIDKey
        {
            get { return TCP_RemoteDataHandlerPassiveMode._ServerGlobalIDKey; }
            set { TCP_RemoteDataHandlerPassiveMode._ServerGlobalIDKey = value; }
        }
       
        #endregion

        #endregion

        #region  客户端发送指令到服务端处理方法


        /// <summary>
        /// 发送SQL数据库请求命令到服务器并返回请求结果 (测试用)
        /// </summary>
        /// <param name="requestData">请求的SQL命令数据类</param>
        /// <param name="millisecondsTimeout"></param>
        /// <returns></returns>
        public HPSocketCS.Extended.SQLHelperReturnData HP_SendSqlCommandToServer(HPSocketCS.Extended.SQLHelperRequestData requestData, int millisecondsTimeout = 1000*90)
        {
            HPSocketCS.Extended.SQLHelperReturnData retData = null;
            try
            {
                byte[] tempSendBuffer = HPSocketCS.Extended.DataSetSerializerDeserialize.ObjectSerializerCompressionRetBytes(requestData);
                using (System.IO.MemoryStream retMstream = this.HpClient.AutoUnpackingSendAndReturnResult(tempSendBuffer, HPSocketCS.Extended.DataType.SQLHelper, HPSocketCS.Extended.TransferRequestCommand.SQLHelperData, millisecondsTimeout))
                {
                    if (retMstream != null && retMstream.Length > 0)
                    {
                        retData = (HPSocketCS.Extended.SQLHelperReturnData)HPSocketCS.Extended.DataSetSerializerDeserialize.ObjectDeserializeDecompress(retMstream.GetBuffer());

                        LYFZ.Network.TCPNetworkClient.TCP_NetworkClient.FromServerStartTimeStamp = retData.ServerStartTimeStamp;
                        retData.DataSize = retMstream.Length;
                    }
                    if (retMstream != null)
                    {
                        retMstream.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                retData = new HPSocketCS.Extended.SQLHelperReturnData("SQL请求处理出错："+ex.Message);
                HPSocketCS.Extended.SystemFileLogs.WriteLogs(retData.ReturnMessage);
            }

            return retData;
        }


        /// <summary>
        /// 发送指令到服务端并返回服务器的处理结果
        /// </summary>
        /// <param name="type">本次传输类型</param>
        /// <param name="command">要发送到服务器的指令</param>
        /// <param name="msgOrParameters">发送到服务器指令的参数或是说明，注：多个参数用 “｜”分隔</param>
        /// <returns></returns>
        public TCP_FileProtocol HP_SendCommandToServer(InformationType type, HPSocketCS.Extended.TransferRequestCommand command, string msgOrParameters, int millisecondsTimeout = 1000*90)
        {

            TCP_FileProtocol protocol = new TCP_FileProtocol();
            try
            {
                LYFZ.Network.TCP_FileProtocol msgXML = new Network.TCP_FileProtocol(msgOrParameters);
                byte[] tempSendBuffer = Encoding.UTF8.GetBytes(msgXML.ToString());  // 获得缓存
                using (System.IO.MemoryStream retMstream = this.HpClient.AutoUnpackingSendAndReturnResult(tempSendBuffer, HPSocketCS.Extended.DataType.Text, command, millisecondsTimeout))
                {
                    if (retMstream != null && retMstream.Length > 0)
                    {

                        if (type == InformationType.Data)
                        {
                            protocol = new TCP_FileProtocol("return");
                            protocol.DataArray = retMstream.GetBuffer();
                            protocol.ReceiveFileSize = retMstream.Length;
                        }
                        else
                        {
                            string ReceiveInfo = Encoding.UTF8.GetString(retMstream.GetBuffer());
                            TCP_ProtocolHelperXML helper = new TCP_ProtocolHelperXML(ReceiveInfo.Trim());
                            protocol = helper.GetProtocol();
                            protocol.ReceiveFileSize = retMstream.Length;
                            LYFZ.Network.TCPNetworkClient.TCP_NetworkClient.FromServerStartTimeStamp = protocol.ServerStartTimeStamp;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                HPSocketCS.Extended.SystemFileLogs.WriteLogs("连接错误：" + ex.Message);
            }

            return protocol;
        }

        /// <summary>
        /// 发送指令到服务端并返回服务器的处理结果
        /// </summary>
        /// <param name="command">要发送到服务器的指令</param>
        /// <param name="msgOrParameters">发送到服务器指令的参数或是说明，注：多个参数用 “｜”分隔</param>
        /// <returns></returns>
        public string SendCommandToServerRetMessage(HPSocketCS.Extended.TransferRequestCommand command, string msgOrParameters = "Hello", int millisecondsTimeout = 1000*90)
        {
            string tempMsg = "";
            TCP_FileProtocol protocol = HP_SendCommandToServer(InformationType.Message, command, msgOrParameters, millisecondsTimeout);
            if (protocol.InfoType == InformationType.Message)
            {
                tempMsg = protocol.Content;
            }
            return tempMsg;
        }

        #endregion
    }

}