package yaokong;

import ui.UIConfig;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.List;

public class RemoteControlDialog extends JDialog {
    private final Color THEME_COLOR;
    private boolean serialWarningShown;
    private final List<ButtonInteraction> buttonInteractions = new ArrayList<>();
    private ModernJoystickComponent moveJoystick;  // 移动摇杆（控制前进后退）
    private ModernJoystickComponent turnJoystick;  // 转向摇杆（控制左右转向）
    private JLabel speedLabel;  // 首页的速度标签引用
    private JLabel joystickValuesLabel; // 旧的顶部显示（保留以防兼容），但主要使用下面两个标签
    // 分别显示两个摇杆的数值/状态，位于各自摇杆的正上方
    private JLabel moveJoystickValueLabel;
    private JLabel turnJoystickValueLabel;
    private Timer speedUpdateTimer;  // 速度更新定时器
    // 摇杆控制定时器：持续发送控制指令
    private Timer forwardControlTimer;  // 前进/后退控制定时器
    private Timer steeringControlTimer;  // 转向控制定时器
    private int targetForwardSpeed = 0;  // 目标前进/后退速度
    private int targetSteeringSpeed = 0;  // 目标转向速度
    private List<JButton> bladeButtons = new ArrayList<>();  // 存储刀盘控制按钮，用于清理定时器
    private String bladeUpDefaultText = "刀盘升";  // 刀盘升按钮默认文字
    private String bladeDownDefaultText = "刀盘降";  // 刀盘降按钮默认文字
    
    public RemoteControlDialog(Component parent, Color themeColor, JLabel speedLabel) {
        super(parent != null ? (JFrame) SwingUtilities.getWindowAncestor(parent) : null,
              "遥控操作", false);
        this.THEME_COLOR = themeColor;
        this.speedLabel = speedLabel;
        setModalityType(ModalityType.MODELESS);
        setAlwaysOnTop(true);
        Control03.resetSpeeds();
        Control03.sendNeutralCommandIfDebugSerialOpen();
        int dialogWidth = UIConfig.DIALOG_WIDTH;  // 与首页宽度一致
        int dialogHeight = (int) (UIConfig.DIALOG_HEIGHT / 3.0 * 0.7) +150;  // 增加90像素（原40+新增40+再增10）
        initializeDialog(dialogWidth, dialogHeight);
        initializeRemoteContent();
        startSpeedUpdateTimer();  // 启动速度更新定时器
        if (parent == null) {
            setLocationRelativeTo(null); // 居中显示
        }
    }
    
    private void startSpeedUpdateTimer() {
        // 不再在首页显示“行进/转向”内容，隐藏并清空速度标签
        if (speedLabel != null) {
            speedLabel.setVisible(false);
            speedLabel.setText("");
            // 不创建速度更新定时器，避免在首页显示行进/转向信息
            speedUpdateTimer = null;
        }
    }
    
    private void initializeDialog(int width, int height) {
        setSize(width, height);
        setLocationRelativeTo(getOwner());
        setResizable(false);
        Container contentPane = getContentPane();
        if (contentPane instanceof JComponent) {
            JComponent jContentPane = (JComponent) contentPane;
            jContentPane.setBackground(new Color(0, 0, 0, 0)); // 透明背景
            jContentPane.setOpaque(false);
        }
    }
    
