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

import com.zy.common.HslCommunication.Core.IMessage.INetMessage;
import com.zy.common.HslCommunication.Core.Types.HslTimeOut;
import com.zy.common.HslCommunication.Core.Types.OperateResult;
import com.zy.common.HslCommunication.Core.Types.OperateResultExOne;
import com.zy.common.HslCommunication.LogNet.Core.ILogNet;
import com.zy.common.HslCommunication.StringResources;
import com.zy.common.HslCommunication.Utilities;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.Date;
import java.util.UUID;


/**
 * 本系统所有网络类的基类，该类为抽象类，无法进行实例化
 */
public abstract class NetworkBase {

    /**
     * 实例化一个NetworkBase对象
     */
    public NetworkBase( )
    {
        Token = UUID.fromString("00000000-0000-0000-0000-000000000000");
    }



    /**
     * 通讯类的核心套接字
     */
    protected Socket CoreSocket = null;


    /**
     * 线程检查是否发生了超时的方法
     * @param timeout
     * @param millisecond
     */
    public static void ThreadPoolCheckConnect(HslTimeOut timeout, int millisecond) {
        while (!timeout.IsSuccessful) {
            if ((new Date().getTime() - timeout.StartTime.getTime()) > millisecond) {
                // 连接超时或是验证超时
                if (!timeout.IsSuccessful) {
                    try {
                        if (timeout.WorkSocket != null) {
                            timeout.WorkSocket.close();
                        }
                    } catch (IOException ex) {
                        // 不处理，放弃
                    }
                }
                break;
            }
        }
    }


    /**
     * 从套接字接收定长度的字节数组
     * @param socket 套接字
     * @param length 数据长度
     * @return 消息类对象
     */
    protected OperateResultExOne<byte[]> Receive(Socket socket, int length, int timeout )
    {
        OperateResultExOne<byte[]> resultExOne = new OperateResultExOne<>();

        if (length == 0) {
            resultExOne.IsSuccess = true;
            resultExOne.Content = new byte[0];
            return  resultExOne;
        }

        int count_receive = 0;
        byte[] bytes_receive = new byte[length];
        try {
            if(timeout>0) socket.setSoTimeout(timeout);
            InputStream input = socket.getInputStream();
            while (count_receive<length)
            {
                count_receive += input.read(bytes_receive, count_receive, length-count_receive);
            }
        }
        catch (IOException ex)
        {
            CloseSocket(socket);
            resultExOne.Message = ex.getMessage();
            return  resultExOne;
        }

        resultExOne.IsSuccess = true;
        resultExOne.Content = bytes_receive;
        return  resultExOne;
    }

    /**
     * 从套接字接收定长度的字节数组
     * @param socket 套接字
     * @param length 数据长度
     * @return 消息类对象
     */
    protected OperateResultExOne<byte[]> Receive(Socket socket, int length )
    {
        return Receive(socket,length,-1);
    }


    /**
     * 从套接字接收指定长度的字节数据
     * @param socket 网络套接字
     * @param timeOut 超时时间
     * @param netMsg 消息格式
     * @param <TNetMessage> 类型
     * @return 消息类
     */
    protected <TNetMessage extends INetMessage> OperateResultExOne<TNetMessage> ReceiveMessage(Socket socket, int timeOut, TNetMessage netMsg)
    {
        OperateResultExOne<TNetMessage> resultExOne = new OperateResultExOne<>();

        // 接收指令头
        OperateResultExOne<byte[]> headResult = Receive( socket, netMsg.ProtocolHeadBytesLength(), timeOut );
        if (!headResult.IsSuccess)
        {
            resultExOne.CopyErrorFromOther( headResult );
            return resultExOne;
        }

        netMsg.setHeadBytes( headResult.Content );
        if (!netMsg.CheckHeadBytesLegal(Utilities.UUID2Byte(Token)))
        {
            // 令牌校验失败
            CloseSocket(socket);
            if(LogNet != null) LogNet.WriteError( toString( ), StringResources.Language.TokenCheckFailed() );
            resultExOne.Message = StringResources.Language.TokenCheckFailed();
            return resultExOne;
        }


        int contentLength = netMsg.GetContentLengthByHeadBytes( );
        if (contentLength == 0)
        {
            netMsg.setContentBytes( new byte[0] );
        }
        else
        {
            OperateResultExOne<byte[]> contentResult = Receive( socket, contentLength, timeOut );
            if (!contentResult.IsSuccess)
            {
                resultExOne.CopyErrorFromOther( contentResult );
                return resultExOne;
            }

            netMsg.setContentBytes( contentResult.Content);
        }

        // 防止没有实例化造成后续的操作失败
        if (netMsg.getContentBytes() == null){ netMsg.setContentBytes( new byte[0]);}
        resultExOne.Content = netMsg;
        resultExOne.IsSuccess = true;
        return resultExOne;
    }


