package zhuye;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import dikuai.Dikuai;
import gecaoji.Gecaoji;
import gecaoji.lujingdraw;
import publicway.buttonset;
import zhangaiwu.Obstacledge;

/**
 * 导航预览 - 在地图上预览导航路径和已割区域
 */
public class daohangyulan {
    private static boolean active = false;
    private static Shouye shouyeInstance;
    private static Dikuai currentDikuai;
    private static Runnable returnCallback;
    
    // 导航模拟相关
    private static List<Point2D.Double> pathPoints = new ArrayList<>();
    private static int currentPathIndex = 0;
    private static double currentSpeed = 1.0; // 默认1米/秒
    private static Timer navigationTimer;
    private static double totalPathLength = 0.0;
    private static double traveledDistance = 0.0;
    private static List<Point2D.Double> mowedTrack = new ArrayList<>();
    
    // UI组件
    private static JButton exitButton;
    private static JButton speedUpButton;
    private static JButton speedDownButton;
    private static JPanel navigationButtonPanel;
    
    private daohangyulan() {
    }
    
    /**
     * 启动导航预览
     * @param shouye 主页面实例
     * @param dikuai 地块数据
     * @param callback 返回回调函数
     */
    public static void startNavigationPreview(Shouye shouye, Dikuai dikuai, Runnable callback) {
        if (shouye == null || dikuai == null) {
            return;
        }
        
        active = true;
        shouyeInstance = shouye;
        currentDikuai = dikuai;
        returnCallback = callback;
        
        // 首先获取路径坐标
        String plannedPath = dikuai.getPlannedPath();
        if (plannedPath == null || plannedPath.trim().isEmpty() || "-1".equals(plannedPath.trim())) {
            // 如果路径不存在，提示用户
            SwingUtilities.invokeLater(() -> {
                javax.swing.JOptionPane.showMessageDialog(shouye, 
                    "无法获取有效的路径坐标，请先设置地块边界坐标和割草宽度，然后生成路径规划", 
                    "提示", javax.swing.JOptionPane.WARNING_MESSAGE);
            });
            return;
        }
        
        // 解析路径坐标
        pathPoints = parsePlannedPath(plannedPath);
        if (pathPoints.isEmpty()) {
            SwingUtilities.invokeLater(() -> {
                javax.swing.JOptionPane.showMessageDialog(shouye, 
                    "路径坐标解析失败，请检查路径数据", 
                    "提示", javax.swing.JOptionPane.WARNING_MESSAGE);
            });
            return;
        }
        
        // 计算总路径长度
        totalPathLength = calculatePathLength(pathPoints);
        traveledDistance = 0.0;
        currentPathIndex = 0;
        currentSpeed = 1.0; // 默认1米/秒
        mowedTrack.clear();
        
        // 获取地块数据
        String landNumber = dikuai.getLandNumber();
        String landName = dikuai.getLandName();
        String boundary = dikuai.getBoundaryCoordinates();
        
        // 获取障碍物坐标
        String obstacles = getObstacleCoordinates(landNumber);
        
        // 获取割草宽度（转换为米）
        double mowingWidthMeters = getMowingWidthInMeters(dikuai);
        
        // 设置导航预览轨迹和宽度到MapRenderer
        MapRenderer renderer = shouye.getMapRenderer();
        if (renderer != null) {
            renderer.setNavigationPreviewTrack(new ArrayList<>());
            renderer.setNavigationPreviewWidth(mowingWidthMeters);
        }
        
        // 使用startMowingPathPreview来显示返回按钮和设置预览状态
        Runnable returnAction = () -> {
            handleReturn();
        };
        shouye.startMowingPathPreview(landNumber, landName, boundary, obstacles, plannedPath, returnAction);
        
        // 更新导航预览状态显示（在作业状态左边，间隔10像素）
        shouye.updateNavigationPreviewStatus(true);
        
        // 创建并显示导航控制按钮
        createNavigationButtons(shouye);
        
        // 初始化割草机位置到路径起点
        if (!pathPoints.isEmpty()) {
            Point2D.Double startPoint = pathPoints.get(0);
            Gecaoji mower = renderer != null ? renderer.getMower() : null;
            if (mower != null) {
                mower.setPosition(startPoint.x, startPoint.y);
            }
            // 添加起点到已割轨迹
            mowedTrack.add(new Point2D.Double(startPoint.x, startPoint.y));
            if (renderer != null) {
                renderer.addNavigationPreviewTrackPoint(new Point2D.Double(startPoint.x, startPoint.y));
            }
        }
        
        // 启动导航模拟定时器
        startNavigationSimulation(shouye, renderer, mowingWidthMeters);
        
        // 刷新地图显示
        shouye.repaint();
    }
    
