package com.zy.common.HslCommunication.Core.Net.NetworkBase;

import com.zy.common.HslCommunication.BasicFramework.SoftBasic;
import com.zy.common.HslCommunication.Core.Net.HslProtocol;
import com.zy.common.HslCommunication.Core.Net.StateOne.AppSession;
import com.zy.common.HslCommunication.Core.Types.*;
import com.zy.common.HslCommunication.StringResources;
import com.zy.common.HslCommunication.Utilities;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Date;

/**
 * 客户端服务器的共享基类
 */
public class NetworkXBase extends NetworkBase
{

    /**
     * 默认的无参构造方法
     */
    public NetworkXBase()
    {
    }

    /**
     * 发送数据的方法
     * @param session 通信用的核心对象
     * @param content 完整的字节信息
     */
    void SendBytesAsync(AppSession session, byte[] content )
    {
        if (content == null) return;
        try
        {
            // 进入发送数据的锁，然后开启异步的数据发送
            session.getHybirdLockSend().lock();
            OutputStream outputStream = session.getWorkSocket().getOutputStream();
            outputStream.write(content);
        }
        catch (Exception ex)
        {
            if (!ex.getMessage().contains( StringResources.Language.SocketRemoteCloseException() ))
            {
                if(LogNet!=null) LogNet.WriteException( toString( ), StringResources.Language.SocketSendException(), ex );
            }
        }
        finally {
            session.getHybirdLockSend().unlock();
        }
    }


    private Thread thread;  // 后台线程

    /**
     * 开始接受数据
     * @param session 会话信息
     */
    protected void BeginReceiveBackground(AppSession session){
        thread = new Thread(){
            @Override
            public void run(){
                while (true){
                    OperateResultExOne<byte[]> readHeadBytes = Receive(session.getWorkSocket(),HslProtocol.HeadByteLength);
                    if(!readHeadBytes.IsSuccess){
                        SocketReceiveException( session );
                        return;
                    }

                    int length = Utilities.getInt(readHeadBytes.Content,28);
                    OperateResultExOne<byte[]> readContent = Receive(session.getWorkSocket(),length);
                    if(!readContent.IsSuccess){
                        SocketReceiveException( session );
                        return;
                    }

                    if (CheckRemoteToken( readHeadBytes.Content ))
                    {
                        byte[] head = readHeadBytes.Content;
                        byte[] content = HslProtocol.CommandAnalysis(head,readContent.Content);
                        int protocol = Utilities.getInt( head, 0 );
                        int customer = Utilities.getInt( head, 4 );

                        DataProcessingCenter(session,protocol,customer,content);
                    }
                    else {
                        if(LogNet!=null) LogNet.WriteWarn( toString( ), StringResources.Language.TokenCheckFailed() );
                        AppSessionRemoteClose( session );
                    }
                }
            }
        };
        thread.start();
    }

    /**
     * 数据处理中心，应该继承重写
     * @param session 连接状态
     * @param protocol 协议头
     * @param customer 用户自定义
     * @param content 数据内容
     */
    protected void DataProcessingCenter( AppSession session, int protocol, int customer, byte[] content ) {

    }

    /**
     * 检查当前的头子节信息的令牌是否是正确的
     * @param headBytes 头子节数据
     * @return 令牌是验证成功
     */
    protected boolean CheckRemoteToken( byte[] headBytes )
    {
        return SoftBasic.IsTwoBytesEquel( headBytes,12, Utilities.UUID2Byte(Token),0,16 );
    }


    /**
     * 接收出错的时候进行处理
     * @param session 会话内容
     */
    protected void SocketReceiveException( AppSession session ) {

    }


    /**
     * 当远端的客户端关闭连接时触发
     * @param session 会话内容
     */
    protected void AppSessionRemoteClose( AppSession session ) {

    }



