package com.hdl.sdk.link.core.connect;

import android.text.TextUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.hdl.sdk.link.common.event.EventDispatcher;
import com.hdl.sdk.link.common.event.EventListener;
import com.hdl.sdk.link.common.exception.HDLLinkCode;
import com.hdl.sdk.link.common.utils.ErrorUtils;
import com.hdl.sdk.link.common.utils.LogUtils;
import com.hdl.sdk.link.common.utils.ThreadToolUtils;
import com.hdl.sdk.link.core.bean.LinkRequest;
import com.hdl.sdk.link.core.bean.LinkResponse;
import com.hdl.sdk.link.core.bean.ModbusResponse;
import com.hdl.sdk.link.core.bean.ZigbeeResponse;
import com.hdl.sdk.link.core.bean.gateway.GatewayBean;
import com.hdl.sdk.link.core.config.HDLLinkConfig;
import com.hdl.sdk.link.core.utils.EncryptUtil;
import com.hdl.sdk.link.core.utils.mqtt.MqttRecvClient;
import com.hdl.sdk.link.gateway.HDLLinkLocalGateway;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by Tong on 2021/11/11.
 */
public class HDLConnectHelper {

    private static final Long DEF_SEND_TIMEOUT = 8000L;
    private static final int DEF_MAX_RETRY = 1;//最大重发数
    private static final int DEF_SEND_ONE = 1;
    private static final int TCP_PORT = 8586;
    private static final int UDP_PORT = 8585;

    private final Long sendAwaitTime;
    private final int maxRetry;

    /**
     * 是否tcp发送类型
     */
    private boolean isTcp;
    /**
     * 设备mac
     */
    private String mac;
    /**
     * 发送的目标IP
     */
    private String ipAddress;
    /**
     * 发送的目标地址
     */
    private int port;
    private final LinkRequest linkRequest;
    private final EventListener eventListener;

    private final AtomicInteger sendNumber = new AtomicInteger(0);

    private final AtomicBoolean isSend = new AtomicBoolean(false);

    private HdlSocketListener listener;

    private ScheduledExecutorService sendThread;

    private String replyTopic;

    public interface HdlSocketListener {
        void onSucceed(Object msg);

        void onFailure(HDLLinkCode hdlLinkCode);
    }

    /**
     * 发送UDP或者TCP数据
     *
     * @param sendAwaitTime 每次发送等待时间
     * @param maxRetry      重试次数
     * @param ipAddress     发送目标IP
     * @param port          发送目标端口
     * @param linkRequest   发送对象
     * @param listener      回调
     * @param isTcp         是否TCP
     */
    public HDLConnectHelper(Long sendAwaitTime, int maxRetry, String ipAddress, int port,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp) {
        this.sendAwaitTime = sendAwaitTime;
        this.maxRetry = maxRetry;
        this.ipAddress = ipAddress;
        this.port = port;
        this.linkRequest = linkRequest;
        this.replyTopic = linkRequest.getReplyTopic();
        this.listener = listener;
        this.isTcp = isTcp;


        eventListener = new EventListener() {
            @Override
            public void onMessage(Object msg) {
                isSend.set(true);
                try {
                    if (msg instanceof LinkResponse) {
                        LinkResponse linkResponse = (LinkResponse) msg;
                        JSONObject jsonObject = JSON.parseObject(linkResponse.getData());
                        String id = jsonObject.getString("id");
                        Integer code = jsonObject.getInteger("code");
                        /**
                         * 可能返回code属性可能没有   没有的话直接成功  有的话只有200才会成功
                         */
                        if (code == null || code.intValue() == 200 || code.intValue() == 0) {
                            notifySucceed(msg);
                        } else {
                            notifyFailure(ErrorUtils.getByCode(code));
                        }
                    } else if (msg instanceof ZigbeeResponse) {
                        ZigbeeResponse linkResponse = (ZigbeeResponse) msg;
                        //TODO 如果配置从网关的信息，通过主网关转达，这里oid要判断下
                        if (replyTopic.equals(linkResponse.getTopic())) {
                            notifySucceed(linkResponse.getData());
                        } else {
                            notifyFailure(HDLLinkCode.HDL_TOPIC_NOT_RIGHT);
                        }
                    } else if (msg instanceof ModbusResponse) {
                        ModbusResponse response = (ModbusResponse) msg;
                        if (replyTopic.equals(response.getTopic())) {
                            notifySucceed(response.getData());
                        } else {
                            notifyFailure(HDLLinkCode.HDL_TOPIC_NOT_RIGHT);
                        }
                    } else {
                        notifyFailure(new HDLLinkCode(HDLLinkCode.HDL_OBJECT_NOT_SUPPORT.getCode(), "Object Name:" + msg));
                    }
                } catch (Exception e) {
                    notifyFailure(new HDLLinkCode(HDLLinkCode.HDL_APPLICATION_CODE.getCode(), e.getMessage()));
                }
            }
        };
        //注册监听
        registerListener();
    }