    /**
     * 停止导航预览
     */
    public static void stopNavigationPreview() {
        if (!active) {
            return;
        }
        
        active = false;
        
        // 停止导航模拟定时器
        stopNavigationSimulation();
        
        // 隐藏导航控制按钮
        hideNavigationButtons();
        
        // 清除导航预览轨迹
        if (shouyeInstance != null) {
            MapRenderer renderer = shouyeInstance.getMapRenderer();
            if (renderer != null) {
                renderer.clearNavigationPreviewTrack();
            }
            
            // 更新导航预览状态显示
            shouyeInstance.updateNavigationPreviewStatus(false);
            
            // 刷新地图显示
            shouyeInstance.repaint();
        }
        
        // 执行返回回调
        if (returnCallback != null) {
            Runnable callback = returnCallback;
            returnCallback = null;
            SwingUtilities.invokeLater(callback);
        }
        
        shouyeInstance = null;
        currentDikuai = null;
        pathPoints.clear();
        mowedTrack.clear();
    }
    
    /**
     * 检查是否处于导航预览模式
     */
    public static boolean isActive() {
        return active;
    }
    
    /**
     * 处理返回按钮点击
     */
    public static void handleReturn() {
        stopNavigationPreview();
    }
    
    /**
     * 创建导航控制按钮
     */
    private static void createNavigationButtons(Shouye shouye) {
        if (shouye == null) {
            return;
        }
        
        JPanel visualizationPanel = shouye.getVisualizationPanel();
        if (visualizationPanel == null) {
            return;
        }
        
        // 创建按钮面板
        navigationButtonPanel = new JPanel();
        navigationButtonPanel.setLayout(new BoxLayout(navigationButtonPanel, BoxLayout.Y_AXIS));
        navigationButtonPanel.setOpaque(false);
        navigationButtonPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
        
        // 创建按钮
        exitButton = createNavigationButton("退出");
        exitButton.addActionListener(e -> handleReturn());
        
        speedUpButton = createNavigationButton("加速");
        speedUpButton.addActionListener(e -> {
            currentSpeed *= 2.0;
            updateSpeedDisplay(shouye);
        });
        
        speedDownButton = createNavigationButton("减速");
        speedDownButton.addActionListener(e -> {
            currentSpeed /= 2.0;
            if (currentSpeed < 0.1) {
                currentSpeed = 0.1;
            }
            updateSpeedDisplay(shouye);
        });
        
        // 垂直排列
        navigationButtonPanel.add(speedUpButton);
        navigationButtonPanel.add(Box.createRigidArea(new Dimension(0, 8)));
        navigationButtonPanel.add(speedDownButton);
        navigationButtonPanel.add(Box.createRigidArea(new Dimension(0, 8)));
        navigationButtonPanel.add(exitButton);
        
        // 设置面板大小
        navigationButtonPanel.setPreferredSize(new Dimension(80, 120));
        navigationButtonPanel.setSize(80, 120);
        
        // 添加到容器
        visualizationPanel.add(navigationButtonPanel);
        visualizationPanel.setComponentZOrder(navigationButtonPanel, 0);
        
        // 初始化位置
        SwingUtilities.invokeLater(() -> {
            updateButtonPositions(visualizationPanel);
        });
        
        // 监听缩放/调整大小
        visualizationPanel.addComponentListener(new ComponentAdapter() {
            @Override
            public void componentResized(ComponentEvent e) {
                updateButtonPositions(visualizationPanel);
            }
        });
    }
    
    private static JButton createNavigationButton(String text) {
        return buttonset.createStyledButton(text, new Color(46, 139, 87));
    }
    