    /**
     * [自校验] 发送字节数据并确认对方接收完成数据，如果结果异常，则结束通讯
     * @param socket 网络套接字
     * @param headcode 头指令
     * @param customer 用户指令
     * @param send 发送的数据
     * @return 是否发送成功
     */
    protected OperateResult SendBaseAndCheckReceive(Socket socket, int headcode, int customer, byte[] send )
    {
        // 数据处理
        send = HslProtocol.CommandBytes( headcode, customer, Token, send );

        OperateResult sendResult = Send( socket, send );
        if(!sendResult.IsSuccess) return sendResult;

        // 检查对方接收完成
        OperateResultExOne<Long> checkResult = ReceiveLong( socket );
        if(!checkResult.IsSuccess) return checkResult;

        // 检查长度接收
        if (checkResult.Content != send.length)
        {
            CloseSocket(socket);
            return new OperateResult(StringResources.Language.CommandLengthCheckFailed());
        }

        return checkResult;
    }


    /**
     * [自校验] 发送字节数据并确认对方接收完成数据，如果结果异常，则结束通讯
     * @param socket 网络套接字
     * @param customer 用户指令
     * @param send 发送的数据
     * @return 是否发送成功
     */
    protected OperateResult SendBytesAndCheckReceive( Socket socket, int customer, byte[] send )
    {
        return SendBaseAndCheckReceive( socket, HslProtocol.ProtocolUserBytes, customer, send );
    }


    /**
     * [自校验] 直接发送字符串数据并确认对方接收完成数据，如果结果异常，则结束通讯
     * @param socket 网络套接字
     * @param customer 用户指令
     * @param send 发送的数据
     * @return 是否发送成功
     */
    protected OperateResult SendStringAndCheckReceive( Socket socket, int customer, String send )
    {
        byte[] data =(send == null || send.isEmpty() ) ? null : Utilities.string2Byte( send );

        return SendBaseAndCheckReceive( socket, HslProtocol.ProtocolUserString, customer, data );
    }



    /// <summary>
    /// [自校验] 将文件数据发送至套接字，如果结果异常，则结束通讯
    /// </summary>
    /// <param name="socket">网络套接字</param>
    /// <param name="filename">完整的文件路径</param>
    /// <param name="filelength">文件的长度</param>
    /// <param name="report">进度报告器</param>
    /// <returns>是否发送成功</returns>
//    protected OperateResult SendFileStreamToSocket( Socket socket, String filename, long filelength, BiConsumer<Long, Long> report )
//    {
//        try
//        {
//            OperateResult result = null;
//            FileInputStream
//            using (FileStream fs = new FileStream( filename, FileMode.Open, FileAccess.Read ))
//            {
//                result = SendStream( socket, fs, filelength, report, true );
//            }
//            return result;
//        }
//        catch (Exception ex)
//        {
//            socket?.Close( );
//            LogNet?.WriteException( ToString( ), ex );
//            return new OperateResult( )
//            {
//                Message = ex.Message
//            };
//        }
//    }


    /// <summary>
    /// [自校验] 将文件数据发送至套接字，具体发送细节将在继承类中实现，如果结果异常，则结束通讯
    /// </summary>
    /// <param name="socket">套接字</param>
    /// <param name="filename">文件名称，文件必须存在</param>
    /// <param name="servername">远程端的文件名称</param>
    /// <param name="filetag">文件的额外标签</param>
    /// <param name="fileupload">文件的上传人</param>
    /// <param name="sendReport">发送进度报告</param>
    /// <returns>是否发送成功</returns>
//    protected OperateResult SendFileAndCheckReceive(
//            Socket socket,
//            String filename,
//            String servername,
//            String filetag,
//            String fileupload,
//            BiConsumer<Long, Long> sendReport
//    )
//    {
//        // 发送文件名，大小，标签
//        File file = new File(filename);
//
//        if (!file.exists())
//        {
//            // 如果文件不存在
//            OperateResult stringResult = SendStringAndCheckReceive( socket, 0, "" );
//            if (!stringResult.IsSuccess)
//            {
//                return stringResult;
//            }
//            else
//            {
//                CloseSocket(socket);
//                OperateResult result = new OperateResult();
//                result.Message = StringResources.FileNotExist;
//                return  result;
//            }
//        }
//
//        // 文件存在的情况
//        Newtonsoft.Json.Linq.JObject json = new Newtonsoft.Json.Linq.JObject
//        {
//            { "FileName", new Newtonsoft.Json.Linq.JValue(servername) },
//            { "FileSize", new Newtonsoft.Json.Linq.JValue(file.length()) },
//            { "FileTag", new Newtonsoft.Json.Linq.JValue(filetag) },
//            { "FileUpload", new Newtonsoft.Json.Linq.JValue(fileupload) }
//        };
//
//        // 先发送文件的信息到对方
//        OperateResult sendResult = SendStringAndCheckReceive( socket, 1, json.ToString( ) );
//        if (!sendResult.IsSuccess)
//        {
//            return sendResult;
//        }
//
//        // 最后发送
//        return SendFileStreamToSocket( socket, filename, file.length(), sendReport );
//    }