    /**
     * 发送一串数据到网络套接字中
     * @param socket 网络套接字
     * @param data 数据
     * @return 是否发送成功
     */
    protected OperateResult Send(Socket socket,byte[] data){
        OperateResult result = new OperateResult();
        if(data == null) {
            result.IsSuccess = true;
            return result;
        }
        try {
            DataOutputStream output = new DataOutputStream(socket.getOutputStream());
            output.write(data, 0, data.length);
        }
        catch (IOException ex)
        {
            result.Message = ex.getMessage();
            return  result;
        }

        result.IsSuccess = true;
        return  result;
    }


    /**
     * 创建一个套接字并且连接到服务器
     * @param endPoint 目标节点
     * @param timeOut 超时时间
     * @return 连接成功的标志
     */
    protected  OperateResultExOne<Socket> CreateSocketAndConnect(SocketAddress endPoint, int timeOut){
        OperateResultExOne<Socket> operateResultExOne = new OperateResultExOne<>();

        Socket socket = new Socket();
        try {
            socket.connect(endPoint,timeOut);
            operateResultExOne.Content = socket;
            operateResultExOne.IsSuccess = true;
        }
        catch (IOException ex)
        {
            operateResultExOne.Message = ex.getMessage();
            CloseSocket(socket);
        }

        return operateResultExOne;
    }

    /**
     * 创建一个套接字并且连接到服务器
     * @param ipAddress ip地址
     * @param port 端口号
     * @param timeOut 超时时间
     * @return 连接成功的标志
     */
    protected  OperateResultExOne<Socket> CreateSocketAndConnect(String ipAddress,int port, int timeOut) {
        SocketAddress endPoint = new InetSocketAddress(ipAddress,port);
        return CreateSocketAndConnect(endPoint,timeOut);
    }


    /**
     * 读取流中的数据到缓存区
     * @param stream 流数据
     * @param buffer 缓冲数据
     * @return
     */
    protected OperateResultExOne<Integer> ReadStream(InputStream stream, byte[] buffer) {
        OperateResultExOne<Integer> resultExOne = new OperateResultExOne<>();
        int read_count = 0;
        try {
            while (read_count < buffer.length) {
                read_count += stream.read(buffer, read_count, buffer.length - read_count);
            }
            resultExOne.Content = read_count;
            resultExOne.IsSuccess = true;
        } catch (IOException ex) {
            resultExOne.Message = ex.getMessage();
        }

        return resultExOne;
    }


    /**
     * 将字节流数据写入到输出流里面去
     * @param stream 字节流
     * @param buffer 缓存数据
     * @return 写入是否成功
     */
    protected OperateResult WriteStream(OutputStream stream, byte[] buffer ) {
        OperateResult result = new OperateResultExOne<>();
        try {
            stream.write(buffer, 0, buffer.length);
            result.IsSuccess = true;
        } catch (IOException ex) {
            result.Message = ex.getMessage();
        }

        return result;
    }


    /**
     * 安全的关闭一个套接字
     * @param socket 网络套接字
     */
    protected void CloseSocket(Socket socket){
        if(socket != null){
            try {
                socket.close();
            }
            catch (Exception ex){

            }
        }
    }


    /**
     * 组件的日志工具，支持日志记录
     */
    public ILogNet LogNet = null;

    /**
     * 网络类的身份令牌
     */
    public UUID Token = null;



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


}