    /**
     * 更新按钮位置 - 修改此处以匹配图中红框位置
     */
    private static void updateButtonPositions(Component panel) {
        if (navigationButtonPanel == null || panel == null) {
            return;
        }
        
        int panelWidth = panel.getWidth();
        int panelHeight = panel.getHeight();
        if (panelWidth <= 0 || panelHeight <= 0) {
            Component parent = panel.getParent();
            if (parent != null) {
                if (panelWidth <= 0) {
                    panelWidth = parent.getWidth();
                }
                if (panelHeight <= 0) {
                    panelHeight = parent.getHeight();
                }
            }
            if (panelWidth <= 0) {
                panelWidth = 800; // 默认宽度
            }
            if (panelHeight <= 0) {
                panelHeight = 600; // 默认高度
            }
        }
        
        // 按钮面板尺寸
        int buttonPanelWidth = 80;
        int buttonPanelHeight = 120;
        
        // 右下角位置：距离右边20像素，距离底部20像素（在缩放文字上方）
        // 缩放控制面板在右下角，有20像素的右边距和底部边距
        // 按钮面板放在缩放控制面板左侧，避免重叠
        int x = panelWidth - buttonPanelWidth - 20; // 距离右边20像素 
        
        // Y坐标计算说明：
        // 按钮面板高度为 120。
        // 为了避开底部的“缩放: 3.91x”文字（该文字通常在底部向上20-30像素处），
        // 我们将按钮面板放在距离底部约 50-60 像素的位置。
        // y = 总高度 - 按钮面板高度 - 底部预留空间
        int y = panelHeight - buttonPanelHeight - 20; // 距离底部20像素 
        
        navigationButtonPanel.setBounds(x, y, buttonPanelWidth, buttonPanelHeight);
        navigationButtonPanel.setVisible(true);
        
        // 确保层级在最前
        Component buttonParent = navigationButtonPanel.getParent();
        if (buttonParent instanceof java.awt.Container) {
            ((java.awt.Container) buttonParent).setComponentZOrder(navigationButtonPanel, 0);
        }
    }
    
    private static void hideNavigationButtons() {
        if (navigationButtonPanel != null) {
            navigationButtonPanel.setVisible(false);
            if (navigationButtonPanel.getParent() != null) {
                navigationButtonPanel.getParent().remove(navigationButtonPanel);
            }
        }
        exitButton = null;
        speedUpButton = null;
        speedDownButton = null;
        navigationButtonPanel = null;
    }
    
    private static void startNavigationSimulation(Shouye shouye, MapRenderer renderer, double mowingWidthMeters) {
        if (pathPoints.isEmpty() || renderer == null) return;
        
        if (navigationTimer != null && navigationTimer.isRunning()) {
            navigationTimer.stop();
        }
        
        navigationTimer = new Timer(100, e -> {
            if (!active) {
                stopNavigationSimulation();
                return;
            }
            if (currentPathIndex >= pathPoints.size() - 1) {
                stopNavigationSimulation();
                return;
            }
            updateNavigation(shouye, renderer, mowingWidthMeters);
        });
        navigationTimer.start();
    }
    
    private static void stopNavigationSimulation() {
        if (navigationTimer != null) {
            navigationTimer.stop();
            navigationTimer = null;
        }
    }
    
    private static void updateNavigation(Shouye shouye, MapRenderer renderer, double mowingWidthMeters) {
        if (pathPoints.isEmpty() || currentPathIndex >= pathPoints.size() - 1) {
            stopNavigationSimulation();
            return;
        }
        
        double deltaTime = 0.1;
        double moveDistance = currentSpeed * deltaTime;
        
        Point2D.Double currentPos = pathPoints.get(currentPathIndex);
        Point2D.Double nextPos = pathPoints.get(currentPathIndex + 1);
        double segmentLength = Math.hypot(nextPos.x - currentPos.x, nextPos.y - currentPos.y);
        
        if (segmentLength < 0.001) {
            currentPathIndex++;
            return;
        }
        
        Gecaoji mower = renderer.getMower();
        if (moveDistance >= segmentLength) {
            currentPathIndex++;
            traveledDistance += segmentLength;
            if (mower != null && currentPathIndex < pathPoints.size()) {
                Point2D.Double newPos = pathPoints.get(currentPathIndex);
                mower.setPosition(newPos.x, newPos.y);
                mowedTrack.add(new Point2D.Double(newPos.x, newPos.y));
                renderer.addNavigationPreviewTrackPoint(new Point2D.Double(newPos.x, newPos.y));
            }
        } else {
            double ratio = moveDistance / segmentLength;
            double newX = currentPos.x + (nextPos.x - currentPos.x) * ratio;
            double newY = currentPos.y + (nextPos.y - currentPos.y) * ratio;
            if (mower != null) {
                mower.setPosition(newX, newY);
                if (mowedTrack.isEmpty() || Math.hypot(newX - mowedTrack.get(mowedTrack.size() - 1).x, newY - mowedTrack.get(mowedTrack.size() - 1).y) > 0.05) {
                    mowedTrack.add(new Point2D.Double(newX, newY));
                    renderer.addNavigationPreviewTrackPoint(new Point2D.Double(newX, newY));
                }
            }
            traveledDistance += moveDistance;
        }
        
        updateProgressAndSpeed(shouye, renderer, mowingWidthMeters);
        shouye.repaint();
    }
    
