package com.hdl.sdk.link.socket;

import android.text.TextUtils;

import androidx.collection.ArrayMap;

import com.hdl.sdk.link.BuildConfig;
import com.hdl.sdk.link.HDLLinkLocalSdk;
import com.hdl.sdk.link.bean.LoginRequest;
import com.hdl.sdk.link.common.config.TopicConstant;
import com.hdl.sdk.link.common.utils.IdUtils;
import com.hdl.sdk.link.common.utils.LogUtils;
import com.hdl.sdk.link.common.utils.ThreadToolUtils;
import com.hdl.sdk.link.common.utils.gson.GsonConvert;
import com.hdl.sdk.link.core.bean.LinkRequest;
import com.hdl.sdk.link.core.bean.response.BaseLocalResponse;
import com.hdl.sdk.link.core.callback.HDLLinkCallBack;
import com.hdl.sdk.link.core.config.HDLLinkConfig;
import com.hdl.sdk.link.core.connect.HDLConnectHelper;
import com.hdl.sdk.link.socket.client.IClient;
import com.hdl.sdk.link.socket.client.IHeartbeat;
import com.hdl.sdk.link.socket.listener.SendListener;
import com.hdl.sdk.link.socket.annotation.ConnectStatus;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * Created by Tong on 2021/9/26.
 * Tcp/Udp 启动器
 */
public class TcpSocketBoot {

    private ExecutorService connectThread;
    private ExecutorService sendThread;
    private ExecutorService receiveThread;
    private ExecutorService heartbeatThread;

    private final IClient client;
    private IHeartbeat iHeartbeat;
    public void SetHeartbeat(IHeartbeat iHeartbeat){
        this.iHeartbeat=iHeartbeat;
    }
    /**
     * 当前接收到数据的时间
     */
    private  long time=System.currentTimeMillis();
    /**
     * tcp是否已经连接
     */
    private boolean connected=false;

    public IClient getClient() {
        return client;
    }

    public boolean isConnected() {
        return connected;
    }

    private final BlockingQueue<SocketRequest> mMessageQueue = new LinkedBlockingDeque<>();

    private final ArrayMap<String, SendListener> sendMap = new ArrayMap<>();

    public  TcpSocketBoot(IClient client) {
        TCP_SOCKET_BOOT_LIST.add(this);
        this.client = client;
        initConnectThread();
        initReceiveThread();
        initSendThread();
        initHeartbeat();
    }

    /**
     * 记录所有SocketBoot
     */
    final static List<TcpSocketBoot> TCP_SOCKET_BOOT_LIST = new ArrayList();

    /**
     * 根据IP地址及端口获取当前socketBoot
     * @param ipAddress
     * @param port
     * @return
     */
    public static TcpSocketBoot getByEndPoint(String ipAddress, int port){
        if(ipAddress==null){
            return  null;
        }
        for(TcpSocketBoot tcpSocketBoot : TCP_SOCKET_BOOT_LIST){
            if(ipAddress.equals(tcpSocketBoot.getClient().getOptions().getIp())&& tcpSocketBoot.getClient().getOptions().getPort()==port)
            {
                return tcpSocketBoot;
            }
        }
        return  null;
    }

    /**
     * 连接tcp，内部维护掉，可以不用开放外部，根据这个业务我特性处理好
     */
    private synchronized void connect() {
        try {
            LogUtils.i("TCP连接："+this.getClient().getOptions().getIp());
            client.onConnectStatus(ConnectStatus.CONNECTING);
//            Thread.sleep(700);
            client.connect();
            LogUtils.i("TCP连接成功："+this.getClient().getOptions().getIp());
            connected=true;
            tcpLogin("program", BuildConfig.SDKVersion);
            client.onConnectStatus(ConnectStatus.CONNECTED);
        }catch(Exception e) {
            LogUtils.e(e.getMessage());
        }
    }

    /**
     * tcp登录方便获取状态
     *
     * @param clientType 客户端类型
     *                   应用：app；
     *                   调试软件：program；
     *                   第三方：third_party；
     *                   网关：gateway；
     *                   其它：other
     * @param version    协议版本
     */
    public void tcpLogin(String clientType, String version) {
        final String msgId = IdUtils.getUUId();
        String time = String.valueOf(System.currentTimeMillis());
        final BaseLocalResponse<LoginRequest> data = new BaseLocalResponse<>();
        data.setId(msgId);
        data.setTime_stamp(time);

        final LoginRequest request = new LoginRequest();
        request.setVersion(version);
        request.setClientType(clientType);

        data.setObjects(request);

        String topic = String.format(TopicConstant.GATEWAY_LOGIN, HDLLinkConfig.getInstance().getGatewayId());
        LinkRequest messageRequest = new LinkRequest(topic,
                GsonConvert.getGson().toJson(data),false);

        new HDLConnectHelper(this.getClient().getOptions().getIp(),messageRequest,true).send();
    }