    /// <summary>
    /// [自校验] 将流数据发送至套接字，具体发送细节将在继承类中实现，如果结果异常，则结束通讯
    /// </summary>
    /// <param name="socket">套接字</param>
    /// <param name="stream">文件名称，文件必须存在</param>
    /// <param name="servername">远程端的文件名称</param>
    /// <param name="filetag">文件的额外标签</param>
    /// <param name="fileupload">文件的上传人</param>
    /// <param name="sendReport">发送进度报告</param>
    /// <returns></returns>
//    protected OperateResult SendFileAndCheckReceive(
//            Socket socket,
//            Stream stream,
//            String servername,
//            String filetag,
//            String fileupload,
//            BiConsumer<Long, Long> sendReport
//    )
//    {
//        // 文件存在的情况
//        Newtonsoft.Json.Linq.JObject json = new Newtonsoft.Json.Linq.JObject
//        {
//            { "FileName", new Newtonsoft.Json.Linq.JValue(servername) },
//            { "FileSize", new Newtonsoft.Json.Linq.JValue(stream.Length) },
//            { "FileTag", new Newtonsoft.Json.Linq.JValue(filetag) },
//            { "FileUpload", new Newtonsoft.Json.Linq.JValue(fileupload) }
//        };
//
//
//        // 发送文件信息
//        OperateResult fileResult = SendStringAndCheckReceive( socket, 1, json.ToString( ) );
//        if (!fileResult.IsSuccess) return fileResult;
//
//
//        return SendStream( socket, stream, stream.count(), sendReport, true );
//    }





    /**
     * [自校验] 接收一条完整的同步数据，包含头子节和内容字节，基础的数据，如果结果异常，则结束通讯
     * @param socket 套接字
     * @param timeout 超时时间设置，如果为负数，则不检查超时
     * @return 接收的结果数据
     */
    protected OperateResultExTwo<byte[], byte[]> ReceiveAndCheckBytes( Socket socket, int timeout ) {
        // 30秒超时接收验证
        HslTimeOut hslTimeOut = new HslTimeOut();
        hslTimeOut.DelayTime = timeout;
        hslTimeOut.IsSuccessful = false;
        hslTimeOut.StartTime = new Date();
        hslTimeOut.WorkSocket = socket;


        //if (timeout > 0) ThreadPool.QueueUserWorkItem( new WaitCallback( ThreadPoolCheckTimeOut ), hslTimeOut );

        // 接收头指令
        OperateResultExOne<byte[]> headResult = Receive(socket, HslProtocol.HeadByteLength, timeout);
        if (!headResult.IsSuccess) {
            hslTimeOut.IsSuccessful = true;
            return OperateResultExTwo.<byte[],byte[]>CreateFailedResult(headResult);
        }
        hslTimeOut.IsSuccessful = true;

        // 检查令牌
        if (!CheckRemoteToken(headResult.Content)) {
            CloseSocket(socket);
            return new OperateResultExTwo<>(StringResources.Language.TokenCheckFailed());
        }

        int contentLength = Utilities.getInt(headResult.Content, HslProtocol.HeadByteLength - 4);
        // 接收内容
        OperateResultExOne<byte[]> contentResult = Receive(socket, contentLength);
        if (!contentResult.IsSuccess) return OperateResultExTwo.CreateFailedResult(contentResult);

        // 返回成功信息
        OperateResult checkResult = SendLong(socket, HslProtocol.HeadByteLength + contentLength);
        if (!checkResult.IsSuccess)  return OperateResultExTwo.CreateFailedResult(checkResult);

        byte[] head = headResult.Content;
        byte[] content = contentResult.Content;
        content = HslProtocol.CommandAnalysis(head, content);
        return OperateResultExTwo.CreateSuccessResult(head, content);
    }