    private static void updateProgressAndSpeed(Shouye shouye, MapRenderer renderer, double mowingWidthMeters) {
        if (shouye == null || renderer == null) return;
        double completedArea = traveledDistance * mowingWidthMeters;
        double totalArea = renderer.getTotalLandAreaSqMeters();
        if (totalArea <= 0 && currentDikuai != null) {
            try {
                String areaStr = currentDikuai.getLandArea();
                if (areaStr != null) totalArea = Double.parseDouble(areaStr.trim());
            } catch (Exception e) {}
        }
        if (totalArea > 0) {
            double percentage = Math.max(0.0, Math.min(100.0, (completedArea / totalArea) * 100.0));
            shouye.updateMowingProgress(percentage, completedArea, totalArea);
        }
        shouye.updateMowerSpeed(currentSpeed * 3.6);
    }
    
    private static void updateSpeedDisplay(Shouye shouye) {
        if (shouye != null) shouye.updateMowerSpeed(currentSpeed * 3.6);
    }
    
    private static double calculatePathLength(List<Point2D.Double> points) {
        double total = 0.0;
        for (int i = 0; i < points.size() - 1; i++) {
            total += Math.hypot(points.get(i+1).x - points.get(i).x, points.get(i+1).y - points.get(i).y);
        }
        return total;
    }
    
    private static List<Point2D.Double> parsePlannedPath(String plannedPath) {
        List<Point2D.Double> points = lujingdraw.parsePlannedPath(plannedPath);
        return points != null ? points : new ArrayList<>();
    }
    
    private static double getMowingWidthInMeters(Dikuai dikuai) {
        if (dikuai == null) return 0.4;
        try {
            String bladeWidth = dikuai.getMowingBladeWidth();
            if (bladeWidth != null && !"-1".equals(bladeWidth)) return Double.parseDouble(bladeWidth);
            String mowWidth = dikuai.getMowingWidth();
            if (mowWidth != null && !"-1".equals(mowWidth)) {
                double val = Double.parseDouble(mowWidth);
                return val > 10 ? val / 100.0 : val;
            }
        } catch (Exception e) {}
        return 0.4;
    }
    
    private static String getObstacleCoordinates(String landNumber) {
        if (landNumber == null || "-1".equals(landNumber)) return null;
        try {
            java.io.File configFile = new java.io.File("Obstacledge.properties");
            if (!configFile.exists()) return null;
            Obstacledge.ConfigManager manager = new Obstacledge.ConfigManager();
            if (!manager.loadFromFile(configFile.getAbsolutePath())) return null;
            Obstacledge.Plot plot = manager.getPlotById(landNumber.trim());
            if (plot == null) return null;
            List<Obstacledge.Obstacle> obsList = plot.getObstacles();
            if (obsList == null) return null;
            StringBuilder sb = new StringBuilder();
            for (Obstacledge.Obstacle obs : obsList) {
                String coords = obs.getXyCoordsString();
                if (coords != null && !"-1".equals(coords)) {
                    if (sb.length() > 0) sb.append(" ");
                    sb.append("(").append(coords).append(")");
                }
            }
            return sb.length() > 0 ? sb.toString() : null;
        } catch (Exception e) { return null; }
    }
}