    /**
     * 初始化发送线程，只需要初始化一次
     */
    private void initSendThread() {
        if (sendThread == null) {
            sendThread = ThreadToolUtils.getInstance().newFixedThreadPool(1);
            sendThread.execute(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            if(connected==false){
                                Thread.sleep(100);
                                continue;
                            }
                            SocketRequest socketRequest = mMessageQueue.take();
                            final String action = socketRequest.getAction();
                            try {
                                client.sendMsg(socketRequest.getData());
                                if (!TextUtils.isEmpty(action)) {
                                    SendListener sendListener = sendMap.get(action);
                                    if (sendListener != null) {
                                        sendListener.onSucceed();
                                    }
                                }
                            } catch (Exception e) {
                                connected = false;
                                LogUtils.e("发送失败:" + e.getMessage());
                                if (!TextUtils.isEmpty(action)) {
                                    SendListener sendListener = sendMap.get(action);
                                    if (sendListener != null) {
                                        sendListener.onError();
                                    }
                                }
                            }
                        } catch (Exception e) {
                            LogUtils.e("发送失败1:" + e.getMessage());
                        }
                    }
                }
            });
        }
    }

    /**
     * 初始化接收线程，只需要初始化一次
     */
    public void initReceiveThread() {
        if (receiveThread == null) {
            receiveThread = ThreadToolUtils.getInstance().newFixedThreadPool(1);
            receiveThread.execute(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            if (connected) {
                                //读取数据
                                client.onHandleResponse();
                                time= System.currentTimeMillis();
                            } else {
                                try {
                                    Thread.sleep(1000);
                                } catch (Exception ee) {

                                }
                            }
                        } catch (Exception e) {
                            connected = false;
                            LogUtils.e("接收数据线程异常" + e.getMessage());
                        }
                    }
                }
            });
        }
    }

    /**
     * 初始化重新连接线程
     */
    private void initConnectThread() {
        if (connectThread == null) {
            connectThread = ThreadToolUtils.getInstance().newFixedThreadPool(1);
            //一定时间检测一次连接情况，没有连接就执行连接，连接统一由这里维护
            connectThread.execute(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            if (!connected) {
                                reconect();
                            }
                            Thread.sleep(2*1000);
                        } catch (Exception e) {

                            LogUtils.e("定时连接线程异常:" + e.getMessage());
                        }
                    }
                }
            });
        }
    }


    /**
     * 初始化重新心跳线程
     */
    private void initHeartbeat() {
        if (heartbeatThread == null) {
            heartbeatThread = ThreadToolUtils.getInstance().newFixedThreadPool(1);
            heartbeatThread.execute(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            //5秒
                            if (connected && 5 * 1000 < (System.currentTimeMillis() - time)) {
                                time = System.currentTimeMillis();
                                //心跳检测
                                if (iHeartbeat != null)
                                    iHeartbeat.heartbeat();
                            }
                            Thread.sleep(10);
                        } catch (Exception e) {
                            LogUtils.e("定时心跳检测网关异常：" + e.getMessage());
                        }
                    }
                }
            });
        }
    }
    /**
     * 重新连接
     */
    private void reconect() {
        disconnect();
        connect();
    }

    /**
     * 发送无需回调
     * @param msg 发送的数据
     */
    public void sendMsg(byte[] msg) {
        sendMsg(msg, null);
    }


    /**
     * @param listener 一般情况无需监听
     */
    public void sendMsg(byte[] msg, SendListener listener) {
        try {
            SocketRequest request = new SocketRequest(msg);
            if (listener != null && !TextUtils.isEmpty(request.getAction())) {
                sendMap.put(request.getAction(), listener);
            }
            mMessageQueue.put(request);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭连接
     */
    private synchronized void disconnect() {
        try {
            client.disconnect();
            //断开连接
            client.onConnectStatus(ConnectStatus.DISCONNECT);
        } catch (Exception e) {

        }
    }


//    /**
//     * 断开全部的Link网关连接
//     */
//    public static void stopAllConnectLinkGateway() {
//        for (TcpSocketBoot data : TCP_SOCKET_BOOT_LIST) {
//            //断开指定的link网关连接
//            stopConnectLinkGateway(data);
//        }
//
//    }
//
//    /**
//     * 断开指定的link网关连接
//     *
//     * @param tcpSocketBoot tcp对象
//     */
//    public static void stopConnectLinkGateway(TcpSocketBoot tcpSocketBoot) {
//        synchronized (TCP_SOCKET_BOOT_LIST) {
//            try {
//                TCP_SOCKET_BOOT_LIST.remove(tcpSocketBoot);
//                tcpSocketBoot.client.disconnect();
//            } catch (Exception ignored) {
//            }
//        }
//    }

}