    /**
     * 发送UDP或者TCP数据(参数有mac)
     *
     * @param sendAwaitTime 每次发送等待时间
     * @param maxRetry      重试次数
     * @param ipAddress     发送目标IP
     * @param port          发送目标端口
     * @param linkRequest   发送对象
     * @param listener      回调
     * @param isTcp         是否TCP
     * @param mac           设备mac
     */
    public HDLConnectHelper(Long sendAwaitTime, int maxRetry, String ipAddress, int port,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp, String mac) {
        this(sendAwaitTime, maxRetry, ipAddress, port, linkRequest, listener, isTcp);
        this.mac = mac;
    }

    /**
     * 按照指定次数发，回调
     *
     * @param maxRetry    重试次数
     * @param ipAddress   发送目标IP
     * @param port        发送目标端口
     * @param linkRequest 发送对象
     * @param listener    回调
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(int maxRetry, String ipAddress, int port,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp) {
        this(DEF_SEND_TIMEOUT, maxRetry, ipAddress, port, linkRequest, listener, isTcp);
    }

    /**
     * 按照指定次数发，回调
     *
     * @param maxRetry    重试次数
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param listener    回调
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(int maxRetry, String ipAddress,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp) {
        this(maxRetry, ipAddress, isTcp ? TCP_PORT : UDP_PORT, linkRequest, listener, isTcp);
    }

    /**
     * 按照指定次数发，不回调
     *
     * @param maxRetry    重试次数
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(int maxRetry, String ipAddress,
                            LinkRequest linkRequest, boolean isTcp) {
        this(maxRetry, ipAddress, linkRequest, null, isTcp);
    }

    /**
     * 按照默认重发机制发送
     *
     * @param ipAddress   发送目标IP
     * @param port        发送目标端口
     * @param linkRequest 发送对象
     * @param listener    回调
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(String ipAddress, int port,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp) {
        this(DEF_MAX_RETRY, ipAddress, port, linkRequest, listener, isTcp);
    }

    /**
     * 默认端口发送
     *
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param listener    回调
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(String ipAddress,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp) {
        this(DEF_SEND_TIMEOUT, DEF_MAX_RETRY, ipAddress, isTcp ? TCP_PORT : UDP_PORT, linkRequest, listener, isTcp);
    }

    /**
     * 默认端口发送(参数有mac)
     *
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param listener    回调
     * @param isTcp       是否TCP
     * @param mac         设备mac
     */
    public HDLConnectHelper(String ipAddress,
                            LinkRequest linkRequest, HdlSocketListener listener, boolean isTcp, String mac) {
        this(DEF_SEND_TIMEOUT, DEF_MAX_RETRY, ipAddress, isTcp ? TCP_PORT : UDP_PORT, linkRequest, listener, isTcp, mac);
    }


    /**
     * 发送一次
     *
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(String ipAddress, LinkRequest linkRequest, boolean isTcp) {
        this(DEF_SEND_TIMEOUT, DEF_SEND_ONE, ipAddress, isTcp ? TCP_PORT : UDP_PORT, linkRequest, null, isTcp);
    }

    /**
     * 发送一次
     *
     * @param ipAddress   发送目标IP
     * @param linkRequest 发送对象
     * @param isTcp       是否TCP
     */
    public HDLConnectHelper(Long timeout, String ipAddress, LinkRequest linkRequest, boolean isTcp) {
        this(timeout, DEF_SEND_ONE, ipAddress, isTcp ? TCP_PORT : UDP_PORT, linkRequest, null, isTcp);
    }


    /**
     * 注册监听
     */
    private void registerListener() {
        if (!TextUtils.isEmpty(replyTopic) && null != listener) {
            EventDispatcher.getInstance().register(replyTopic, eventListener);
        }
    }

    /**
     * 移除监听
     */
    private void removeListener() {
        if (!TextUtils.isEmpty(replyTopic)) {
            EventDispatcher.getInstance().remove(replyTopic, eventListener);
        }
    }

