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;  // 速度更新定时器
    
    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) + 50 + 40;  // 增加40像素
        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);
        getContentPane().setBackground(new Color(26, 26, 46)); // 深色背景
    }
    
    private void initializeRemoteContent() {
        JPanel contentPanel = new JPanel(new BorderLayout());
        contentPanel.setBorder(BorderFactory.createEmptyBorder(16, 16, 16, 16));
        contentPanel.setBackground(Color.WHITE);

        // 在每个摇杆上方分别显示其状态/数值（分两列）
        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);
        contentPanel.add(valuesPanel, 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));

                if (Math.abs(y) > 0.1) {
                    applyForwardSpeed(forwardVal);
                } else {
                    // 前后
                    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));

                if (Math.abs(x) > 0.1) {
                    applySteeringSpeed(steeringVal);
                } else {
                    // 左右
                    stopSteering();
                }

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

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

        getContentPane().add(contentPanel);
    }

    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;
        }
    }

    // 更新顶部显示的摇杆数值（在 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() {
        // 前后速度更新定时器
        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();
        }
        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() {
            // 保留占位实现，便于向后兼容
        }
    }
}