using HPSocketCS.Extended;
using LYFZ.DAL.N8Process;
using LYFZ.Helper;
using LYFZ.Model;
using LYFZ.Network.FTPOperation;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LYFZ.Network.TCPNetworkServer
{

    /// <summary>
    /// 请求指令
    /// </summary>
    public enum SerializerRequestCommand
    {
        /// <summary>
        /// 测试指令
        /// </summary>
        TestCommand = 0,
        FTPCommand = 1,
        OSS_QueryBranch,
        OSS_UploadTask,
        N8ServerIpAddress,
        OSS_QueryBranchId,
        OSS_Status,
        Get_Server_Config,
        OSS_TASK_JSON,
        OSS_TASK_INFO,
        OSS_TASK_EXISTS
    }

    public class SerializationRequestProcessed
    {
        public SerializationRequestProcessed()
        {

        }


        /// <summary>
        /// 服务器端接收客户端发送的Serialization数据请求并处理返回结果
        /// </summary>
        /// <param name="hp_Server">网络连接对象</param>
        /// <param name="header">协议头</param>
        /// <param name="connId">连接ID</param>
        /// <param name="bytes">收到的数据</param>
        public static bool SerializationDataRequestProcessed( HPSocketCS.TcpPackServer hp_Server, TcpHeadInfo header, IntPtr connId, byte[] bytes )
        {
            bool ret = false;
            TransferRequestCommand Command = (TransferRequestCommand)Convert.ToInt32( header.RequestCommand );
            ReturnData returnData;
            try
            {
                RequestData requestData = (RequestData)DataSetSerializerDeserialize.ObjectDeserializeDecompress( bytes );

                TCP_ClientConnectInfo cInfo = new TCP_ClientConnectInfo( connId.ToInt32(), header );

                try
                {

                    // LYFZ.BLL.BLL_FileLogs.WriteMainLogs(String.Format("接收到命令请求{0},参数{1}", Command.ToString(), recprotocol.Content));

                    if ( Command == TransferRequestCommand.SerializationData )
                    {
                        returnData = SerializerRequestProcessed( cInfo, requestData );
                    }
                    else
                    {
                        returnData = new ReturnData( "非法Serializer请求指令，服务器拒绝执行..." );
                    }


                }
                catch ( Exception ex )
                {
                    returnData = new ReturnData( "处理Serializer请求指令时出错：" + ex.Message );
                }

                // LYFZ.BLL.BLL_FileLogs.WriteMainLogs("服务器端返回信息：" + returnProtocol.Content.Trim());

                if ( returnData == null )
                {
                    returnData = new ReturnData( "Serializer请求指令失败，没有返回有效的结果" );
                }

                returnData.ServerStartTimeStamp = LYFZ.Network.TCPNetworkServer.TCP_NetworkServer.ServerStartTimeStamp;
                byte[] sendBytes = DataSetSerializerDeserialize.ObjectSerializerCompressionRetBytes( returnData );
                ret = hp_Server.AutoUnpackingAndSend( connId, sendBytes, header.TransportID, DataType.Serialization, Command );
                System.GC.Collect();
            }
            catch ( Exception ex )
            {
                try
                {
                    returnData = new ReturnData( "服务器处理客户端Serializer请求时出错:" + ex.Message );
                    returnData.ServerStartTimeStamp = LYFZ.Network.TCPNetworkServer.TCP_NetworkServer.ServerStartTimeStamp;
                    LYFZ.BLL.BLL_FileLogs.WriteMainLogs( returnData.ReturnMessage );
                    byte[] sendBytes = DataSetSerializerDeserialize.ObjectSerializerCompressionRetBytes( returnData );
                    ret = hp_Server.AutoUnpackingAndSend( connId, sendBytes, header.TransportID, DataType.Serialization, Command );
                }
                catch
                {

                }
            }
            return ret;
        }

        /// <summary>
        /// 处理SQL命令请求 并返回请求结果
        /// </summary>
        /// <param name="cInfo"></param>
        /// <param name="requestData"></param>
        /// <returns></returns>
        static ReturnData SerializerRequestProcessed( TCP_ClientConnectInfo cInfo, RequestData requestData )
        {
            ReturnData returnData = null;
            SerializerRequestCommand rCommand = (SerializerRequestCommand)requestData.RequestCommand;
            //System.IO.File.WriteAllText("D:\\txt.txt",(System.Windows.Forms.Application.ExecutablePath) + "\\txt.txt");
            switch ( rCommand )
            {
                case SerializerRequestCommand.TestCommand:

                    string jsondata = "1111";

                    byte[] jsonBytes = HPSocketCS.Extended.DataSetSerializerDeserialize.ObjectSerializerRetBytes( jsondata );

                    returnData = new ReturnData( "请求指令成功 ~O~", 0 );

                    returnData.DataByte = jsonBytes;
                    returnData.AttachedMessage = "Serializer测试请求指令成功 ~O~ 收到的附加信息为：" + requestData.AttachedMessage;
                    break;
                case SerializerRequestCommand.FTPCommand:
                    string jString = requestData.AttachedMessage;
                    FTPDataCommand command = new FTPDataCommand();
                    string msg = command.CommandFtpData( jString );

                    returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                    returnData.AttachedMessage = msg;
                    break;

                #region oss云传片
                // 客户端请求oss分店信息;
                case SerializerRequestCommand.OSS_QueryBranch:
                {
                    List<OssBranch> osslist = OssOperation.OssProcess.GetBranchList();
                    if ( osslist != null )
                    {
                        returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                        returnData.DataByte = osslist.ToSerializerRetBytes();
                    }
                    else
                    {
                        returnData = new ReturnData( "请求指令失败 ~O~", 1 );
                        returnData.DataByte = null;
                    }

                    bool useOss = false;
                    // 打开指定的xml文件;
                    string configPath = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + "AliyunOssClient\\lyfzAliyunOss.config";
                    XMLHelper xmlhelper = new XMLHelper( configPath );
                    if ( xmlhelper != null )
                    {
                        useOss = Convert.ToBoolean( xmlhelper.GetXmlNodeByXpath( "//sys_configuration//UseOss" ) == null ? "false" : xmlhelper.GetXmlNodeByXpath( "//sys_configuration//UseOss" ).InnerText );
                    }
                    // 附加数据：是否开启oss传片;
                    returnData.AttachedMessage = useOss.ToString();
                }
                break;

                case SerializerRequestCommand.OSS_Status:
                {
                    bool useOss = false;
                    returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                    // 打开指定的xml文件;
                    string configPath = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + "AliyunOssClient\\lyfzAliyunOss.config";
                    XMLHelper xmlhelper = new XMLHelper( configPath );
                    if ( xmlhelper != null )
                    {
                        useOss = Convert.ToBoolean( xmlhelper.GetXmlNodeByXpath( "//sys_configuration//UseOss" ) == null ? "false" : xmlhelper.GetXmlNodeByXpath( "//sys_configuration//UseOss" ).InnerText );
                    }
                    // 附加数据：是否开启oss传片;
                    returnData.AttachedMessage = useOss.ToString();
                }
                break;

                // 获取当前服务器配置的分店id;
                case SerializerRequestCommand.OSS_QueryBranchId:
                {
                    string branchid = "";
                    // 打开指定的xml文件;
                    string configfile = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + "AliyunOssClient\\lyfzAliyunOss.config";
                    XMLHelper xml = new XMLHelper( configfile );
                    if ( xml != null )
                    {
                        branchid = xml.GetXmlNodeByXpath( "//sys_configuration//LoginId" ) == null ? "" : xml.GetXmlNodeByXpath( "//sys_configuration//LoginId" ).InnerText;
                    }
                    // 附加数据：是否开启oss传片;
                    returnData.AttachedMessage = branchid;
                }
                break;

                // 客户端发送上传任务信息;
                case SerializerRequestCommand.OSS_UploadTask:
                {
                    HPSocketCS.Extended.RequestParameters reqParameters = requestData.AttachedDataToObject<HPSocketCS.Extended.RequestParameters>();
                    OssOperation.OssUploadTask uploadTask = reqParameters.GetRequestParameter<OssOperation.OssUploadTask>( "uploadtask" );

                    if ( OssOperation.OssProcess.SaveUploadTaskToFile( uploadTask ) )
                    {
                        returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                    }
                    else
                    {
                        returnData = new ReturnData( "请求指令失败 ~O~", 1 );
                    }
                }
                break;
                #endregion

                #region oss
                case SerializerRequestCommand.OSS_TASK_JSON:
                {
                    HPSocketCS.Extended.RequestParameters reqParameters = requestData.AttachedDataToObject<HPSocketCS.Extended.RequestParameters>();
                    string strTaskJson = reqParameters.GetRequestParameter<string>( "oss_task_json" );
                    string strTaskId = requestData.AttachedMessage;

                    string path = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + ".OssTask\\";
                    if ( !System.IO.Directory.Exists( path ) )
                    {
                        try
                        {
                            System.IO.Directory.CreateDirectory( path );
                        }
                        catch ( Exception e )
                        {
                            returnData = new ReturnData( "无法创建任务文件保存目录, " + e.Message, 1 );
                            return returnData;
                        }
                    }

                    // 保存文件;
                    try
                    {
                        if ( strTaskId.Length == 33 )
                        {
                            string file = path + strTaskId.Substring( 0, 32 ) + ".json";
                            System.IO.File.WriteAllText( file, strTaskJson );
                        }
                        else
                        {
                            string file = path + strTaskId + ".json";
                            //if ( !System.IO.File.Exists( file ) )
                            System.IO.File.WriteAllText( file, strTaskJson );
                        }

                        returnData = new ReturnData( "保存文件成功", 0 );

                        // 判断程序是否启动;
                        #region 单例模式运行			
                        try
                        {
                            bool create;
                            System.Threading.Mutex mu = new System.Threading.Mutex( false, "lyfz.Oss.Upload.Tool", out create );
                            if ( create )
                            {
                                // 退出锁;
                                mu.ReleaseMutex();
                                // 启动程序;
                                System.Diagnostics.Process.Start( LYFZ.WinAPI.CustomPublicMethod.BasePath + "\\OssTool.exe" );
                            }
                        }
                        catch { }
                        #endregion
                    }
                    catch ( Exception e )
                    {
                        returnData = new ReturnData( "保存文件失败," + e.Message, 1 );
                        return returnData;
                    }
                }
                break;
                case SerializerRequestCommand.OSS_TASK_INFO:
                {
                    string path = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + "\\.OssTask\\";
                    if ( !System.IO.Directory.Exists( path ) )
                    {
                        returnData = new ReturnData( "任务文件目录不存在!", 1 );
                        return returnData;
                    }

                    // 遍历文件夹;
                    string strJson;
                    List<string> listJson = new List<string>();

                    try
                    {
                        string[] files = System.IO.Directory.GetFiles( path );
                        foreach ( string file in files )
                        {
                            strJson = System.IO.File.ReadAllText( file );
                            listJson.Add( strJson );
                        }

                        returnData = new ReturnData( "获取任务信息成功", 0 );
                        returnData.DataByte = listJson.ToSerializerRetBytes();
                    }
                    catch ( Exception e )
                    {
                        returnData = new ReturnData( "遍历任务文件失败," + e.Message, 1 );
                        return returnData;
                    }
                }
                break;
                case SerializerRequestCommand.OSS_TASK_EXISTS:
                {
                    // 获取客户的请求参数;
                    HPSocketCS.Extended.RequestParameters reqParameters = requestData.AttachedDataToObject<HPSocketCS.Extended.RequestParameters>();
                    string strTaskId = reqParameters.GetRequestParameter<string>( "oss_task_id" );

                    // 查找文件;
                    string path = LYFZ.WinAPI.CustomPublicMethod.GetFullDirectoryPath( LYFZ.WinAPI.CustomPublicMethod.BasePath ) + "\\.OssTask\\";
                    if ( !System.IO.Directory.Exists( path ) )
                    {
                        returnData = new ReturnData( "任务文件目录不存在!", 1 );
                        return returnData;
                    }

                    // 遍历文件夹;
                    try
                    {
                        string strJson;
                        string filename;
                        bool bExist = false;
                        string[] files = System.IO.Directory.GetFiles( path, "*.json" );
                        foreach ( string file in files )
                        {
                            filename = System.IO.Path.GetFileNameWithoutExtension( file );
                            if ( filename.ToUpper() == strTaskId.ToUpper() )
                            {
                                bExist = true;
                                strJson = System.IO.File.ReadAllText( file );
                                returnData = new ReturnData( "获取任务信息成功", 0 );
                                returnData.DataByte = strJson.ToSerializerRetBytes();
                                break;
                            }
                        }

                        if ( !bExist )
                        {
                            returnData = new ReturnData( "没有该任务", 1 );
                        }
                    }
                    catch ( Exception e )
                    {
                        returnData = new ReturnData( "遍历任务文件失败," + e.Message, 1 );
                        return returnData;
                    }
                }
                break;
                #endregion

                // 客户端获取服务端配置信息, 用于客户端获取备份相片等操作;
                case SerializerRequestCommand.Get_Server_Config:
                {
                    LYFZ.Model.Model_ServerConfig ConfigModel = new BLL.BLL_Config().GetModelServerSysConfig();
                    if ( ConfigModel != null )
                    {
                        returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                        returnData.DataByte = ConfigModel.ToSerializerRetBytes();
                    }
                    else
                    {
                        returnData = new ReturnData( "请求指令失败 ~O~", 1 );
                        returnData.DataByte = null;
                    }
                }
                break;

                #region N8服务器IP地址;
                case SerializerRequestCommand.N8ServerIpAddress:
                {
                    DAL_N8ServerConfig config = new DAL_N8ServerConfig();
                    config.LoadConfig();
                    returnData = new ReturnData( "请求指令成功 ~O~", 0 );
                    Model.N8Process.N8ServerConfig result = new Model.N8Process.N8ServerConfig();
                    result.N8ProductConfigDirectory = config.N8ProductConfigDirectory;
                    result.N8ServerIpAddress = config.N8ServerIpAddress;
                    result.N8ServerStatisticsDirectory = config.N8ServerStatisticsDirectory;
                    result.N8ServerUserDirectory = config.N8ServerUserDirectory;
                    returnData.DataByte = result.ToSerializerRetBytes();
                }
                break;
                #endregion

            }
            return returnData;
        }



    }
}