    public static boolean isLocal() {
        String ip = HDLLinkConfig.getInstance().getIpAddress();
        if (ip == null) {
            //如是本地是可以搜索到ip的
            return false;
        }

        //本地是可以远程成功的
        return HDLTcpConnect.getTcpSocketBoot(ip).isConnected();
    }

    public void send() {

        getSendThread().scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                //发送次数小于重发次数
                if ((sendNumber.get() < maxRetry)) {
                    try {

                        //还没有收到回复，再发送
                        if (!isSend.get()) {
                            sendNumber.set(sendNumber.get() + 1);

                            //如是tcp或者mqtt
                            if (isTcp) {
                                //mqtt
                                if (TextUtils.isEmpty(ipAddress) || !HDLTcpConnect.getTcpSocketBoot(ipAddress).isConnected()) {
                                    if (!linkRequest.getTopic().endsWith("heartbeat")) {//心跳主题数据过多，过滤下
                                        //LogUtils.i("心跳包发送数据：\r\n" + new String(linkRequest.getCloudSendBytes()));
                                    } else {
                                        return;//云端情况下，心跳可以不用
                                    }
                                    String requestTopic = linkRequest.getCloudTopic();
                                    byte[] encryBytes = null;
                                    GatewayBean gatewayBean = HDLLinkLocalGateway.getInstance().getLocalGateway(mac);
                                    if (gatewayBean != null && getNotGatewayTypeList().contains(gatewayBean.getGatewayType())) {
                                        /**
                                         * 毫米波这边获取数据的时候  已经设置了主从密钥进去了 这边不作处理
                                         */
                                        encryBytes = EncryptUtil.encryBytes(linkRequest.getCloudSendBytes(), gatewayBean.getAesKey());
                                    } else {
                                        encryBytes = EncryptUtil.encryBytes(linkRequest.getCloudSendBytes(), HDLLinkConfig.getInstance().getAesKey());
                                    }
                                    if (MqttRecvClient.getInstance() != null) {
                                        MqttRecvClient.getInstance().send(requestTopic, encryBytes);
                                        if (HDLConnectHelper.isInverterTopic(linkRequest.getCloudTopic())) {
                                            LogUtils.i("远程发送数据：" + linkRequest.getCloudTopic() + "\r\n" + Arrays.toString(byteArrayConvertIntArray(linkRequest.getCloudSendBytes())));
                                        } else {
                                            LogUtils.i("远程发送数据：" + linkRequest.getCloudTopic() + "\r\n" + new String(linkRequest.getCloudSendBytes()));
                                        }
                                    }
                                }
                                //本地TCP
                                else {
                                    linkRequest.setEncrypt(false);// 2024年01月31日16:34:22 默认明文通讯,因为创建电站,绑定逆变器时，需要设置参数给逆变器,这时候还没有秘钥;
                                    if (!linkRequest.getTopic().endsWith("heartbeat")) {//心跳主题数据过多，过滤下
                                        if (HDLConnectHelper.isInverterTopic(linkRequest.getTopic())) {
                                            LogUtils.i("本地发送数据：\r\n" + Arrays.toString(byteArrayConvertIntArray(linkRequest.getSendBytes())));
                                        } else {
                                            LogUtils.i("本地发送数据：\r\n" + new String(linkRequest.getSendBytes()));
                                        }
                                    }
                                    HDLTcpConnect.getTcpSocketBoot(ipAddress).sendMsg(EncryptUtil.getEncryBytes(linkRequest));
                                }
                            } else {
                                //如果是udp
                                LogUtils.i("本地发送数据UDP：" + new String(linkRequest.getSendBytes()));
                                HDLUdpConnect.getInstance().getUdpBoot().sendMsg(ipAddress, port, EncryptUtil.getEncryBytes(linkRequest));
                            }
                        }
                    } catch (Exception e) {
                        LogUtils.e("数据发送异常：", e.getMessage());
                    }
                } else {
                    //超出重发次数并没有收到回复
                    if (!isSend.get()) {
                        if (linkRequest.getTopic().endsWith("heartbeat")) {//心跳主题先不通知
                            notifyFailure(null);
                        } else {
                            if (!TextUtils.isEmpty(replyTopic) && null != listener) {//需要打印出失败的日志
                                LogUtils.e("发送失败数据主题:" + linkRequest.getTopic());
                            }
                            if (isTcp) {
                                //mqtt
                                if (TextUtils.isEmpty(ipAddress) || !HDLTcpConnect.getTcpSocketBoot(ipAddress).isConnected()) {
                                    notifyFailure(HDLLinkCode.HDL_GATEWAY_REMOTE_NOT_RESPONSE);
                                }
                                //本地TCP，并是连接状态
                                else {
                                    notifyFailure(HDLLinkCode.HDL_TIMEOUT_ERROR);
                                }
                            } else {
                                notifyFailure(HDLLinkCode.HDL_TIMEOUT_ERROR);
                            }
                        }
                    }
                }
            }
        }, 0, sendAwaitTime, TimeUnit.MILLISECONDS);
        //initialdelay - 首次执行的延迟时间 0
        //delay - 一次执行终止和下一次执行开始之间的延迟
    }

    /**
     * 获取发送线程
     *
     * @return 返回获取到的线程
     */
    private ScheduledExecutorService getSendThread() {
        if (sendThread == null) {
            sendThread = ThreadToolUtils.getInstance().newScheduledThreadPool(1);
        }
        return sendThread;
    }

    /**
     * 发送失败
     */
    private void notifyFailure(HDLLinkCode hdlLinkCode) {
        //移除监听
        removeListener();
        if (sendThread != null) {
            sendThread.shutdownNow();
            sendThread = null;
        }
        if (listener != null && hdlLinkCode != null) {
            listener.onFailure(hdlLinkCode);
            listener = null;
        }
    }