    private void initializeRemoteContent() {
        JPanel contentPanel = new JPanel(new BorderLayout());
        contentPanel.setBorder(BorderFactory.createEmptyBorder(16, 16, 16, 16));
        contentPanel.setOpaque(false); // 设置为透明

        // 创建顶部面板，包含按钮和数值显示
        JPanel topPanel = new JPanel(new BorderLayout());
        topPanel.setOpaque(false);
        
        // 创建按钮面板（4个按钮，间隔30像素）
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 30, 0));
        buttonPanel.setOpaque(false);
        buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0)); // 底部间距8像素
        
        // 按钮1：off.png <-> starton.png，文字：启动 <-> 熄火
        JLabel label1 = new JLabel("启动", SwingConstants.CENTER);
        label1.setFont(new Font("微软雅黑", Font.PLAIN, 12));
        label1.setForeground(new Color(40, 40, 40));
        JButton button1 = createIconButtonWithLabel("image/off.png", "image/starton.png", 27, 27, 
                                                     label1, "启动", "熄火", "POWER");
        JPanel panel1 = createButtonWithLabel(button1, label1);
        buttonPanel.add(panel1);
        
        // 按钮2：dengoff.png <-> dengon.png，文字：开灯 <-> 关灯
        JLabel label2 = new JLabel("开灯", SwingConstants.CENTER);
        label2.setFont(new Font("微软雅黑", Font.PLAIN, 12));
        label2.setForeground(new Color(40, 40, 40));
        JButton button2 = createIconButtonWithLabel("image/dengoff.png", "image/dengon.png", 30, 30,
                                                     label2, "开灯", "关灯", "LIGHT");
        JPanel panel2 = createButtonWithLabel(button2, label2);
        buttonPanel.add(panel2);
        
        // 按钮3：xia1.png（固定图标），文字：刀盘升
        JButton button3 = createBladeControlButton("image/xia1.png", "image/xia20.png", 30, 30, true);
        JLabel label3 = new JLabel("刀盘升", SwingConstants.CENTER);
        label3.setFont(new Font("微软雅黑", Font.PLAIN, 12));
        label3.setForeground(new Color(40, 40, 40));
        button3.putClientProperty("label", label3);
        button3.putClientProperty("defaultText", bladeUpDefaultText);
        bladeButtons.add(button3);  // 添加到列表以便清理
        JPanel panel3 = createButtonWithLabel(button3, label3);
        buttonPanel.add(panel3);
        
        // 按钮4：xia2.png（固定图标），文字：刀盘降
        JButton button4 = createBladeControlButton("image/xia2.png", "image/xia10.png", 30, 30, false);
        JLabel label4 = new JLabel("刀盘降", SwingConstants.CENTER);
        label4.setFont(new Font("微软雅黑", Font.PLAIN, 12));
        label4.setForeground(new Color(40, 40, 40));
        button4.putClientProperty("label", label4);
        button4.putClientProperty("defaultText", bladeDownDefaultText);
        bladeButtons.add(button4);  // 添加到列表以便清理
        JPanel panel4 = createButtonWithLabel(button4, label4);
        buttonPanel.add(panel4);
        
        topPanel.add(buttonPanel, BorderLayout.NORTH);

        // 在每个摇杆上方分别显示其状态/数值（分两列）
        JPanel valuesPanel = new JPanel(new GridLayout(1, 2, 20, 0));
        valuesPanel.setOpaque(false);

        moveJoystickValueLabel = new JLabel("前后", SwingConstants.CENTER);
        moveJoystickValueLabel.setFont(new Font("微软雅黑", Font.BOLD, 14));
        moveJoystickValueLabel.setForeground(new Color(40, 40, 40));
        moveJoystickValueLabel.setBorder(BorderFactory.createEmptyBorder(8, 4, 8, 4));
        moveJoystickValueLabel.setOpaque(false);

        turnJoystickValueLabel = new JLabel("左右", SwingConstants.CENTER);
        turnJoystickValueLabel.setFont(new Font("微软雅黑", Font.BOLD, 14));
        turnJoystickValueLabel.setForeground(new Color(40, 40, 40));
        turnJoystickValueLabel.setBorder(BorderFactory.createEmptyBorder(8, 4, 8, 4));
        turnJoystickValueLabel.setOpaque(false);

        valuesPanel.add(moveJoystickValueLabel);
        valuesPanel.add(turnJoystickValueLabel);
        topPanel.add(valuesPanel, BorderLayout.CENTER);
        
        contentPanel.add(topPanel, BorderLayout.NORTH);

        // 创建摇杆面板
        JPanel joystickPanel = new JPanel(new GridLayout(1, 2, 20, 0));
        joystickPanel.setOpaque(false);

        // 移动摇杆（绿色主题）
        moveJoystick = new ModernJoystickComponent(" ", 
            new Color(46, 204, 113), true);  // 绿色主题
        moveJoystick.setJoystickListener(new JoystickListener() {
            @Override
            public void onJoystickMoved(double x, double y) {
                // 只使用Y轴控制前进后退，向上（北）为正
                // 计算并四舍五入到整数速度值，正为前进，负为后退
                int forwardVal = (int) Math.round(-y * 100.0);
                // 限制在 [-100, 100]
                forwardVal = Math.max(-100, Math.min(100, forwardVal));

                // 更新目标速度
                targetForwardSpeed = forwardVal;

                if (Math.abs(y) > 0.1) {
                    // 摇杆不在中心位置，启动持续发送定时器
                    startForwardControlTimer();
                } else {
                    // 摇杆回到中心位置，停止发送
                    stopForwardControlTimer();
                    stopForward();
                }

                // 更新顶部显示（移动显示当前前进/后退速度，转向取当前转向速度作为参考）
                int steeringVal = Control03.getCurrentSteeringSpeed();
                updateJoystickValues(forwardVal, steeringVal);
            }
        });
        // 转向摇杆（蓝色主题）
        turnJoystick = new ModernJoystickComponent("", 
            new Color(52, 152, 219), false);  // 蓝色主题
        turnJoystick.setJoystickListener(new JoystickListener() {
            @Override
            public void onJoystickMoved(double x, double y) {
                // 只使用X轴控制左右转向，向右为正
                // 计算并四舍五入到整数转向值，正为右转，负为左转
                int steeringVal = (int) Math.round(x * 100.0);
                steeringVal = Math.max(-100, Math.min(100, steeringVal));

                // 更新目标速度
                targetSteeringSpeed = steeringVal;

                if (Math.abs(x) > 0.1) {
                    // 摇杆不在中心位置，启动持续发送定时器
                    startSteeringControlTimer();
                } else {
                    // 摇杆回到中心位置，停止发送
                    stopSteeringControlTimer();
                    stopSteering();
                }

                // 更新顶部显示（转向显示当前转向速度，移动显示当前前进速度）
                int forwardVal = Control03.getCurrentForwardSpeed();
                updateJoystickValues(forwardVal, steeringVal);
            }
        });
        joystickPanel.add(moveJoystick);
        joystickPanel.add(turnJoystick);

    // 仅显示摇杆面板（已移除下方的矩形速度显示）
    contentPanel.add(joystickPanel, BorderLayout.CENTER);

        getContentPane().add(contentPanel);
    }

    /**
     * 创建带标签的按钮面板（垂直布局：按钮在上，标签在下）
     * @param button 按钮
     * @param label 标签
     * @return 包含按钮和标签的面板
     */
    private JPanel createButtonWithLabel(JButton button, JLabel label) {
        JPanel panel = new JPanel(new BorderLayout());
        panel.setOpaque(false);
        panel.add(button, BorderLayout.CENTER);
        panel.add(label, BorderLayout.SOUTH);
        panel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
        return panel;
    }

    /**
     * 创建可切换图标的按钮（带标签文字切换）
     * @param defaultIconPath 默认图标路径
     * @param clickedIconPath 点击后的图标路径
     * @param width 图标宽度
     * @param height 图标高度
     * @param label 标签组件
     * @param defaultText 默认文字
     * @param clickedText 点击后的文字
     * @param controlType 控制指令类型："POWER"表示启动/熄火，"LIGHT"表示开灯/关灯，null表示无控制指令
     * @return 配置好的按钮
     */
    private JButton createIconButtonWithLabel(String defaultIconPath, String clickedIconPath, 
                                               int width, int height, JLabel label, 
                                               String defaultText, String clickedText, String controlType) {
        JButton button = new JButton();
        button.setPreferredSize(new Dimension(width, height));
        button.setMinimumSize(new Dimension(width, height));
        button.setMaximumSize(new Dimension(width, height));
        button.setContentAreaFilled(false);
        button.setBorderPainted(false);
        button.setFocusPainted(false);
        
        // 加载默认图标和点击图标
        ImageIcon defaultIcon = loadIcon(defaultIconPath, width, height);
        ImageIcon clickedIcon = loadIcon(clickedIconPath, width, height);
        
        if (defaultIcon != null) {
            button.setIcon(defaultIcon);
        }
        
        // 使用 clientProperty 来跟踪按钮状态（false=默认图标，true=点击图标）
        button.putClientProperty("isClicked", false);
        button.putClientProperty("defaultIcon", defaultIcon);
        button.putClientProperty("clickedIcon", clickedIcon);
        button.putClientProperty("label", label);
        button.putClientProperty("defaultText", defaultText);
        button.putClientProperty("clickedText", clickedText);
        button.putClientProperty("controlType", controlType);
        
        // 添加点击事件，切换图标和文字，并发送控制指令
        button.addActionListener(e -> {
            Boolean isClicked = (Boolean) button.getClientProperty("isClicked");
            ImageIcon defaultIconRef = (ImageIcon) button.getClientProperty("defaultIcon");
            ImageIcon clickedIconRef = (ImageIcon) button.getClientProperty("clickedIcon");
            JLabel labelRef = (JLabel) button.getClientProperty("label");
            String defaultTextRef = (String) button.getClientProperty("defaultText");
            String clickedTextRef = (String) button.getClientProperty("clickedText");
            String controlTypeRef = (String) button.getClientProperty("controlType");
            
            if (isClicked == null || !isClicked) {
                // 当前是默认图标，切换到点击图标
                if (clickedIconRef != null) {
                    button.setIcon(clickedIconRef);
                    button.putClientProperty("isClicked", true);
                }
                // 更新标签文字
                if (labelRef != null && clickedTextRef != null) {
                    labelRef.setText(clickedTextRef);
                }
                // 发送控制指令（开启）
                if ("POWER".equals(controlTypeRef)) {
                    boolean success = Control05.sendPowerOnIfDebugSerialOpen();
                    if (!success) {
                        showSerialClosedWarning();
                    }
                } else if ("LIGHT".equals(controlTypeRef)) {
                    boolean success = Control07.sendLightOnIfDebugSerialOpen();
                    if (!success) {
                        showSerialClosedWarning();
                    }
                }
            } else {
                // 当前是点击图标，切换回默认图标
                if (defaultIconRef != null) {
                    button.setIcon(defaultIconRef);
                    button.putClientProperty("isClicked", false);
                }
                // 更新标签文字
                if (labelRef != null && defaultTextRef != null) {
                    labelRef.setText(defaultTextRef);
                }
                // 发送控制指令（关闭）
                if ("POWER".equals(controlTypeRef)) {
                    boolean success = Control05.sendPowerOffIfDebugSerialOpen();
                    if (!success) {
                        showSerialClosedWarning();
                    }
                } else if ("LIGHT".equals(controlTypeRef)) {
                    boolean success = Control07.sendLightOffIfDebugSerialOpen();
                    if (!success) {
                        showSerialClosedWarning();
                    }
                }
            }
        });
        
        return button;
    }

    /**
     * 创建可切换图标的按钮
     * @param defaultIconPath 默认图标路径
     * @param clickedIconPath 点击后的图标路径
     * @param width 图标宽度
     * @param height 图标高度
     * @return 配置好的按钮
     */
    private JButton createIconButton(String defaultIconPath, String clickedIconPath, int width, int height) {
        JButton button = new JButton();
        button.setPreferredSize(new Dimension(width, height));
        button.setMinimumSize(new Dimension(width, height));
        button.setMaximumSize(new Dimension(width, height));
        button.setContentAreaFilled(false);
        button.setBorderPainted(false);
        button.setFocusPainted(false);
        
        // 加载默认图标和点击图标
        ImageIcon defaultIcon = loadIcon(defaultIconPath, width, height);
        ImageIcon clickedIcon = loadIcon(clickedIconPath, width, height);
        
        if (defaultIcon != null) {
            button.setIcon(defaultIcon);
        }
        
        // 使用 clientProperty 来跟踪按钮状态（false=默认图标，true=点击图标）
        button.putClientProperty("isClicked", false);
        button.putClientProperty("defaultIcon", defaultIcon);
        button.putClientProperty("clickedIcon", clickedIcon);
        
        // 添加点击事件，切换图标
        button.addActionListener(e -> {
            Boolean isClicked = (Boolean) button.getClientProperty("isClicked");
            ImageIcon defaultIconRef = (ImageIcon) button.getClientProperty("defaultIcon");
            ImageIcon clickedIconRef = (ImageIcon) button.getClientProperty("clickedIcon");
            
            if (isClicked == null || !isClicked) {
                // 当前是默认图标，切换到点击图标
                if (clickedIconRef != null) {
                    button.setIcon(clickedIconRef);
                    button.putClientProperty("isClicked", true);
                }
            } else {
                // 当前是点击图标，切换回默认图标
                if (defaultIconRef != null) {
                    button.setIcon(defaultIconRef);
                    button.putClientProperty("isClicked", false);
                }
            }
        });
        
        return button;
    }

    /**
     * 创建固定图标的按钮
     * @param iconPath 图标路径
     * @param width 图标宽度
     * @param height 图标高度
     * @return 配置好的按钮
     */
    private JButton createFixedIconButton(String iconPath, int width, int height) {
        JButton button = new JButton();
        button.setPreferredSize(new Dimension(width, height));
        button.setMinimumSize(new Dimension(width, height));
        button.setMaximumSize(new Dimension(width, height));
        button.setContentAreaFilled(false);
        button.setBorderPainted(false);
        button.setFocusPainted(false);
        
        ImageIcon icon = loadIcon(iconPath, width, height);
        if (icon != null) {
            button.setIcon(icon);
        }
        
        return button;
    }

    /**
     * 创建刀盘升降控制按钮（支持点击和长按）
     * @param defaultIconPath 默认图标路径
     * @param clickedIconPath 点击/长按时的图标路径
     * @param width 图标宽度
     * @param height 图标高度
     * @param isUp true表示刀盘升，false表示刀盘降
     * @return 配置好的按钮
     */
    private JButton createBladeControlButton(String defaultIconPath, String clickedIconPath, 
                                             int width, int height, boolean isUp) {
        JButton button = new JButton();
        button.setPreferredSize(new Dimension(width, height));
        button.setMinimumSize(new Dimension(width, height));
        button.setMaximumSize(new Dimension(width, height));
        button.setContentAreaFilled(false);
        button.setBorderPainted(false);
        button.setFocusPainted(false);
        
        // 加载图标
        ImageIcon defaultIcon = loadIcon(defaultIconPath, width, height);
        ImageIcon clickedIcon = loadIcon(clickedIconPath, width, height);
        
        if (defaultIcon != null) {
            button.setIcon(defaultIcon);
        }
        
        button.putClientProperty("defaultIcon", defaultIcon);
        button.putClientProperty("clickedIcon", clickedIcon);
        button.putClientProperty("isUp", isUp);
        button.putClientProperty("isPressed", false);
        
        // 长按定时器
        Timer longPressTimer = new Timer(100, e -> {  // 每100ms执行一次
            if (button.getClientProperty("isPressed") == Boolean.TRUE) {
                boolean isUpButton = (Boolean) button.getClientProperty("isUp");
                int currentHeight = Control06.getCurrentBladeHeight();
                
                // 使用Control06的方法发送指令
                boolean success;
                if (isUpButton) {
                    success = Control06.sendBladeUpIfDebugSerialOpen(1);
                } else {
                    success = Control06.sendBladeDownIfDebugSerialOpen(1);
                }
                
                if (!success) {
                    showSerialClosedWarning();
                } else {
                    // 更新按钮标签显示当前数值
                    updateBladeButtonLabel(button);
                }
            }
        });
        longPressTimer.setInitialDelay(500);  // 长按500ms后开始连续变化
        button.putClientProperty("longPressTimer", longPressTimer);  // 存储定时器引用
        
        // 鼠标按下事件
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                button.putClientProperty("isPressed", true);
                
                // 立即切换图标
                ImageIcon clickedIconRef = (ImageIcon) button.getClientProperty("clickedIcon");
                if (clickedIconRef != null) {
                    button.setIcon(clickedIconRef);
                }
                
                // 点击时立即增加/减少10，使用Control06的方法发送指令
                boolean isUpButton = (Boolean) button.getClientProperty("isUp");
                boolean success;
                if (isUpButton) {
                    success = Control06.sendBladeUpIfDebugSerialOpen(10);
                } else {
                    success = Control06.sendBladeDownIfDebugSerialOpen(10);
                }
                
                if (!success) {
                    showSerialClosedWarning();
                } else {
                    // 更新按钮标签显示当前数值
                    updateBladeButtonLabel(button);
                }
                
                // 启动长按定时器
                longPressTimer.start();
            }
            
            @Override
            public void mouseReleased(MouseEvent e) {
                button.putClientProperty("isPressed", false);
                
                // 停止长按定时器
                longPressTimer.stop();
                
                // 恢复默认图标
                ImageIcon defaultIconRef = (ImageIcon) button.getClientProperty("defaultIcon");
                if (defaultIconRef != null) {
                    button.setIcon(defaultIconRef);
                }
                
                // 恢复默认文字
                JLabel labelRef = (JLabel) button.getClientProperty("label");
                String defaultTextRef = (String) button.getClientProperty("defaultText");
                if (labelRef != null && defaultTextRef != null) {
                    labelRef.setText(defaultTextRef);
                }
            }
        });
        
        return button;
    }

    /**
     * 更新刀盘按钮标签显示当前数值
     * @param button 按钮
     */
    private void updateBladeButtonLabel(JButton button) {
        JLabel labelRef = (JLabel) button.getClientProperty("label");
        if (labelRef != null) {
            String defaultTextRef = (String) button.getClientProperty("defaultText");
            int currentHeight = Control06.getCurrentBladeHeight();
            String displayText = defaultTextRef + " " + currentHeight;
            labelRef.setText(displayText);
        }
    }

    /**
     * 加载并缩放图标
     * @param iconPath 图标路径
     * @param width 目标宽度
     * @param height 目标高度
     * @return 缩放后的图标
     */
    private ImageIcon loadIcon(String iconPath, int width, int height) {
        try {
            java.net.URL imgURL = getClass().getClassLoader().getResource(iconPath);
            if (imgURL == null) {
                // 尝试从文件系统加载
                java.io.File imgFile = new java.io.File(iconPath);
                if (imgFile.exists()) {
                    ImageIcon originalIcon = new ImageIcon(imgFile.getAbsolutePath());
                    Image scaledImage = originalIcon.getImage().getScaledInstance(width, height, Image.SCALE_SMOOTH);
                    ImageIcon scaledIcon = new ImageIcon(scaledImage);
                    scaledIcon.setDescription(iconPath);
                    return scaledIcon;
                }
            } else {
                ImageIcon originalIcon = new ImageIcon(imgURL);
                Image scaledImage = originalIcon.getImage().getScaledInstance(width, height, Image.SCALE_SMOOTH);
                ImageIcon scaledIcon = new ImageIcon(scaledImage);
                scaledIcon.setDescription(iconPath);
                return scaledIcon;
            }
        } catch (Exception e) {
            System.err.println("无法加载图标: " + iconPath + " - " + e.getMessage());
        }
        return null;
    }

    private JPanel createStatusPanel(String label, String value, Color color) {
        JPanel panel = new JPanel(new BorderLayout(0, 5));
        panel.setOpaque(false);

        JLabel titleLabel = new JLabel(label, SwingConstants.CENTER);
        titleLabel.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        titleLabel.setForeground(new Color(255, 255, 255, 180));

        JLabel valueLabel = new JLabel(value, SwingConstants.CENTER);
        valueLabel.setFont(new Font("微软雅黑", Font.BOLD, 24));
        valueLabel.setForeground(color);
        valueLabel.setOpaque(true);
        valueLabel.setBackground(new Color(0, 0, 0, 30));
        valueLabel.setBorder(BorderFactory.createCompoundBorder(
            BorderFactory.createLineBorder(new Color(255, 255, 255, 30), 2),
            BorderFactory.createEmptyBorder(10, 20, 10, 20)
        ));
        valueLabel.setPreferredSize(new Dimension(120, 60));

        panel.add(titleLabel, BorderLayout.NORTH);
        panel.add(valueLabel, BorderLayout.CENTER);

        return panel;
    }

    private void showSerialClosedWarning() {
        if (serialWarningShown) {
            return;
        }
        serialWarningShown = true;
        JOptionPane.showMessageDialog(this, "请先打开系统调试串口", "提示", JOptionPane.WARNING_MESSAGE);
    }

    private void applyForwardSpeed(int speed) {
        // 计算目标速度（范围-100到100）
        int targetSpeed = Math.max(-100, Math.min(100, speed));
        
        // 获取当前速度
        int currentSpeed = Control03.getCurrentForwardSpeed();
        
        // 如果差异较大，逐步调整
        if (Math.abs(targetSpeed - currentSpeed) > 5) {
            int delta = targetSpeed > currentSpeed ? 10 : -10;
            boolean success = Control03.adjustForwardSpeed(delta);
            if (!success) {
                showSerialClosedWarning();
                return;
            }
            serialWarningShown = false;
        }
    }

    private void stopForward() {
        if (Control03.getCurrentForwardSpeed() != 0) {
            boolean success = Control03.approachForwardSpeedToZero(20);
            if (!success) {
                showSerialClosedWarning();
                return;
            }
            serialWarningShown = false;
        }
    }

    private void applySteeringSpeed(int speed) {
        // 计算目标转向速度（范围-100到100）
        int targetSpeed = Math.max(-100, Math.min(100, speed));
        
        // 获取当前转向速度
        int currentSpeed = Control03.getCurrentSteeringSpeed();
        
        // 如果差异较大，逐步调整
        if (Math.abs(targetSpeed - currentSpeed) > 5) {
            int delta = targetSpeed > currentSpeed ? 15 : -15;
            boolean success = Control03.adjustSteeringSpeed(delta);
            if (!success) {
                showSerialClosedWarning();
                return;
            }
            serialWarningShown = false;
        }
    }

    private void stopSteering() {
        if (Control03.getCurrentSteeringSpeed() != 0) {
            boolean success = Control03.approachSteeringSpeedToZero(25);
            if (!success) {
                showSerialClosedWarning();
                return;
            }
            serialWarningShown = false;
        }
    }

    /**
     * 启动前进/后退控制定时器，持续发送控制指令
     */
    private void startForwardControlTimer() {
        // 如果定时器已经在运行，先停止它
        if (forwardControlTimer != null && forwardControlTimer.isRunning()) {
            forwardControlTimer.stop();
        }
        
        // 创建新的定时器，每100ms发送一次指令
        forwardControlTimer = new Timer(100, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 持续发送目标速度的指令
                applyForwardSpeedContinuously(targetForwardSpeed);
            }
        });
        forwardControlTimer.setInitialDelay(0);
        forwardControlTimer.start();
    }

    /**
     * 停止前进/后退控制定时器
     */
    private void stopForwardControlTimer() {
        if (forwardControlTimer != null && forwardControlTimer.isRunning()) {
            forwardControlTimer.stop();
        }
    }

    /**
     * 启动转向控制定时器，持续发送控制指令
     */
    private void startSteeringControlTimer() {
        // 如果定时器已经在运行，先停止它
        if (steeringControlTimer != null && steeringControlTimer.isRunning()) {
            steeringControlTimer.stop();
        }
        
        // 创建新的定时器，每100ms发送一次指令
        steeringControlTimer = new Timer(100, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 持续发送目标速度的指令
                applySteeringSpeedContinuously(targetSteeringSpeed);
            }
        });
        steeringControlTimer.setInitialDelay(0);
        steeringControlTimer.start();
    }

    /**
     * 停止转向控制定时器
     */
    private void stopSteeringControlTimer() {
        if (steeringControlTimer != null && steeringControlTimer.isRunning()) {
            steeringControlTimer.stop();
        }
    }

    /**
     * 持续发送前进/后退速度指令
     */
    private void applyForwardSpeedContinuously(int targetSpeed) {
        int currentSpeed = Control03.getCurrentForwardSpeed();
        int currentSteeringSpeed = Control03.getCurrentSteeringSpeed();
        
        // 如果已经达到目标速度，直接发送一次以保持状态
        if (currentSpeed == targetSpeed) {
            // 直接发送目标速度指令以保持状态（即使速度相同也要发送）
            Control03.setAndSendSpeeds(currentSteeringSpeed, targetSpeed);
        } else {
            // 逐步调整到目标速度
            int delta = targetSpeed > currentSpeed ? 10 : -10;
            Control03.adjustForwardSpeed(delta);
        }
    }

    /**
     * 持续发送转向速度指令
     */
    private void applySteeringSpeedContinuously(int targetSpeed) {
        int currentSpeed = Control03.getCurrentSteeringSpeed();
        int currentForwardSpeed = Control03.getCurrentForwardSpeed();
        
        // 如果已经达到目标速度，直接发送一次以保持状态
        if (currentSpeed == targetSpeed) {
            // 直接发送目标速度指令以保持状态（即使速度相同也要发送）
            Control03.setAndSendSpeeds(targetSpeed, currentForwardSpeed);
        } else {
            // 逐步调整到目标速度
            int delta = targetSpeed > currentSpeed ? 15 : -15;
            Control03.adjustSteeringSpeed(delta);
        }
    }

    // 更新顶部显示的摇杆数值（在 EDT 上调用），文字根据数值映射为方向描述
    private void updateJoystickValues(int forwardVal, int steeringVal) {
        // 计算移动/转向描述文本
        // 移动方向：正为前进，负为后退，0 为前后
        String moveText;
        if (forwardVal > 0) {
            moveText = String.format("前进 %d", forwardVal);
        } else if (forwardVal < 0) {
            moveText = String.format("后退 %d", Math.abs(forwardVal));
        } else {
            moveText = "前后";
        }

        // 转向方向：正为右转，负为左转，0 为左右
        String steerText;
        if (steeringVal > 0) {
            steerText = String.format("右转 %d", steeringVal);
        } else if (steeringVal < 0) {
            steerText = String.format("左转 %d", Math.abs(steeringVal));
        } else {
            steerText = "左右";
        }

    // 分别设置两个摇杆上方的文字（同时兼容旧的顶部合并标签）
    final String moveTextFinal = moveText;
    final String steerTextFinal = steerText;
        // 大部分回调来自 EDT（鼠标事件或 Swing Timer），但为安全使用 invokeLater
        SwingUtilities.invokeLater(() -> {
            if (moveJoystickValueLabel != null) moveJoystickValueLabel.setText(moveTextFinal);
            if (turnJoystickValueLabel != null) turnJoystickValueLabel.setText(steerTextFinal);
            // 兼容：同时更新旧的合并显示（如果存在）
            if (joystickValuesLabel != null) joystickValuesLabel.setText(String.format("%s    %s", moveTextFinal, steerTextFinal));
        });
    }

    /**
     * 显示对话框并仅显示移动摇杆（隐藏转向摇杆）。
     * 这个方法用于兼容旧调用点，确保外部可以请求只显示移动控制部分。
     */
    public void showOnlyMoveJoystick() {
        if (moveJoystick != null) {
            moveJoystick.setVisible(true);
        }
        if (turnJoystick != null) {
            turnJoystick.setVisible(false);
        }
        // 重新布局并刷新显示
        revalidate();
        repaint();
        // 不再显示首页速度标签（已移除“行进/转向”内容）
        // 显示对话框
        setVisible(true);
        // 尝试让对话框获得焦点
        toFront();
        requestFocus();
    }

    /**
     * 仅显示转向（左右）摇杆，隐藏移动摇杆。
     */
    public void showOnlyTurnJoystick() {
        if (moveJoystick != null) {
            moveJoystick.setVisible(false);
        }
        if (turnJoystick != null) {
            turnJoystick.setVisible(true);
        }
        revalidate();
        repaint();
        // 不再显示首页速度标签（已移除“行进/转向”内容）
        setVisible(true);
        toFront();
        requestFocus();
    }

    /**
     * 同时显示移动摇杆与转向摇杆（恢复默认视图）。
     */
    public void showBothJoysticks() {
        if (moveJoystick != null) {
            moveJoystick.setVisible(true);
        }
        if (turnJoystick != null) {
            turnJoystick.setVisible(true);
        }
        revalidate();
        repaint();
        // 不再显示首页速度标签（已移除“行进/转向”内容）
        setVisible(true);
        toFront();
        requestFocus();
    }

    @Override
    public void dispose() {
        // 停止并清理控制定时器
        stopForwardControlTimer();
        stopSteeringControlTimer();
        if (forwardControlTimer != null) {
            forwardControlTimer = null;
        }
        if (steeringControlTimer != null) {
            steeringControlTimer = null;
        }
        // 前后速度更新定时器
        if (speedUpdateTimer != null) {
            speedUpdateTimer.stop();
            speedUpdateTimer = null;
        }
        // 隐藏速度标签
        if (speedLabel != null) {
            speedLabel.setVisible(false);
            speedLabel.setText("");
        }
        for (ButtonInteraction interaction : buttonInteractions) {
            interaction.shutdown();
        }
        if (moveJoystick != null) {
            moveJoystick.dispose();
        }
        if (turnJoystick != null) {
            turnJoystick.dispose();
        }
        // 停止并清理刀盘按钮的定时器
        for (JButton bladeButton : bladeButtons) {
            Timer timer = (Timer) bladeButton.getClientProperty("longPressTimer");
            if (timer != null && timer.isRunning()) {
                timer.stop();
            }
        }
        bladeButtons.clear();
        super.dispose();
    }

    // 摇杆监听器接口
    private interface JoystickListener {
        void onJoystickMoved(double x, double y);
    }
    // 现代化摇杆组件（参考1.html风格）
    private class ModernJoystickComponent extends JPanel {
        private final String title;
        private final Color themeColor;
        private final boolean isVertical;
        private JoystickListener listener;
        private double joystickX = 0;
        private double joystickY = 0;
    // 视觉坐标：用于回中动画（不影响对外发送的逻辑数值）
    private double visualX = 0;
    private double visualY = 0;
        private boolean isDragging = false;
        // 缩小摇杆尺寸，使其在窗口中完整显示
        private final int joystickSize = 140;  // 从150缩小到100
        private final int handleSize = 60;     // 从60缩小到40
        private final int maxMoveDistance;
        private Timer returnToCenterTimer;
        
        public ModernJoystickComponent(String title, Color themeColor, boolean isVertical) {
            this.title = title;
            this.themeColor = themeColor;
            this.isVertical = isVertical;
            this.maxMoveDistance = (joystickSize - handleSize) / 2 - 10;
            
            setOpaque(false);
            // 调整组件整体大小，使摇杆更紧凑
            setPreferredSize(new Dimension(joystickSize + 40, joystickSize + 80));
            
            // 初始化回中定时器
            returnToCenterTimer = new Timer(20, new ActionListener() {
                private static final double RETURN_SPEED = 0.08;
                
                @Override
                public void actionPerformed(ActionEvent e) {
                    // 视觉回中：仅改变 visualX/visualY，不影响对外的逻辑值 joystickX/joystickY
                    if (!isDragging && (Math.abs(visualX) > 0.001 || Math.abs(visualY) > 0.001)) {
                        // 平滑回中视觉坐标
                        visualX = applyReturnForce(visualX, RETURN_SPEED);
                        visualY = applyReturnForce(visualY, RETURN_SPEED);

                        // 不在视觉回中期间向外发送非零数值（逻辑值已在释放时置0）
                        repaint();

                        // 如果视觉坐标已经接近中心，停止动画并确保为精确 0
                        if (Math.abs(visualX) < 0.001 && Math.abs(visualY) < 0.001) {
                            visualX = 0;
                            visualY = 0;
                            returnToCenterTimer.stop();
                        }
                    }
                }
            });
            returnToCenterTimer.setInitialDelay(0);
            
            addMouseListener(new MouseAdapter() {
                @Override
                public void mousePressed(MouseEvent e) {
                    isDragging = true;
                    if (returnToCenterTimer.isRunning()) {
                        returnToCenterTimer.stop();
                    }
                    updateJoystickPosition(e.getX(), e.getY());
                    // 视觉坐标随逻辑坐标同步
                    visualX = joystickX;
                    visualY = joystickY;
                    repaint();
                }
                
                @Override
                public void mouseReleased(MouseEvent e) {
                    isDragging = false;
                    // 立即把对外逻辑数值置为 0 并通知监听器，保证数值立刻为 0
                    joystickX = 0;
                    joystickY = 0;
                    if (listener != null) {
                        listener.onJoystickMoved(0, 0);
                    }

                    // 启动视觉回中动画（仅影响 visualX/visualY，不再发送监听器事件）
                    if (!returnToCenterTimer.isRunning()) {
                        returnToCenterTimer.start();
                    }
                }
            });
            
            addMouseMotionListener(new MouseMotionAdapter() {
                @Override
                public void mouseDragged(MouseEvent e) {
                    if (isDragging) {
                        updateJoystickPosition(e.getX(), e.getY());
                        // 拖动时视觉坐标与逻辑坐标同步
                        visualX = joystickX;
                        visualY = joystickY;
                        repaint();
                    }
                }
            });
        }
        
        private double applyReturnForce(double value, double speed) {
            if (value > 0) {
                return Math.max(0, value - speed);
            } else if (value < 0) {
                return Math.min(0, value + speed);
            }
            return 0;
        }
        
        private void updateJoystickPosition(int mouseX, int mouseY) {
            int centerX = joystickSize / 2 + 20;
            // 将摇杆绘制中心在组件内向下平移 5 像素（整体上移 5px）
            int centerY = joystickSize / 2 + 25;
            
            int rawDx = mouseX - centerX;
            int rawDy = mouseY - centerY;

            // 计算在圆形范围内的距离（使用原始整数位移计算距离）
            double distance = Math.sqrt((double)rawDx * rawDx + (double)rawDy * rawDy);

            // 使用 double 进行限制与缩放，避免整型截断导致最大值达不到 1.0 的问题
            double scaledDx = rawDx;
            double scaledDy = rawDy;
            if (distance > maxMoveDistance && distance > 0) {
                double factor = maxMoveDistance / distance;
                scaledDx = rawDx * factor;
                scaledDy = rawDy * factor;
            }

            // 转换为-1到1的范围（使用 double，避免精度丢失）
            joystickX = maxMoveDistance > 0 ? scaledDx / (double)maxMoveDistance : 0;
            joystickY = maxMoveDistance > 0 ? scaledDy / (double)maxMoveDistance : 0;
            
            // 根据摇杆方向调整
            if (isVertical) {
                joystickX = 0; // 竖向摇杆不处理X轴
            } else {
                joystickY = 0; // 横向摇杆不处理Y轴
            }
            
            if (listener != null) {
                listener.onJoystickMoved(joystickX, joystickY);
            }
        }
        
        public void setJoystickListener(JoystickListener listener) {
            this.listener = listener;
        }
        
        
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g;
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            
            int centerX = joystickSize / 2 + 20;
            // 与 updateJoystickPosition 保持一致：将绘制中心向下平移 5 像素（整体上移 5px）
            int centerY = joystickSize / 2 + 25;
            
            // 绘制标题
            if (title != null && !title.isEmpty()) {
                g2d.setColor(new Color(255, 255, 255, 180));
                g2d.setFont(new Font("微软雅黑", Font.BOLD, 16));
                FontMetrics fm = g2d.getFontMetrics();
                int titleWidth = fm.stringWidth(title);
                g2d.drawString(title, centerX - titleWidth / 2, 30);
            }
            
            // 绘制摇杆底座（渐变圆形）
            RadialGradientPaint baseGradient = new RadialGradientPaint(
                centerX, centerY, joystickSize / 2,
                new float[]{0.0f, 1.0f},
                new Color[]{
                    new Color(44, 62, 80),  // 深蓝灰
                    new Color(26, 37, 47)   // 更深的蓝灰
                }
            );
            g2d.setPaint(baseGradient);
            g2d.fillOval(centerX - joystickSize / 2, centerY - joystickSize / 2, 
                        joystickSize, joystickSize);
            
            // 绘制底座边框
            g2d.setColor(new Color(255, 255, 255, 20));
            g2d.setStroke(new BasicStroke(6));
            g2d.drawOval(centerX - joystickSize / 2, centerY - joystickSize / 2, 
                        joystickSize, joystickSize);
            
            // 绘制内部阴影
            g2d.setColor(new Color(0, 0, 0, 80));
            for (int i = 1; i <= 15; i++) {
                g2d.drawOval(centerX - joystickSize / 2 + i, centerY - joystickSize / 2 + i, 
                            joystickSize - 2 * i, joystickSize - 2 * i);
            }
            
            // 绘制方向指示线
            g2d.setColor(new Color(255, 255, 255, 80));
            g2d.setStroke(new BasicStroke(2));
            
            // 垂直指示线
            g2d.drawLine(centerX, centerY - joystickSize / 4, 
                        centerX, centerY + joystickSize / 4);
            // 水平指示线
            g2d.drawLine(centerX - joystickSize / 4, centerY, 
                        centerX + joystickSize / 4, centerY);
            
            // 绘制方向箭头
            g2d.setColor(new Color(255, 255, 255, 100));
            g2d.setFont(new Font("微软雅黑", Font.BOLD, 12));
            
            if (isVertical) {
                // 竖向箭头
                g2d.drawString("↑", centerX - 4, centerY - joystickSize / 2 + 20);
                g2d.drawString("↓", centerX - 4, centerY + joystickSize / 2 - 8);
            } else {
                // 横向箭头
                g2d.drawString("←", centerX - joystickSize / 2 + 12, centerY + 4);
                g2d.drawString("→", centerX + joystickSize / 2 - 16, centerY + 4);
            }
            
            // 计算摇杆手柄位置（使用视觉坐标 visualX/visualY，这样回中动画只影响视觉）
            int handleX = centerX + (int)(visualX * maxMoveDistance);
            int handleY = centerY + (int)(visualY * maxMoveDistance);
            
            // 绘制手柄阴影
            g2d.setColor(new Color(0, 0, 0, 60));
            g2d.fillOval(handleX - handleSize / 2 + 3, handleY - handleSize / 2 + 3, 
                        handleSize, handleSize);
            
            // 绘制手柄（渐变圆形）
            RadialGradientPaint handleGradient = new RadialGradientPaint(
                handleX, handleY, handleSize / 2,
                new float[]{0.0f, 0.8f, 1.0f},
                new Color[]{
                    themeColor.brighter(),
                    themeColor,
                    themeColor.darker()
                }
            );
            g2d.setPaint(handleGradient);
            g2d.fillOval(handleX - handleSize / 2, handleY - handleSize / 2, 
                        handleSize, handleSize);
            
            // 绘制手柄高光
            g2d.setColor(new Color(255, 255, 255, 100));
            g2d.fillOval(handleX - handleSize / 4, handleY - handleSize / 4, 
                        handleSize / 2, handleSize / 2);
            
            // 绘制手柄中心点
            g2d.setColor(Color.WHITE);
            g2d.fillOval(handleX - 6, handleY - 6, 12, 12);
            g2d.setColor(themeColor.darker());
            g2d.drawOval(handleX - 6, handleY - 6, 12, 12);
            
            
        }
        
        public void dispose() {
            // 清理资源
            listener = null;
            if (returnToCenterTimer != null) {
                returnToCenterTimer.stop();
                returnToCenterTimer = null;
            }
        }
    }

    // 保留原有的ButtonInteraction类，但不再使用
    private final class ButtonInteraction extends MouseAdapter {
        // ... 保持原有代码不变 ...

        public void shutdown() {
            // 保留占位实现，便于向后兼容
        }
    }
}