package com.pinappletech.android.main;

import android.app.NotificationManager;
import android.content.pm.ServiceInfo;
import android.os.Handler;
import android.os.Looper;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.PowerManager;
import android.net.wifi.WifiManager;
import android.util.Log;
import android.os.Build;
import android.app.NotificationChannel;
import android.app.Notification;
import android.content.Context;
import android.os.RemoteException;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.unity3d.player.UnityPlayer;
import com.pvr.tobservice.interfaces.IToBServiceProxy;
import com.pvr.tobservice.interfaces.IIntCallback;
import com.pvr.tobservice.ToBServiceHelper;
import com.pvr.tobservice.enums.PBS_SystemInfoEnum;

import java.util.ArrayList;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

public class Main extends Service {

    private final String TAG = "PineappleService";

    // ================= UDP服务 =================
    // ip地址
    private String localIp = "0.0.0.0";
    // UDP监听端口
    private int udpReceivePort = 9988;
    private int udpSendPort = 9987;
    private DatagramSocket udpSocket;
    private boolean isRunning = false;
    // 添加缓冲区大小常量定义
    private final int bufferSize = 1024;

    private final ExecutorService networkExecutor = Executors.newFixedThreadPool(2);

    // 设备状态
    private DeviceInfo deviceInfo = null;

    // 包名映射
    private Map<String, String> packageNamesMap = new HashMap<>();
    private List<String> packageNamesList = new ArrayList<>();
    private String packageNames = "{}";

    // 服务context
    private android.content.Context serviceContext;

    // ================= 设备信息类 =================
    private class DeviceInfo {
        String ip;
        String sn;
        int power;
        int status; // 0: 离线 1: 在线 2: 游玩中
        String playing;

        DeviceInfo(String ip, String sn, int power, int status, String playing) {
            this.ip = ip;
            this.sn = sn;
            this.power = power;
            this.status = status;
            this.playing = playing;
        }
    }

    // ================= Http 服务 =================
    private ServerSocket httpServerSocket;
    private ExecutorService httpExecutor = Executors.newFixedThreadPool(4);
    private boolean httpServerRunning = false;
    private int httpPort = 9999;

    private ToBServiceHelper toBServiceHelper;

    // ================= MQTT 服务 =================
    private MqttClient mqttClient;
    private static final String MQTT_BROKER_URL = "ws://emqx.pineappletech.cn";
    private static final String MQTT_CLIENT_ID_PREFIX = "pico_";
    private ScheduledExecutorService mqttScheduler;
    private static final long MQTT_REPORT_INTERVAL = 20; // 20秒上报一次
    private static final int MQTT_KEEP_ALIVE = 60; // KeepAlive 60秒
    private static final int MQTT_CONNECTION_TIMEOUT = 30; // 连接超时30秒
    private volatile boolean isMqttReconnecting = false;
    private int mqttReconnectAttempts = 0;
    private static final int MAX_RECONNECT_ATTEMPTS = 10;
    private static final long RECONNECT_DELAY_MS = 5000; // 重连延迟5秒

    // ================= 唤醒锁 =================
    private PowerManager.WakeLock wakeLock;
    private WifiManager.WifiLock wifiLock;
    private static final String WAKE_LOCK_TAG = "PineappleService::WakeLock";

    // ================= 服务生命周期 =================
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        Log.i(TAG, "菠萝服务启动");

        // pico企业服务绑定
        toBServiceHelper = ToBServiceHelper.getInstance();
        toBServiceHelper.bindTobService(this);
        toBServiceHelper.setBindCallBack(new ToBServiceHelper.BindCallBack() {
            @Override
            public void bindCallBack(Boolean status) {
                // 绑定结果回调，绑定成功之后才能调用接口
                Log.i(TAG, "绑定pico企业服务 : " + status);
                if (status) {
                    try {
                        toBServiceHelper.getServiceBinder().pbsAppKeepAlive("com.pineapplegame.service", true, 0);
                        Log.i(TAG, "启动应用保活");
                    } catch (android.os.RemoteException e) {
                        Log.e(TAG, "启动应用保活失败: " + e.getMessage());
                    }
                }
            }
        });

        serviceContext = this;
        deviceInfo = new DeviceInfo("0.0.0.0", "未知序列号", 0, 0, "未知游戏");
        // 初始化本机IP地址
        String ip = getIpAddressFromPico();
        localIp = ip;
        deviceInfo.ip = ip;