    /**
     * [自校验] 从网络中接收一个字符串数据，如果结果异常，则结束通讯
     * @param socket 套接字
     * @return 接收的结果数据
     */
    protected OperateResultExTwo<Integer, String> ReceiveStringContentFromSocket( Socket socket ) {
        OperateResultExTwo<byte[], byte[]> receive = ReceiveAndCheckBytes(socket, 10000);
        if (!receive.IsSuccess) return OperateResultExTwo.CreateFailedResult(receive);

        // 检查是否是字符串信息
        if (Utilities.getInt(receive.Content1, 0) != HslProtocol.ProtocolUserString) {
            if (LogNet != null) LogNet.WriteError(toString(), StringResources.Language.CommandHeadCodeCheckFailed());
            CloseSocket(socket);
            return new OperateResultExTwo<>(StringResources.Language.CommandHeadCodeCheckFailed());
        }

        if (receive.Content2 == null) receive.Content2 = new byte[0];
        // 分析数据
        return OperateResultExTwo.CreateSuccessResult(Utilities.getInt(receive.Content1, 4), Utilities.byte2String(receive.Content2));
    }




    /**
     * [自校验] 从网络中接收一串字节数据，如果结果异常，则结束通讯
     * @param socket 套接字
     * @return 结果数据对象
     */
    protected OperateResultExTwo<Integer, byte[]> ReceiveBytesContentFromSocket( Socket socket )
    {
        OperateResultExTwo<byte[], byte[]> receive = ReceiveAndCheckBytes( socket, 10000 );
        if (!receive.IsSuccess) return OperateResultExTwo.CreateFailedResult(receive);

        // 检查是否是字节信息
        if (Utilities.getInt( receive.Content1, 0 ) != HslProtocol.ProtocolUserBytes)
        {
            if(LogNet!=null) LogNet.WriteError( toString( ), StringResources.Language.CommandHeadCodeCheckFailed() );
            CloseSocket(socket);

            return new OperateResultExTwo<>(StringResources.Language.CommandHeadCodeCheckFailed());
        }

        // 分析数据
        return OperateResultExTwo.CreateSuccessResult( Utilities.getInt( receive.Content1, 4 ), receive.Content2 );
    }


    /// <summary>
    /// [自校验] 从套接字中接收文件头信息
    /// </summary>
    /// <param name="socket"></param>
    /// <returns></returns>
//    protected OperateResult<FileBaseInfo> ReceiveFileHeadFromSocket( Socket socket )
//    {
//        // 先接收文件头信息
//        OperateResult<int, string> receiveString = ReceiveStringContentFromSocket( socket );
//        if (!receiveString.IsSuccess) return OperateResult.CreateFailedResult<FileBaseInfo>( receiveString );
//
//        // 判断文件是否存在
//        if (receiveString.Content1 == 0)
//        {
//            socket?.Close( );
//            LogNet?.WriteWarn( ToString( ), "对方文件不存在，无法接收！" );
//            return new OperateResult<FileBaseInfo>( )
//            {
//                Message = StringResources.FileNotExist
//            };
//        }
//
//        OperateResult<FileBaseInfo> result = new OperateResult<FileBaseInfo>( );
//        result.Content = new FileBaseInfo( );
//        try
//        {
//            // 提取信息
//            Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse( receiveString.Content2 );
//            result.Content.Name = SoftBasic.GetValueFromJsonObject( json, "FileName", "" );
//            result.Content.Size = SoftBasic.GetValueFromJsonObject( json, "FileSize", 0L );
//            result.Content.Tag = SoftBasic.GetValueFromJsonObject( json, "FileTag", "" );
//            result.Content.Upload = SoftBasic.GetValueFromJsonObject( json, "FileUpload", "" );
//            result.IsSuccess = true;
//        }
//        catch (Exception ex)
//        {
//            socket?.Close( );
//            result.Message = "提取信息失败，" + ex.Message;
//        }
//
//        return result;
//    }

