package com.aros.apron.tools;


import android.annotation.SuppressLint;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;

import com.aros.apron.app.ApronApp;
import com.aros.apron.callback.MqttActionCallBack;
import com.aros.apron.callback.MqttCallBack;
import com.aros.apron.constant.AMSConfig;

import org.eclipse.paho.android.service.MqttAndroidClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;

import java.util.Random;

public class MqttManager {

    public MqttAndroidClient mqttAndroidClient; //ltz change
    public MqttConnectOptions mMqttConnectOptions;
    String TAG = getClass().getSimpleName();

    private MqttManager() {
    }

    private static class MqttHolder {
        private static final MqttManager INSTANCE = new MqttManager();
    }

    public static MqttManager getInstance() {
        return MqttHolder.INSTANCE;
    }

    public void needConnect() {
        initMqttClientParams();
    }

    private void initMqttClientParams() {
        mqttAndroidClient = new MqttAndroidClient(ApronApp.Companion.getApplication(), AMSConfig.getInstance().getMqttServerUri(), generateRandomString(10));
        mMqttConnectOptions = new MqttConnectOptions();
        mMqttConnectOptions.setAutomaticReconnect(true); //ltz add
        mMqttConnectOptions.setMaxInflight(1000);// 增加最大并发未确认消息数量
        mMqttConnectOptions.setCleanSession(true); //设置是否清除缓存
        mMqttConnectOptions.setConnectionTimeout(30); //设置超时时间，单位：秒 ltz denote
        mMqttConnectOptions.setKeepAliveInterval(20); //设置心跳包发送间隔，单位：秒 ltz denote
        mMqttConnectOptions.setUserName(AMSConfig.getInstance().getUserName()); //设置用户名
        mMqttConnectOptions.setPassword(AMSConfig.getInstance().getPassword().toCharArray()); //设置密码
        mqttAndroidClient.setCallback(new MqttCallBack()); //设置监听订阅消息的回调
        doClientConnection();
    }



    /**
     * 连接MQTT服务器
     */
    private void doClientConnection() {
        if (mqttAndroidClient.isConnected()) {
            return;
        }
        // 先检查网络状态（仅用于日志和延迟策略，不阻塞连接尝试）
        boolean networkAvailable = isConnectIsNomarl();
        if (networkAvailable) {
            tryConnect();
        } else {
            // 网络检查未通过时，仍尝试连接（防止网络误判导致永久断连）
            LogUtil.log(TAG, "网络检查未通过，但仍尝试连接");
            tryConnect();
        }
    }

    private void tryConnect() {
        if (mqttAndroidClient.isConnected()) {
            return;
        }
        try {
            mqttAndroidClient.connect(mMqttConnectOptions, null, new MqttActionCallBack(mqttAndroidClient, mMqttConnectOptions));
        } catch (MqttException e) {
            LogUtil.log(TAG, "mqtt连接异常:" + e.toString());
            e.printStackTrace();
        }
    }

    /**
     * 判断网络是否连接（仅做日志记录，不阻塞连接尝试）
     */
    private boolean isConnectIsNomarl() {
        ConnectivityManager connectivityManager = (ConnectivityManager) ApronApp.Companion.getApplication().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            Network network = connectivityManager.getActiveNetwork();
            if (network != null) {
                NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
                if (capabilities != null) {
                    String transportInfo;
                    if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
                        transportInfo = "ETHERNET";
                    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                        transportInfo = "WIFI";
                    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                        transportInfo = "CELLULAR";
                    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
                        transportInfo = "VPN";
                    } else {
                        transportInfo = "OTHER";
                    }
                    LogUtil.log(TAG, "当前网络可用：" + transportInfo);
                    return true;
                }
            }
            LogUtil.log(TAG, "没有可用Mqtt网络（API 23+）");
            return false;
        } else {
            @SuppressLint("MissingPermission") NetworkInfo info = connectivityManager.getActiveNetworkInfo();
            if (info != null && info.isAvailable()) {
                String name = info.getTypeName();
                LogUtil.log(TAG, "当前网络名称：" + name);
                return true;
            } else {
                LogUtil.log(TAG, "没有可用Mqtt网络");
                return false;
            }
        }
    }


    private String generateRandomString(int length) {
        String characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        StringBuilder builder = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            int index = random.nextInt(characters.length());
            builder.append(characters.charAt(index));
        }
        return builder.toString();
    }
}