package com.ard.work.component.websocket.handler;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.ard.common.core.domain.model.LoginUser;
import com.ard.framework.web.service.TokenService;
import com.ard.work.component.websocket.WebSocketSessionManager;
import com.ard.work.domain.enums.MessageType;
import com.ard.work.domain.message.*;
import com.ard.work.service.control.UavControlService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import javax.annotation.Resource;
import java.util.concurrent.CompletableFuture;


@Component
@Slf4j
public class TyMessageHandler extends TextWebSocketHandler {

    @Resource
    private UavControlService uavControlService;
    @Resource
    private UavStreamManager uavStreamManager;
    @Resource
    private UavStateManager uavStateManager;
    @Resource
    private UavTelemetryManager uavTelemetryManager;
    @Resource
    private UavSignalManager uavSignalManager;
    @Resource
    private UavControlManager uavControlManager;
    @Resource
    private UavAllManager uavAllManager;
    @Resource
    private TokenService tokenService;

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        try {
            String userIdStr = (String) session.getAttributes().get("userId");
            Long userId = Long.parseLong(userIdStr);
            String payload = message.getPayload();
            log.info("【cmd】Received message: {}", payload);
            log.info("【cmd】size: {}", WebSocketSessionManager.getOnlineUserCount());
            BaseMessage<?> baseMessage = JSON.parseObject(payload, BaseMessage.class);
            MessageType messageType = MessageType.fromString(baseMessage.getType());
            switch (messageType) {
                case STREAM:
                    handleStreamMessage(payload, userId);
                    break;
                case STATE:
                    handleStateMessage(payload, userId);
                    break;
                case TELEMETRY:
                    handleTelemetryMessage(payload, userId);
                    break;
                case SIGNAL:
                    handleSignalMessage(payload, userId);
                    break;
                case CONTROLLER:
                    handleControlMessage(payload, userId);
                    break;
                case ALL:
                    handleAllMessage(payload, userId);
                    break;
            }
        } catch (Exception e) {
            log.error("Error handling message: {}", message, e);
        }
    }

    /**
     * 处理流消息
     * <p>
     * 该方法解析给定的负载数据，以获取无人机流消息，并根据消息类型决定是否开始或停止流
     *
     * @param payload 消息的负载数据，通常为JSON字符串
     * @param userId  接收消息的用户ID
     */
    private void handleStreamMessage(String payload, Long userId) {
        // 解析JSON负载数据为BaseMessage对象，包含UavStreamMessage类型的有效载荷
        BaseMessage<UavStreamMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavStreamMessage>>() {
                });
        UavStreamMessage uavStreamMessage = baseMessage.getPayload();

        // 检查解析后的UavStreamMessage对象是否非空
        if (uavStreamMessage != null) {
            String boxSn = uavStreamMessage.getBoxSn();

            // 根据Subscribe决定操作类型：true表示开始拉流，false表示停止拉流
            if (uavStreamMessage.getSubscribe()) {
                uavStreamManager.subscribe(boxSn, userId);
            } else {
                uavStreamManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理状态消息
     * 根据接收到的消息内容，决定无人机状态信息的订阅或退订
     *
     * @param payload 消息负载，包含订阅信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleStateMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavStateMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavStateMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavStateMessage uavStateMessage = baseMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavStateMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavStateMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavStateMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavStateManager.subscribe(boxSn, userId, 1);
            } else {
                // 执行退订操作
                uavStateManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理遥测消息
     * 根据接收到的消息内容，决定无人机状态信息的订阅或退订
     *
     * @param payload 消息负载，包含订阅信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleTelemetryMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavTelemetryMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavTelemetryMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavTelemetryMessage uavTelemetryMessage = baseMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavTelemetryMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavTelemetryMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavTelemetryMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavTelemetryManager.subscribe(boxSn, userId, 1);
            } else {
                // 执行退订操作
                uavTelemetryManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理信号质量
     * 根据接收到的消息内容，决定无人机信号质量信息的订阅或退订
     *
     * @param payload 消息负载，包含订阅信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleSignalMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavSignalMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavSignalMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavSignalMessage uavSignalMessage = baseMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavSignalMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavSignalMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavSignalMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavSignalManager.subscribe(boxSn, userId, 2);
            } else {
                // 执行退订操作
                uavSignalManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理无人机控制者
     * 根据接收到的消息内容，决定无人机控制者信息的订阅或退订
     *
     * @param payload 消息负载，包含控制信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleControlMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavControlMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavControlMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavControlMessage uavControlMessage = baseMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavControlMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavControlMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavControlMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavControlManager.subscribe(boxSn, userId, 2);
            } else {
                // 执行退订操作
                uavControlManager.unsubscribe(boxSn, userId);
            }
        }
    }

    private void handleAllMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavAllMessage> baseMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavAllMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavAllMessage uavAllMessage = baseMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavAllMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavAllMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavAllMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavAllManager.subscribe(boxSn, userId, 1);
            } else {
                // 执行退订操作
                uavAllManager.unsubscribe(boxSn, userId);
            }
        }
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) {
        log.info("【cmd】Connected: {}", session.getId());
        String userIdStr = (String) session.getAttributes().get("userId");
        if (userIdStr == null || userIdStr.isBlank()) {
            return;
        }
        Long userId = Long.parseLong(userIdStr);
        WebSocketSessionManager.addSession(userId, session);
        log.info("【cmd】size: {}", WebSocketSessionManager.getOnlineUserCount());
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
        log.info("【cmd】Disconnected: {}", session.getId());
        String userIdStr = (String) session.getAttributes().get("userId");
        if (userIdStr == null || userIdStr.isBlank()) {
            return;
        }
        Long userId = Long.parseLong(userIdStr);
        WebSocketSessionManager.removeSession(userId);
        log.info("【cmd】size: {}", WebSocketSessionManager.getOnlineUserCount());

        // 释放该用户所有 UAV 控制权
        uavControlService.releaseAllControls(userId);
        uavStreamManager.stopAllPullStreamByUser(userId);
        uavStateManager.removeSubscribe(userId);
        uavTelemetryManager.removeSubscribe(userId);
        uavSignalManager.removeSubscribe(userId);
        uavControlManager.removeSubscribe(userId);

        // 延迟10秒删除token（若期间没重连）
        CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(10_000); // 延迟10秒
            } catch (InterruptedException ignored) {}

            if (!WebSocketSessionManager.containsUser(userId)) {
                LoginUser loginUser = tokenService.getLoginUserByUserId(userId);
                if (loginUser != null) {
                    tokenService.delLoginUser(loginUser.getToken(), userId);
                    log.info("【cmd】用户 [{}] 超时未重连，已删除 token", userId);
                }
            }
        });
    }
}