        // 创建通知渠道
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                    "pineapple_channel",
                    "菠萝服务",
                    NotificationManager.IMPORTANCE_LOW);
            NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            manager.createNotificationChannel(channel);
        }

        Notification notification = new Notification.Builder(this, "pineapple_channel")
                .setContentTitle("菠萝服务")
                .setContentText("运行中...")
                .setSmallIcon(android.R.drawable.ic_notification_overlay)
                .build();

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
        } else {
            startForeground(1, notification);
        }

        // 启动Udp服务
        startUdpReceiver();

        // 启动Http服务
        startHttpReceiver();

        // 初始化唤醒锁
        initWakeLocks();

        // 启动MQTT服务
        initMqttService();

        // return START_STICKY;
    }

    /**
     * 初始化唤醒锁，防止设备进入 Doze 模式导致 MQTT 断线
     */
    private void initWakeLocks() {
        try {
            // 获取 PowerManager 并创建 WakeLock
            PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
            wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG);
            wakeLock.setReferenceCounted(false);
            wakeLock.acquire();
            Log.i(TAG, "唤醒锁已获取");

            // 获取 WifiManager 并创建 WifiLock
            WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
            wifiLock = wifiManager.createWifiLock(WifiManager.WIFI_MODE_FULL_HIGH_PERF, WAKE_LOCK_TAG);
            wifiLock.setReferenceCounted(false);
            wifiLock.acquire();
            Log.i(TAG, "WiFi 锁已获取");
        } catch (Exception e) {
            Log.e(TAG, "初始化唤醒锁失败: " + e.getMessage());
        }
    }

    /**
     * 释放唤醒锁
     */
    private void releaseWakeLocks() {
        try {
            if (wakeLock != null && wakeLock.isHeld()) {
                wakeLock.release();
                Log.i(TAG, "唤醒锁已释放");
            }
            if (wifiLock != null && wifiLock.isHeld()) {
                wifiLock.release();
                Log.i(TAG, "WiFi 锁已释放");
            }
        } catch (Exception e) {
            Log.e(TAG, "释放唤醒锁失败: " + e.getMessage());
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "菠萝服务停止");

        // 清理资源
        isRunning = false;
        httpServerRunning = false;

        // 关闭网络执行器
        networkExecutor.shutdownNow();

        // 关闭UDP socket
        if (udpSocket != null && !udpSocket.isClosed()) {
            udpSocket.close();
        }

        // 关闭HTTP服务器socket
        try {
            if (httpServerSocket != null && !httpServerSocket.isClosed()) {
                httpServerSocket.close();
            }
        } catch (IOException e) {
            Log.e(TAG, "关闭HTTP服务器socket时出错: " + e.getMessage());
        }

        // 关闭HTTP执行器
        if (httpExecutor != null) {
            httpExecutor.shutdownNow();
        }

        // 断开MQTT连接
        disconnectMqtt();

        // 释放唤醒锁
        releaseWakeLocks();
    }

    private String getIpAddressFromPico() {
        String ip = "0.0.0.0";
        try {
            // 尝试通过Pico的系统信息服务获取IP地址
            ip = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                    PBS_SystemInfoEnum.DEVICE_IP, 0);
            Log.i(TAG, "通过Pico服务获取到IP地址: " + ip);
        } catch (Exception e) {
            Log.e(TAG, "通过Pico服务获取IP失败: " + e.getMessage());
        }
        return ip;
    }

    // 修改 isLocalAddress 方法为 isLocalMessage，增加端口判断
    private boolean isLocalMessage(InetAddress address, int port) {
        // 只有当地址是本机IP且端口是8888时才屏蔽
        // return localIPs.contains(address.getHostAddress()) && port == localPort;
        return localIp.equals(address.getHostAddress()) && port == udpReceivePort;
    }

    // 根据包名获取应用名称
    private String getAppName(String packageName) {
        try {
            android.content.pm.PackageManager pm = getPackageManager();
            android.content.pm.ApplicationInfo appInfo = pm.getApplicationInfo(packageName, 0);
            return pm.getApplicationLabel(appInfo).toString();
        } catch (android.content.pm.PackageManager.NameNotFoundException e) {
            Log.e(TAG, "应用名称获取失败，包名: " + packageName + ", 错误: " + e.getMessage());
            return "未知应用";
        }
    }

    // 获取已安装的包名
    private void getInstalledApps() {
        try {
            // 获取包管理器
            android.content.pm.PackageManager pm = getPackageManager();
            // 获取已安装的应用列表
            java.util.List<android.content.pm.PackageInfo> packages = pm.getInstalledPackages(0);

            // 创建一个Map来存储包名和应用名称的映射
            packageNamesMap.clear();
            packageNamesList.clear();

            for (android.content.pm.PackageInfo packageInfo : packages) {
                // 过滤掉系统应用，只显示用户安装的应用
                if ((packageInfo.applicationInfo.flags & android.content.pm.ApplicationInfo.FLAG_SYSTEM) == 0) {
                    // 只保留包名中包含"pineappletech"的应用
                    if (packageInfo.packageName.contains("pineappletech")
                            && !packageInfo.packageName.contains("service")) {
                        // 获取应用名称
                        String appName = getAppName(packageInfo.packageName);
                        packageNamesMap.put(packageInfo.packageName, appName);
                        packageNamesList.add(packageInfo.packageName);
                    }
                }
            }

            // 将Map转换为指定格式的JSON数组字符串
            StringBuilder jsonBuilder = new StringBuilder();
            jsonBuilder.append("{\"apps\":[");
            boolean first = true;
            for (Map.Entry<String, String> entry : packageNamesMap.entrySet()) {
                if (!first) {
                    jsonBuilder.append(",");
                }
                // 构建 { "name": "应用名称", "address": "包名" } 格式
                jsonBuilder.append("{")
                        .append("\"name\":\"").append(entry.getValue()).append("\",")
                        .append("\"address\":\"").append(entry.getKey()).append("\"")
                        .append("}");
                first = false;
            }
            jsonBuilder.append("]}");

            Log.i(TAG, "=== 已安装的应用包名 ===");
            Log.i(TAG, "JSON格式: " + jsonBuilder.toString());
            packageNames = jsonBuilder.toString();
            Log.i(TAG, "=== 应用包名列表结束 ===");
        } catch (Exception e) {
            Log.e(TAG, "获取已安装应用列表失败: " + e.getMessage());
        }
    }

    // 处理接收到的消息
    private void handleUdpReceivedMessage(String message, InetAddress senderAddress, int senderPort) {
        Log.i(TAG, "收到消息 -> " + message);
        handleBoardcastMessage(message, senderAddress, senderPort);
    }

    private void handleBoardcastMessage(String message, InetAddress senderAddress, int senderPort) {
        // 不处理来自本机相同端口的消息
        if (isLocalMessage(senderAddress, senderPort)) {
            return;
        }

        if ("DISCOVER".equals(message)) {
            Log.i(TAG, "收到设备发现请求");
            if (deviceInfo.status == 0) {
                // 更新设备状态为在线
                deviceInfo.status = 1;
            }

            getDeviceInfoAsJson();

            // 使用主线程池来发送回复，避免并发问题
            networkExecutor.execute(() -> {
                DatagramSocket replySocket = null;
                try {
                    // 创建一个新的UDP套接字用于回复
                    replySocket = new DatagramSocket(udpSendPort);
                    // 准备回复消息，包含sn号
                    String responseMessage = deviceInfo.sn;
                    byte[] data = responseMessage.getBytes("UTF-8");
                    DatagramPacket packet = new DatagramPacket(
                            data, data.length, senderAddress, 8988);

                    replySocket.send(packet);
                    Log.i(TAG, "回复设备发现请求到: " + senderAddress.getHostAddress() + ":" + 8988);
                } catch (Exception e) {
                    Log.e(TAG, "设备发现回复失败: " + e.getMessage());
                    e.printStackTrace();
                } finally {
                    if (replySocket != null && !replySocket.isClosed()) {
                        replySocket.close();
                    }
                }
            });
        }
    }

    private void startUdpReceiver() {
        Log.i(TAG, "启动UDP接收器");
        isRunning = true;

        networkExecutor.execute(() -> {
            try {
                udpSocket = new DatagramSocket(udpReceivePort);
                udpReceivePort = udpSocket.getLocalPort(); // 记录本地端口号
                byte[] buffer = new byte[bufferSize];

                while (isRunning) {
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                    udpSocket.receive(packet);

                    String receivedData = new String(
                            packet.getData(), 0, packet.getLength()).trim();

                    // 修改为使用新的判断方法
                    if (!isLocalMessage(packet.getAddress(), packet.getPort())) {
                        handleUdpReceivedMessage(
                                receivedData,
                                packet.getAddress(),
                                packet.getPort());
                    } else {
                        Log.d(TAG, "忽略来自本机相同端口的消息: " +
                                packet.getAddress().getHostAddress() + ":" + packet.getPort());
                    }
                }
            } catch (Exception e) {
                if (isRunning) {
                    Log.e(TAG, "UDP接收错误: " + e.getMessage());
                }
            } finally {
                if (udpSocket != null && !udpSocket.isClosed()) {
                    udpSocket.close();
                }
            }
        });
    }

    // 建议callback，单独创建。防止多次调用init后，会绑定多个callback。
    public void initPicoCast() {
        try {
            int result = ToBServiceHelper.getInstance().getServiceBinder().pbsPicoCastInit(callback, 0);
            Log.i(TAG, "pico投屏初始化 " + result);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    private IIntCallback callback = new IIntCallback.Stub() {
        @Override
        public void callback(int result) throws RemoteException {
            Log.i(TAG, "pico投屏回调 " + result);
        }
    };

    private void startHttpReceiver() {
        Log.i(TAG, "启动HTTP接收器");
        httpExecutor.execute(() -> {
            try {
                httpServerSocket = new ServerSocket(httpPort);
                httpServerRunning = true;
                Log.i(TAG, "HTTP服务器启动，端口: " + httpPort);

                while (httpServerRunning) {
                    try {
                        Socket clientSocket = httpServerSocket.accept();
                        httpExecutor.execute(() -> handleHttpRequest(clientSocket));
                    } catch (IOException e) {
                        if (httpServerRunning) {
                            Log.e(TAG, "处理HTTP请求时出错: " + e.getMessage());
                        }
                    }
                }
            } catch (IOException e) {
                Log.e(TAG, "无法启动HTTP服务器: " + e.getMessage());
            }
        });
    }

    private void handleHttpRequest(Socket clientSocket) {
        try {
            java.io.BufferedReader in = new java.io.BufferedReader(
                    new java.io.InputStreamReader(clientSocket.getInputStream()));

            // 解析请求行
            String requestLine = in.readLine();
            if (requestLine == null || requestLine.isEmpty()) {
                clientSocket.close();
                return;
            }

            // 提取请求方法和路径
            String[] requestParts = requestLine.split(" ");
            String method = requestParts[0];
            String path = requestParts[1];

            Log.i(TAG, "收到HTTP请求: " + requestLine);

            // 解析请求头
            Map<String, String> headers = new HashMap<>();
            String headerLine;
            int contentLength = 0;
            while ((headerLine = in.readLine()) != null && !headerLine.isEmpty()) {
                String[] parts = headerLine.split(":", 2);
                if (parts.length == 2) {
                    headers.put(parts[0].trim(), parts[1].trim());
                    if ("Content-Length".equalsIgnoreCase(parts[0].trim())) {
                        contentLength = Integer.parseInt(parts[1].trim());
                    }
                }
            }

            // 读取请求体（如果有）
            StringBuilder body = new StringBuilder();
            if (contentLength > 0) {
                char[] buffer = new char[contentLength];
                int totalRead = 0;
                while (totalRead < contentLength) {
                    int read = in.read(buffer, totalRead, contentLength - totalRead);
                    if (read == -1)
                        break;
                    totalRead += read;
                }
                body.append(buffer, 0, totalRead);
            }

            Log.i(TAG, "请求体: " + body.toString());

            // 处理预检请求（OPTIONS）
            String responseContent = "";
            int responseCode = 200;

            if ("OPTIONS".equalsIgnoreCase(method)) {
                // 对于预检请求，直接返回成功
                responseContent = "{\"status\":\"preflight-success\"}";
            } else {
                // 根据请求路径和方法处理请求
                // 解析请求体中的JSON数据
                try {
                    org.json.JSONObject jsonBody = new org.json.JSONObject(body.toString());
                    String intent = jsonBody.optString("intent");

                    // 获取所有包信息
                    if ("getPackageInfos".equals(intent)) {
                        Log.i(TAG, "执行获取所有包信息");
                        // 修复后的代码：
                        getInstalledApps(); // 更新包信息
                        responseContent = "{\"code\":200,\"message\":\"获取成功\",\"data\":" + packageNames + "}";
                    }
                    // 播放影片
                    else if ("playFilm".equals(intent)) {
                        String packageName = jsonBody.optString("packageName");
                        Log.i(TAG, "执行播放: " + packageName);
                        // 点亮屏幕
                        try {
                            toBServiceHelper.getServiceBinder().pbsScreenOn();
                            Log.i(TAG, "屏幕点亮命令发送成功");
                        } catch (android.os.RemoteException e) {
                            Log.e(TAG, "调用pbsScreenOn失败: " + e.getMessage());
                        }
                        launchAppDirectly(packageName);
                        deviceInfo.status = 2;
                        deviceInfo.playing = packageNamesMap.get(packageName);
                        responseContent = "{\"code\":200,\"message\":\"已执行播放\"}";
                    }
                    // 停止播放
                    else if ("stopFilm".equals(intent)) {
                        Log.i(TAG, "执行停止播放");
                        // 点亮屏幕
                        try {
                            toBServiceHelper.getServiceBinder().pbsScreenOn();
                            Log.i(TAG, "屏幕点亮命令发送成功");
                        } catch (android.os.RemoteException e) {
                            Log.e(TAG, "调用pbsScreenOn失败: " + e.getMessage());
                        }
                        forceStopAllPineappleApps();
                        responseContent = "{\"code\":200,\"message\":\"已执行停止播放\"}";
                    }
                    // ping
                    else if ("ping".equals(intent)) {
                        Log.i(TAG, "执行ping");
                        responseContent = "{\"code\":200,\"message\":\"成功连接\",\"data\":\"" + getDeviceInfoAsJson()
                                + "\"}";
                    }

                } catch (org.json.JSONException e) {
                    Log.e(TAG, "解析请求体JSON失败: " + e.getMessage());
                    responseContent = "{\"status\":\"fail\",\"message\":\"解析失败\"}";
                    responseCode = 400;
                }
            }

            // 发送响应
            OutputStream out = clientSocket.getOutputStream();
            String httpResponse = "HTTP/1.1 " + responseCode + " OK\r\n" +
                    "Content-Type: application/json; charset=utf-8\r\n" +
                    "Access-Control-Allow-Origin: *\r\n" +
                    "Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS\r\n" +
                    "Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With\r\n"
                    +
                    "Access-Control-Max-Age: 3600\r\n" +
                    "Content-Length: " + responseContent.getBytes("UTF-8").length + "\r\n" +
                    "\r\n" +
                    responseContent;

            out.write(httpResponse.getBytes("UTF-8"));
            out.flush();
            out.close();
            clientSocket.close();
        } catch (

        IOException e) {
            Log.e(TAG, "处理HTTP客户端连接时出错: " + e.getMessage());
            try {
                clientSocket.close();
            } catch (IOException ioException) {
                Log.e(TAG, "关闭客户端连接时出错: " + ioException.getMessage());
            }
        }
    }

    // // 然后修改launchAppDirectly方法使用Service的Context
    // public void launchAppDirectly(String packageName) {
    // Log.i(TAG, "直接启动应用: " + packageName);
    // try {
    // // 使用Service自己的Context而不是UnityPlayer的Activity
    // if (serviceContext == null) {
    // Log.e(TAG, "Service Context为空");
    // return;
    // }

    // forceStopAllPineappleApps();

    // try {
    // Thread.sleep(500);
    // } catch (InterruptedException e) {
    // // 忽略
    // }

    // // 使用Service Context启动应用
    // android.content.Intent launchIntent = serviceContext.getPackageManager()
    // .getLaunchIntentForPackage(packageName);

    // if (launchIntent != null) {
    // // 添加传递给目标应用的参数
    // launchIntent.putExtra("service_ip", deviceInfo.ip);
    // launchIntent.putExtra("service_port", httpPort);

    // launchIntent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
    // launchIntent.addFlags(android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP);
    // launchIntent.addFlags(android.content.Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
    // launchIntent.addFlags(android.content.Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT);
    // serviceContext.startActivity(launchIntent);
    // Log.i(TAG, "成功启动应用: " + packageName);
    // } else {
    // Log.e(TAG, "无法找到应用的启动Intent: " + packageName);
    // }
    // } catch (Exception e) {
    // Log.e(TAG, "启动应用失败: " + e.getMessage());
    // e.printStackTrace();
    // }
    // }

    // 然后修改launchAppDirectly方法使用Service的Context
    public void launchAppDirectly(String packageName) {
        Log.i(TAG, "直接启动应用: " + packageName);
        try {
            // 使用Pico企业服务启动应用
            if (toBServiceHelper == null || toBServiceHelper.getServiceBinder() == null) {
                Log.e(TAG, "ToB Service Helper 或 Binder 为空");
                return;
            }

            forceStopAllPineappleApps();

            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // 忽略
            }

            // 使用Pico的企业服务API启动应用
            String action = "picovr.intent.action.player"; // 根据需要调整action
            String extra = "{\"uri\":\"/sdcard/test.mp4\",\"videoType\":0,\"videoSource\":1}"; // 这里需要根据实际需求调整参数
            String[] categories = { android.content.Intent.CATEGORY_DEFAULT };
            int[] flags = { android.content.Intent.FLAG_ACTIVITY_NEW_TASK };
            int ext = 0;

            // 如果packageName是实际的应用包名，可以用它替换action参数
            // 目前使用您提供的Pico API格式
            toBServiceHelper.getServiceBinder().pbsStartActivity(
                    packageName, // packageName
                    "com.unity3d.player.UnityPlayerActivity", // className - 留空让系统自动选择主Activity
                    action, // action
                    extra, // extra - JSON格式的额外参数
                    categories, // categories
                    flags, // flags
                    ext // ext
            );

            Log.i(TAG, "通过Pico企业服务启动应用: " + packageName + " with action: " + action);

            // 更新设备状态
            deviceInfo.status = 2;
            deviceInfo.playing = packageNamesMap.get(packageName);

        } catch (Exception e) {
            Log.e(TAG, "通过Pico服务启动应用失败: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void forceStopAllPineappleApps() {
        Log.i(TAG, "强制停止所有Pineapple应用...");

        // 准备参数
        int[] pids = {}; // 要终止的进程ID数组
        String[] packageNames = packageNamesList.toArray(new String[packageNamesList.size()]);
        int ext = 0; // 扩展参数，根据文档使用

        try {
            toBServiceHelper.getServiceBinder().pbsKillAppsByPidOrPackageName(pids, packageNames, ext);
        } catch (android.os.RemoteException e) {
            Log.e(TAG, "调用pbsKillAppsByPidOrPackageName失败: " + e.getMessage());
            e.printStackTrace();
        } catch (Exception e) {
            Log.e(TAG, "调用pbsKillAppsByPidOrPackageName时发生未知错误: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // ================= Unity通信方法 =================
    public void callUnity(String gameObjectName, String methodName, String message) {
        try {
            UnityPlayer.currentActivity.runOnUiThread(() -> {
                UnityPlayer.UnitySendMessage(gameObjectName, methodName, message);
            });
        } catch (Exception e) {
            Log.e(TAG, "调用Unity方法失败: " + e.getMessage());
        }
    }

    // ================= 静态方法（Unity调用）=================
    public static void startMyForegroundService() {
        Log.i("PineappleService", "开始启动服务...");
        try {
            Class<?> unityPlayerClass = Class.forName("com.unity3d.player.UnityPlayer");
            Field activityField = unityPlayerClass.getField("currentActivity");
            Object activity = activityField.get(null);

            Method getApplicationContextMethod = activity.getClass().getMethod("getApplicationContext");
            Context context = (Context) getApplicationContextMethod.invoke(activity);

            Intent intent = new Intent(context, Main.class);
            context.startForegroundService(intent);
        } catch (Exception e) {
            Log.e("PineappleService", "启动服务失败: " + e.getMessage());
        }
    }

    private String getDeviceInfoAsJson() {
        try {
            deviceInfo.ip = getIpAddressFromPico();
            try {
                deviceInfo.sn = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                        PBS_SystemInfoEnum.EQUIPMENT_SN,
                        0);
            } catch (android.os.RemoteException e) {
                Log.e(TAG, "获取设备序列号失败: " + e.getMessage());
                deviceInfo.sn = "未知序列号";
            }

            // 获取电量信息字符串
            String powerStr;
            try {
                powerStr = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                        PBS_SystemInfoEnum.ELECTRIC_QUANTITY,
                        0);
            } catch (android.os.RemoteException e) {
                Log.e(TAG, "获取电量信息失败: " + e.getMessage());
                powerStr = "0";
            }

            // 将字符串转换为整数
            try {
                deviceInfo.power = Integer.parseInt(powerStr);
            } catch (NumberFormatException e) {
                Log.e(TAG, "解析电量信息失败: " + powerStr + ", 错误: " + e.getMessage());
                deviceInfo.power = 0; // 默认值
            }

            org.json.JSONObject data = new org.json.JSONObject();
            data.put("ip", deviceInfo.ip);
            data.put("sn", deviceInfo.sn);
            data.put("power", deviceInfo.power);
            data.put("status", deviceInfo.status);
            data.put("playing", deviceInfo.playing);
            return data.toString().replace("\"", "\\\"");
        } catch (org.json.JSONException e) {
            Log.e(TAG, "序列化设备信息失败: " + e.getMessage());
            return "{}";
        }
    }

    // ================= MQTT 服务方法 =================

    /**
     * 初始化 MQTT 服务
     */
    private void initMqttService() {
        Log.i(TAG, "初始化 MQTT 服务...");
        mqttScheduler = Executors.newSingleThreadScheduledExecutor();
        connectToMqttBroker();
    }

    /**
     * 连接到 MQTT Broker
     */
    private void connectToMqttBroker() {
        networkExecutor.execute(() -> {
            try {
                // 获取设备序列号作为客户端ID
                String clientId = MQTT_CLIENT_ID_PREFIX + System.currentTimeMillis();
                try {
                    if (toBServiceHelper != null && toBServiceHelper.getServiceBinder() != null) {
                        String sn = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                                PBS_SystemInfoEnum.EQUIPMENT_SN, 0);
                        if (sn != null && !sn.isEmpty() && !"未知序列号".equals(sn)) {
                            clientId = MQTT_CLIENT_ID_PREFIX + sn;
                        }
                    }
                } catch (Exception e) {
                    Log.w(TAG, "获取序列号失败，使用默认客户端ID: " + e.getMessage());
                }

                mqttClient = new MqttClient(MQTT_BROKER_URL, clientId, new MemoryPersistence());

                MqttConnectOptions options = new MqttConnectOptions();
                options.setCleanSession(true);
                options.setConnectionTimeout(MQTT_CONNECTION_TIMEOUT);
                options.setKeepAliveInterval(MQTT_KEEP_ALIVE);
                options.setAutomaticReconnect(true);
                // 设置最大重连间隔为60秒
                options.setMaxReconnectDelay(60000);

                mqttClient.setCallback(new MqttCallback() {
                    @Override
                    public void connectionLost(Throwable cause) {
                        Log.e(TAG, "MQTT 连接丢失: " + cause.getMessage());
                        // 触发重连
                        scheduleMqttReconnect();
                    }

                    @Override
                    public void messageArrived(String topic, MqttMessage message) {
                        Log.i(TAG, "收到 MQTT 消息 - Topic: " + topic + ", Message: " + new String(message.getPayload()));
                    }

                    @Override
                    public void deliveryComplete(IMqttDeliveryToken token) {
                        // 消息发送完成
                    }
                });

                mqttClient.connect(options);
                Log.i(TAG, "MQTT 连接成功 - ClientID: " + clientId);
                // 重置重连计数
                mqttReconnectAttempts = 0;
                isMqttReconnecting = false;

                // 启动定时上报任务
                startMqttReportTask();

            } catch (MqttException e) {
                Log.e(TAG, "MQTT 连接失败: " + e.getMessage());
                // 连接失败也触发重连
                scheduleMqttReconnect();
            }
        });
    }

    /**
     * 调度 MQTT 重连
     */
    private void scheduleMqttReconnect() {
        if (isMqttReconnecting) {
            Log.d(TAG, "MQTT 重连已在进行中，跳过");
            return;
        }

        if (mqttReconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
            Log.e(TAG, "MQTT 重连次数超过最大限制，停止重连");
            return;
        }

        isMqttReconnecting = true;
        mqttReconnectAttempts++;

        long delay = Math.min(RECONNECT_DELAY_MS * mqttReconnectAttempts, 60000); // 最大延迟60秒
        Log.i(TAG, "MQTT 将在 " + delay + "ms 后进行第 " + mqttReconnectAttempts + " 次重连");

        networkExecutor.execute(() -> {
            try {
                Thread.sleep(delay);
                // 清理旧连接
                if (mqttClient != null) {
                    try {
                        mqttClient.disconnectForcibly();
                        mqttClient.close();
                    } catch (Exception e) {
                        // 忽略清理错误
                    }
                    mqttClient = null;
                }
                // 重新连接
                isMqttReconnecting = false;
                connectToMqttBroker();
            } catch (InterruptedException e) {
                Log.e(TAG, "MQTT 重连等待被中断: " + e.getMessage());
                isMqttReconnecting = false;
            }
        });
    }

    /**
     * 启动 MQTT 定时上报任务
     */
    private void startMqttReportTask() {
        mqttScheduler.scheduleAtFixedRate(() -> {
            try {
                if (mqttClient != null && mqttClient.isConnected()) {
                    publishDeviceStatus();
                } else {
                    Log.w(TAG, "MQTT 未连接，跳过上报");
                }
            } catch (Exception e) {
                Log.e(TAG, "MQTT 上报任务异常: " + e.getMessage());
            }
        }, 0, MQTT_REPORT_INTERVAL, TimeUnit.SECONDS);
        Log.i(TAG, "MQTT 定时上报任务已启动，间隔: " + MQTT_REPORT_INTERVAL + " 秒");
    }

    /**
     * 发布设备状态到 MQTT
     */
    private void publishDeviceStatus() {
        try {
            // 更新设备信息
            String deviceJson = getDeviceInfoAsJsonForMqtt();
            String topic = "device/" + deviceInfo.sn + "/status";

            MqttMessage message = new MqttMessage(deviceJson.getBytes("UTF-8"));
            message.setQos(0);
            message.setRetained(false);

            mqttClient.publish(topic, message);
            Log.d(TAG, "MQTT 上报成功 - Topic: " + topic);

        } catch (Exception e) {
            Log.e(TAG, "MQTT 上报失败: " + e.getMessage());
        }
    }

    /**
     * 获取设备信息 JSON（用于 MQTT 上报）
     */
    private String getDeviceInfoAsJsonForMqtt() {
        try {
            deviceInfo.ip = getIpAddressFromPico();
            try {
                deviceInfo.sn = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                        PBS_SystemInfoEnum.EQUIPMENT_SN, 0);
            } catch (android.os.RemoteException e) {
                Log.e(TAG, "获取设备序列号失败: " + e.getMessage());
                deviceInfo.sn = "未知序列号";
            }

            // 获取电量信息字符串
            String powerStr;
            try {
                powerStr = toBServiceHelper.getServiceBinder().pbsStateGetDeviceInfo(
                        PBS_SystemInfoEnum.ELECTRIC_QUANTITY, 0);
            } catch (android.os.RemoteException e) {
                Log.e(TAG, "获取电量信息失败: " + e.getMessage());
                powerStr = "0";
            }

            // 将字符串转换为整数
            try {
                deviceInfo.power = Integer.parseInt(powerStr);
            } catch (NumberFormatException e) {
                Log.e(TAG, "解析电量信息失败: " + powerStr + ", 错误: " + e.getMessage());
                deviceInfo.power = 0;
            }

            org.json.JSONObject data = new org.json.JSONObject();
            data.put("ip", deviceInfo.ip);
            data.put("sn", deviceInfo.sn);
            data.put("power", deviceInfo.power);
            data.put("status", deviceInfo.status);
            data.put("playing", deviceInfo.playing);
            data.put("timestamp", System.currentTimeMillis());
            return data.toString();
        } catch (org.json.JSONException e) {
            Log.e(TAG, "序列化设备信息失败: " + e.getMessage());
            return "{}";
        }
    }

    /**
     * 断开 MQTT 连接
     */
    private void disconnectMqtt() {
        try {
            if (mqttScheduler != null) {
                mqttScheduler.shutdownNow();
                Log.i(TAG, "MQTT 定时任务已停止");
            }

            if (mqttClient != null && mqttClient.isConnected()) {
                mqttClient.disconnect();
                mqttClient.close();
                Log.i(TAG, "MQTT 连接已断开");
            }
        } catch (MqttException e) {
            Log.e(TAG, "断开 MQTT 连接失败: " + e.getMessage());
        }
    }
}