    /// <summary>
    /// [自校验] 从网络中接收一个文件，如果结果异常，则结束通讯
    /// </summary>
    /// <param name="socket">网络套接字</param>
    /// <param name="savename">接收文件后保存的文件名</param>
    /// <param name="receiveReport">接收进度报告</param>
    /// <returns></returns>
//    protected OperateResult<FileBaseInfo> ReceiveFileFromSocket( Socket socket, string savename, Action<long, long> receiveReport )
//    {
//        // 先接收文件头信息
//        OperateResult<FileBaseInfo> fileResult = ReceiveFileHeadFromSocket( socket );
//        if (!fileResult.IsSuccess) return fileResult;
//
//        try
//        {
//            using (FileStream fs = new FileStream( savename, FileMode.Create, FileAccess.Write ))
//            {
//                WriteStream( socket, fs, fileResult.Content.Size, receiveReport, true );
//            }
//            return fileResult;
//        }
//        catch (Exception ex)
//        {
//            LogNet?.WriteException( ToString( ), ex );
//            socket?.Close( );
//            return new OperateResult<FileBaseInfo>( )
//            {
//                Message = ex.Message
//            };
//        }
//    }


    /// <summary>
    /// [自校验] 从网络中接收一个文件，写入数据流，如果结果异常，则结束通讯，参数顺序文件名，文件大小，文件标识，上传人
    /// </summary>
    /// <param name="socket">网络套接字</param>
    /// <param name="stream">等待写入的数据流</param>
    /// <param name="receiveReport">接收进度报告</param>
    /// <returns></returns>
//    protected OperateResult<FileBaseInfo> ReceiveFileFromSocket( Socket socket, Stream stream, Action<long, long> receiveReport )
//    {
//        // 先接收文件头信息
//        OperateResult<FileBaseInfo> fileResult = ReceiveFileHeadFromSocket( socket );
//        if (!fileResult.IsSuccess) return fileResult;
//
//        try
//        {
//            WriteStream( socket, stream, fileResult.Content.Size, receiveReport, true );
//            return fileResult;
//        }
//        catch (Exception ex)
//        {
//            LogNet?.WriteException( ToString( ), ex );
//            socket?.Close( );
//            return new OperateResult<FileBaseInfo>( )
//            {
//                Message = ex.Message
//            };
//        }
//    }


    /**
     * 删除文件的操作
     * @param filename 文件的名称
     * @return 是否删除成功
     */
    protected boolean DeleteFileByName( String filename )
    {
        try
        {
            File file = new File(filename);

            if (!file.exists()) return true;
            file.delete();
            return true;
        }
        catch (Exception ex)
        {
            if(LogNet!=null) LogNet.WriteException( toString( ), "delete file failed:" + filename, ex );
            return false;
        }
    }


    /**
     * 预处理文件夹的名称，除去文件夹名称最后一个'\'，如果有的话
     * @param folder 文件夹名称
     * @return 结果数据
     */
    protected String PreprocessFolderName( String folder ) {
        if (folder.endsWith("\\")) {
            return folder.substring(0, folder.length() - 1);
        } else {
            return folder;
        }
    }