//    /**
//     * 支持毫米类型
//     *
//     * @return 类型列表
//     */
//    public static List<String> getGatewayTypeList() {
//        List<String> typeList = new ArrayList<>();
////        typeList.add("sensor.mmv_sleep");//睡眠毫米波spk
////        typeList.add("sensor.mmv_pose");//姿态毫米波spk
//        typeList.add("energy.hdl_inverter");//逆变器spk
//        typeList.add("sensor.mmv_sleep");//睡眠毫米波spk
//        typeList.add("sensor.mmv_pose");//姿态毫米波spk
//        typeList.add("sensor.hdl_mmw_pose");//Wi-Fi毫米波ZT版本
//        return typeList;
//    }
//
//    public static List<String> getMillimeterTypeList() {
//        List<String> typeList = new ArrayList<>();
////        typeList.add("AGATEWAY");//网关
//        typeList.add("sensor.mmv_sleep");//睡眠毫米波spk
//        typeList.add("sensor.mmv_pose");//姿态毫米波spk
//        typeList.add("sensor.hdl_mmw_pose");//Wi-Fi毫米波ZT版本
//        return typeList;
//    }

    /**
     * 获取除了网关的其它网络设备，上面写的那两个方法不一致getGatewayTypeList，getMillimeterTypeList，统一了下，以免后期出问题
     * @return
     */
    public static List<String> getNotGatewayTypeList(){
        List<String> typeList = new ArrayList<>();
        typeList.add("energy.hdl_inverter");//逆变器spk
        typeList.add("sensor.mmv_sleep");//睡眠毫米波spk
        typeList.add("sensor.mmv_pose");//姿态毫米波spk
        typeList.add("sensor.hdl_mmw_pose");//Wi-Fi毫米波ZT版本
        return  typeList;
    }

    public static List<String> getNewMillimeterTypeList() {
        List<String> typeList = new ArrayList<>();
        typeList.add("sensor.hdl_mmw_pose");//Wi-Fi毫米波ZT版本
        return typeList;
    }

    private void notifySucceed(Object msg) {
        //移除监听
        removeListener();
        if (sendThread != null) {
            sendThread.shutdownNow();
            sendThread = null;
        }
        if (listener != null) {
            listener.onSucceed(msg);
            listener = null;
        }
    }



    public static boolean isInverterTopic(String topic) {
        if (TextUtils.isEmpty(topic)) {
            return false;
        }
        return topic.endsWith("custom/native/inverter/down_reply")
                || topic.endsWith("custom/native/inverter/down")
                || topic.endsWith("custom/native/inverter/up");
    }

    /**
     * byte数组转换成int数组(为了打印出无符号的btye数组数据)
     *
     * @param bytes 数组
     * @return
     */
    public static Integer[] byteArrayConvertIntArray(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return new Integer[]{};
        }
        Integer[] arr = new Integer[bytes.length];
        for (int i = 0; i < bytes.length; i++) {
            arr[i] = bytes[i] & 0xff;
        }
        return arr;
    }
}