    /**
     * 从网络中接收Long数据
     * @param socket 套接字信息
     * @return 返回的结果
     */
    private OperateResultExOne<Long> ReceiveLong( Socket socket ) {
        OperateResultExOne<byte[]> read = Receive(socket, 8);
        if (!read.IsSuccess) return OperateResultExOne.CreateFailedResult(read);

        return OperateResultExOne.CreateSuccessResult(Utilities.getLong(read.Content, 0));
    }

    /**
     * 将Long数据发送到套接字
     * @param socket 套接字
     * @param value 值
     * @return 返回的结果
     */
    private OperateResult SendLong( Socket socket, long value )
    {
        return Send( socket, Utilities.getBytes( value ) );
    }





    /**
     * 发送一个流的所有数据到网络套接字
     * @param socket 网络套接字
     * @param stream 输入流
     * @param receive 接收长度
     * @param report 进度报告
     * @param reportByPercent 是否按照百分比报告进度
     * @return 是否成功
     */
    protected OperateResult SendStream(Socket socket, InputStream stream, long receive, ActionOperateExTwo<Long, Long> report, boolean reportByPercent )
    {
        byte[] buffer = new byte[102400]; // 100K的数据缓存池
        long SendTotal = 0;
        long percent = 0;
        while (SendTotal < receive)
        {
            // 先从流中接收数据
            OperateResultExOne<Integer> read = ReadStream( stream, buffer );
            if (!read.IsSuccess)
            {
                OperateResult result = new OperateResult();
                result.Message = read.Message;
                return  result;
            }
            else
            {
                SendTotal += read.Content;
            }

            // 然后再异步写到socket中
            byte[] newBuffer = new byte[read.Content];
            System.arraycopy( buffer, 0, newBuffer, 0, newBuffer.length );
            OperateResult write = SendBytesAndCheckReceive( socket, read.Content, newBuffer );
            if (!write.IsSuccess)
            {
                OperateResult result = new OperateResult();
                result.Message = write.Message;
                return  result;
            }

            // 报告进度
            if (reportByPercent)
            {
                long percentCurrent = SendTotal * 100 / receive;
                if (percent != percentCurrent)
                {
                    percent = percentCurrent;
                    if(report!=null) report.Action( SendTotal, receive );
                }
            }
            else
            {
                // 报告进度
                if(report!=null) report.Action( SendTotal, receive );
            }
        }

        return OperateResult.CreateSuccessResult( );
    }


    /**
     * 从套接字中接收所有的数据然后写入到流当中去
     * @param socket 网络套接字
     * @param stream 输出流
     * @param totalLength 总长度
     * @param report 进度报告
     * @param reportByPercent 进度报告是否按照百分比
     * @return 结果类对象
     */
    protected OperateResult WriteStream(Socket socket, OutputStream stream, long totalLength, ActionOperateExTwo<Long, Long> report, boolean reportByPercent )
    {
        long count_receive = 0;
        long percent = 0;
        while (count_receive < totalLength)
        {
            // 先从流中异步接收数据
            OperateResultExTwo<Integer,byte[]> read = ReceiveBytesContentFromSocket( socket );
            if (!read.IsSuccess)
            {
                OperateResult result = new OperateResult();
                result.Message = read.Message;
                return  result;
            }
            count_receive += read.Content1;

            // 开始写入文件流
            OperateResult write = WriteStream( stream, read.Content2 );
            if (!write.IsSuccess)
            {
                OperateResult result = new OperateResult();
                result.Message = write.Message;
                return  result;
            }

            // 报告进度
            if (reportByPercent)
            {
                long percentCurrent = count_receive * 100 / totalLength;
                if (percent != percentCurrent)
                {
                    percent = percentCurrent;
                    if(report!=null) report.Action( count_receive, totalLength );
                }
            }
            else
            {
                if(report!=null) report.Action( count_receive, totalLength );
            }

        }

        return OperateResult.CreateSuccessResult( );
    }



    /**
     * 返回表示当前对象的字符串
     * @return
     */
    @Override
    public String toString()
    {
        return "NetworkXBase";
    }

}