package com.hwtd.mes.collect.config;

import com.hwtd.mes.collect.handler.SerialPortListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.annotation.PreDestroy;
import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.JWindow;
import javax.swing.KeyStroke;
import javax.swing.SwingConstants;
import javax.swing.Timer;
import javax.swing.WindowConstants;
import java.awt.AWTException;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Desktop;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.SystemTray;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * 系统托盘图标：exe（或 jar）启动后在任务栏右下角托盘常驻一个小图标，右键菜单可以快速退出。
 * <p>
 * 说明：
 * <ul>
 *     <li>托盘依赖 AWT，而 Spring Boot 默认 {@code java.awt.headless=true}（此时 {@link SystemTray#isSupported()} 为 false），
 *         所以启动类里已经用 {@code setHeadless(false)} 关掉；</li>
 *     <li>右键菜单用 Swing 自己画一个无边框窗口（{@link JWindow}），不用 AWT 的 PopupMenu：
 *         AWT 菜单是 Windows 原生菜单，文字用系统菜单字体绘制，部分机器上不含中文字形会显示成方块，而且 {@code setFont} 不生效；</li>
 *     <li>菜单弹出位置和系统托盘菜单一致：显示在光标上方、右边缘与光标对齐，并保证不超出屏幕（多显示器时按光标所在屏幕计算）；</li>
 *     <li>菜单收起方式：点击菜单外面（窗口失焦）、按 ESC、再右键一次、点了某一项之后，
 *         另外还有一层兜底——鼠标离开菜单附近也会自动收起（避免个别环境窗口抢不到焦点导致菜单关不掉）；</li>
 *     <li>菜单里的“查看串口状态”（或双击托盘图标）会弹出一个状态窗口：串口名称、监听状态、串口连接、缓存条数，每秒自动刷新；</li>
 *     <li>菜单里的“关闭串口”只关闭串口监听（不退出程序），方便现场把串口释放给别的程序用，结果用托盘气泡提示；</li>
 *     <li>图标优先读取 classpath 下的 {@code tray.png}（放一张 32x32 的 png 即可换成自己的图标），没有就用代码画的默认图标；</li>
 *     <li>点“退出”会先关闭 Spring 容器（触发 {@code @PreDestroy}，例如关闭串口监听、停止补帧线程），再结束进程；
 *         用任务管理器结束进程、或直接关掉 exe 的控制台窗口，则不会走这套清理流程；</li>
 *     <li>以 Windows 服务（Session 0，无桌面）方式运行时托盘不会显示，代码会自动跳过，不影响接口使用。</li>
 * </ul>
 */
@Slf4j
@Component
public class SystemTrayInitializer implements ApplicationRunner {

    /** 默认图标尺寸 */
    private static final int DEFAULT_ICON_SIZE = 32;
    /** 菜单背景色 */
    private static final Color MENU_BACKGROUND = Color.WHITE;
    /** 菜单项鼠标悬停背景色 */
    private static final Color MENU_HOVER_BACKGROUND = new Color(0xE8F0FE);
    /** 菜单边框颜色 */
    private static final Color MENU_BORDER = new Color(0xC8C8C8);

    @Value("${server.port:9527}")
    private int serverPort;

    @Value("${logging.file-location:logs}")
    private String logLocation;

    private final ApplicationContext applicationContext;

    /** 托盘图标，退出时先移除 */
    private TrayIcon trayIcon;

    /** 右键菜单窗口，第一次右键时创建 */
    private JWindow popupWindow;

    /** 状态窗口，第一次点“查看采集状态”时创建 */
    private JDialog statusDialog;

    /** 状态窗口的自动刷新定时器（每秒刷新一次） */
    private Timer statusRefreshTimer;

    /** 状态窗口里的值 */
    private JLabel serialPortNameValue;
    private JLabel listeningValue;
    private JLabel portOpenValue;
    private JLabel dataSizeValue;

    /** 兜底收起检查：万一菜单窗口没抢到焦点，鼠标离开菜单后也能自动收起 */
    private Timer popupWatchdog;

    /** 弹出菜单时的光标位置（托盘图标位置） */
    private Point popupAnchor;

    /** 光标连续几次不在菜单附近 */
    private int outsideCount;

    public SystemTrayInitializer(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Override
    public void run(ApplicationArguments args) {
        if (!SystemTray.isSupported()) {
            log.warn("当前环境不支持系统托盘（headless 模式、无桌面会话或缺少 java.desktop 模块），跳过托盘图标");
            return;
        }
        try {
            // AWT/Swing 组件统一在事件分发线程（EDT）里创建
            EventQueue.invokeAndWait(this::createTrayIcon);
        } catch (Exception e) {
            log.error("创建系统托盘图标失败：{}", e.getMessage(), e);
        }
    }

    /**
     * 创建托盘图标，并注册鼠标事件：右键弹菜单、左键双击打开采集状态
     */
    private void createTrayIcon() {
        trayIcon = new TrayIcon(loadTrayImage(), "亨旺特导MES数据采集器");
        trayIcon.setImageAutoSize(true);
        trayIcon.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent event) {
                if (event.isPopupTrigger() || event.getButton() == MouseEvent.BUTTON3) {
                    showPopupWindow();
                }
            }

            @Override
            public void mouseClicked(MouseEvent event) {
                if (event.getButton() == MouseEvent.BUTTON1 && event.getClickCount() >= 2) {
                    showStatusDialog();
                }
            }
        });

        try {
            SystemTray.getSystemTray().add(trayIcon);
            log.info("系统托盘图标已启动，右键托盘图标可以退出程序（端口 {}）", serverPort);
        } catch (AWTException e) {
            log.error("添加系统托盘图标失败：{}", e.getMessage(), e);
        }
    }

    /**
     * 在光标位置弹出右键菜单；已经弹着就收起来
     */
    private void showPopupWindow() {
        Point mouse = MouseInfo.getPointerInfo() == null ? null : MouseInfo.getPointerInfo().getLocation();
        if (mouse == null) {
            return;
        }
        JWindow window = ensurePopupWindow(mouse);
        if (window.isVisible()) {
            hidePopupWindow();
            return;
        }
        Rectangle screen = screenConfigurationOf(mouse).getBounds();
        Dimension size = window.getSize();
        // 和系统托盘菜单一样：显示在光标上方，右边缘与光标对齐
        int x = mouse.x - size.width;
        int y = mouse.y - size.height - 2;
        if (y < screen.y) {
            // 上方放不下（例如任务栏在顶部）就放到光标下方
            y = mouse.y + 12;
        }
        // 保证菜单完整显示在屏幕内
        x = Math.max(screen.x, Math.min(x, screen.x + screen.width - size.width));
        y = Math.max(screen.y, Math.min(y, screen.y + screen.height - size.height));

        window.setLocation(x, y);
        window.setVisible(true);
        window.toFront();
        window.requestFocus();
        startPopupWatchdog(mouse);
    }

    /**
     * 收起右键菜单
     */
    private void hidePopupWindow() {
        stopPopupWatchdog();
        JWindow window = popupWindow;
        if (window != null && window.isVisible()) {
            window.setVisible(false);
        }
    }

    /**
     * 启动兜底收起检查：正常情况下点击别处窗口失焦就会收起，
     * 万一窗口没抢到焦点（部分环境会这样），靠鼠标离开菜单附近也能收起。
     */
    private void startPopupWatchdog(Point anchor) {
        stopPopupWatchdog();
        popupAnchor = anchor;
        outsideCount = 0;
        popupWatchdog = new Timer(250, event -> checkPopupDismiss());
        // 留一点时间给用户从托盘图标移动到菜单上
        popupWatchdog.setInitialDelay(600);
        popupWatchdog.start();
    }

    /**
     * 兜底检查：光标既不在菜单上、也不在托盘图标附近时，连续两次就收起菜单
     */
    private void checkPopupDismiss() {
        JWindow window = popupWindow;
        if (window == null || !window.isVisible()) {
            stopPopupWatchdog();
            return;
        }
        Point mouse = MouseInfo.getPointerInfo() == null ? null : MouseInfo.getPointerInfo().getLocation();
        if (mouse == null) {
            return;
        }
        boolean nearMenu = window.getBounds().contains(mouse);
        boolean nearAnchor = popupAnchor != null && popupAnchor.distance(mouse) < 80;
        if (nearMenu || nearAnchor) {
            outsideCount = 0;
            return;
        }
        if (++outsideCount >= 2) {
            hidePopupWindow();
        }
    }

    private void stopPopupWatchdog() {
        if (popupWatchdog != null) {
            popupWatchdog.stop();
            popupWatchdog = null;
        }
        outsideCount = 0;
    }

    /**
     * 菜单窗口按屏幕创建：多显示器时创建在光标所在的那块屏幕上
     */
    private JWindow ensurePopupWindow(Point mouse) {
        GraphicsConfiguration configuration = screenConfigurationOf(mouse);
        if (popupWindow == null || popupWindow.getGraphicsConfiguration() != configuration) {
            if (popupWindow != null) {
                popupWindow.dispose();
            }
            popupWindow = createPopupWindow(configuration);
        }
        return popupWindow;
    }

    /**
     * 创建菜单窗口：无边框、置顶、可获取焦点（点别处失焦就能自动收起）
     */
    private JWindow createPopupWindow(GraphicsConfiguration configuration) {
        Font menuFont = resolveMenuFont();

        JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
        panel.setBackground(MENU_BACKGROUND);
        panel.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLineBorder(MENU_BORDER),
                BorderFactory.createEmptyBorder(4, 0, 4, 0)));
        panel.add(createMenuItem("查看串口状态", menuFont, e -> showStatusDialog()));
        panel.add(createMenuItem("关闭串口监听", menuFont, e -> closeSerialPort()));
        panel.add(createMenuItem("打开日志目录", menuFont, e -> openLogDirectory()));
        panel.add(createSeparator());
        panel.add(createMenuItem("退出", menuFont, e -> exit()));

        // 按 ESC 收起菜单
        panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "hidePopupWindow");
        panel.getActionMap().put("hidePopupWindow", new AbstractAction() {
            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent event) {
                hidePopupWindow();
            }
        });

        JWindow window = new JWindow(configuration);
        window.setContentPane(panel);
        window.setAlwaysOnTop(true);
        window.setFocusable(true);
        // 关键：窗口必须能获得焦点，点菜单外面时才会触发失焦、菜单才会自动收起
        window.setFocusableWindowState(true);
        window.addWindowFocusListener(new WindowAdapter() {
            @Override
            public void windowLostFocus(WindowEvent event) {
                hidePopupWindow();
            }
        });
        window.addWindowListener(new WindowAdapter() {
            @Override
            public void windowDeactivated(WindowEvent event) {
                hidePopupWindow();
            }
        });
        window.pack();
        return window;
    }

    /**
     * 菜单项：扁平按钮 + 悬停高亮
     */
    private JButton createMenuItem(String text, Font font, ActionListener actionListener) {
        JButton item = new JButton(text);
        item.setFont(font);
        item.setHorizontalAlignment(SwingConstants.LEFT);
        item.setBorder(BorderFactory.createEmptyBorder(6, 18, 6, 24));
        item.setBorderPainted(false);
        item.setFocusPainted(false);
        item.setContentAreaFilled(false);
        item.setOpaque(true);
        item.setBackground(MENU_BACKGROUND);
        item.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        item.setMaximumSize(new Dimension(Integer.MAX_VALUE, item.getPreferredSize().height));
        item.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent event) {
                item.setBackground(MENU_HOVER_BACKGROUND);
            }

            @Override
            public void mouseExited(MouseEvent event) {
                item.setBackground(MENU_BACKGROUND);
            }
        });
        item.addActionListener(event -> {
            // 先收起菜单，再执行动作
            hidePopupWindow();
            actionListener.actionPerformed(event);
        });
        return item;
    }

    /**
     * 菜单分隔线
     */
    private JSeparator createSeparator() {
        JSeparator separator = new JSeparator();
        separator.setForeground(MENU_BORDER);
        separator.setMaximumSize(new Dimension(Integer.MAX_VALUE, 1));
        return separator;
    }

    /**
     * @return 光标所在屏幕的显示配置，找不到就用主屏幕
     */
    private GraphicsConfiguration screenConfigurationOf(Point point) {
        GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
        for (GraphicsDevice device : environment.getScreenDevices()) {
            GraphicsConfiguration configuration = device.getDefaultConfiguration();
            if (configuration.getBounds().contains(point)) {
                return configuration;
            }
        }
        return environment.getDefaultScreenDevice().getDefaultConfiguration();
    }

    /**
     * 退出程序：先关闭 Spring 容器（触发 @PreDestroy，关闭串口、停止补帧线程），再结束进程
     */
    private void exit() {
        log.info("从系统托盘退出程序");
        removeTrayIcon();
        int exitCode = SpringApplication.exit(applicationContext, () -> 0);
        System.exit(exitCode);
    }

    /**
     * 项目停止时移除托盘图标、销毁菜单窗口
     */
    @PreDestroy
    public void destroy() {
        removeTrayIcon();
        stopPopupWatchdog();
        stopStatusRefreshTimer();
        if (statusDialog != null) {
            statusDialog.dispose();
            statusDialog = null;
        }
        if (popupWindow != null) {
            popupWindow.dispose();
            popupWindow = null;
        }
    }

    private void removeTrayIcon() {
        TrayIcon icon = trayIcon;
        trayIcon = null;
        if (icon != null) {
            SystemTray.getSystemTray().remove(icon);
        }
    }

    /**
     * 弹出采集状态窗口（不是打开浏览器），窗口里的状态每秒自动刷新
     */
    private void showStatusDialog() {
        if (statusDialog == null) {
            statusDialog = createStatusDialog();
        }
        refreshStatus();
        statusDialog.setLocationRelativeTo(null);
        statusDialog.setVisible(true);
        statusDialog.toFront();
    }

    /**
     * 创建串口状态窗口：串口名称 / 监听状态 / 串口连接 / 缓存条数 + 刷新、关闭按钮
     */
    private JDialog createStatusDialog() {
        Font font = resolveMenuFont();

        JPanel fields = new JPanel(new GridLayout(4, 2, 12, 10));
        fields.setBackground(MENU_BACKGROUND);
        serialPortNameValue = addStatusRow(fields, "串口名称", font);
        listeningValue = addStatusRow(fields, "监听状态", font);
        portOpenValue = addStatusRow(fields, "串口连接", font);
        dataSizeValue = addStatusRow(fields, "缓存数据", font);

        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT, 8, 0));
        buttons.setBackground(MENU_BACKGROUND);
        JButton refreshButton = new JButton("刷新");
        refreshButton.setFont(font);
        refreshButton.addActionListener(event -> refreshStatus());
        JButton closeButton = new JButton("关闭");
        closeButton.setFont(font);
        closeButton.addActionListener(event -> statusDialog.setVisible(false));
        buttons.add(refreshButton);
        buttons.add(closeButton);

        JPanel content = new JPanel(new BorderLayout(0, 14));
        content.setBackground(MENU_BACKGROUND);
        content.setBorder(BorderFactory.createEmptyBorder(18, 22, 14, 22));
        content.add(fields, BorderLayout.CENTER);
        content.add(buttons, BorderLayout.SOUTH);

        JDialog dialog = new JDialog();
        dialog.setTitle("串口状态");
        dialog.setModal(false);
        dialog.setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
        dialog.setContentPane(content);
        dialog.addWindowListener(new WindowAdapter() {
            @Override
            public void windowOpened(WindowEvent event) {
                refreshStatus();
                startStatusRefreshTimer();
            }

            @Override
            public void windowClosing(WindowEvent event) {
                // 关闭（其实是隐藏）时停掉自动刷新
                stopStatusRefreshTimer();
            }
        });
        dialog.pack();
        dialog.setLocationRelativeTo(null);
        return dialog;
    }

    /**
     * 状态窗口里的一行：左边是标题，右边是值
     *
     * @return 值那一列的标签，刷新时直接 setText
     */
    private JLabel addStatusRow(JPanel parent, String title, Font font) {
        JLabel titleLabel = new JLabel(title + "：", SwingConstants.RIGHT);
        titleLabel.setFont(font);
        titleLabel.setForeground(new Color(0x666666));
        JLabel valueLabel = new JLabel("-");
        valueLabel.setFont(font);
        valueLabel.setForeground(new Color(0x222222));
        parent.add(titleLabel);
        parent.add(valueLabel);
        return valueLabel;
    }

    /**
     * 刷新状态窗口里的内容
     */
    private void refreshStatus() {
        if (serialPortNameValue == null) {
            return;
        }
        SerialPortListener listener = serialPortListener();
        if (listener == null) {
            serialPortNameValue.setText("-");
            listeningValue.setText("获取串口监听器失败");
            portOpenValue.setText("-");
            dataSizeValue.setText("-");
            return;
        }
        String serialPortName = listener.getListenName();
        serialPortNameValue.setText(StringUtils.hasText(serialPortName) ? serialPortName : "-");
        listeningValue.setText(listener.isListening() ? "监听中" : "未监听");
        portOpenValue.setText(listener.isPortOpen() ? "已打开" : "未打开");
        dataSizeValue.setText(listener.dataSize() + " 条");
    }

    /**
     * @return 串口监听器，取不到时返回 null
     */
    private SerialPortListener serialPortListener() {
        if (applicationContext == null) {
            return null;
        }
        try {
            return applicationContext.getBean(SerialPortListener.class);
        } catch (Exception e) {
            log.warn("获取串口监听器失败：{}", e.getMessage());
            return null;
        }
    }

    private void startStatusRefreshTimer() {
        if (statusRefreshTimer == null) {
            statusRefreshTimer = new Timer(1000, event -> refreshStatus());
        }
        statusRefreshTimer.start();
    }

    private void stopStatusRefreshTimer() {
        if (statusRefreshTimer != null) {
            statusRefreshTimer.stop();
        }
    }

    /**
     * 关闭串口监听（只关串口，不退出程序），方便现场直接把串口释放给别的程序用
     */
    private void closeSerialPort() {
        SerialPortListener listener = serialPortListener();
        if (listener == null) {
            showError("获取串口监听器失败，无法关闭串口");
            return;
        }
        String serialPortName = listener.getListenName();
        serialPortName = StringUtils.hasText(serialPortName) ? serialPortName : "-";
        if (!listener.isListening() && !listener.isPortOpen()) {
            notifyMessage("串口 " + serialPortName + " 当前未开启监听");
            return;
        }
        if (listener.closeListening()) {
            log.info("从系统托盘关闭串口 {} 监听", serialPortName);
            notifyMessage("串口 " + serialPortName + " 监听已关闭");
        } else {
            showError("串口 " + serialPortName + " 关闭失败，请检查串口状态");
        }
    }

    /**
     * 托盘气泡提示，不打断当前操作
     */
    private void notifyMessage(String message) {
        if (trayIcon == null) {
            log.info(message);
            return;
        }
        trayIcon.displayMessage("亨旺特导MES数据采集器", message, TrayIcon.MessageType.INFO);
    }

    /**
     * 出错时弹窗提示（气泡提示可能被系统设置屏蔽，失败必须让人看见）
     */
    private void showError(String message) {
        log.warn(message);
        try {
            JOptionPane.showMessageDialog(null, message, "数据采集器", JOptionPane.ERROR_MESSAGE);
        } catch (Exception e) {
            log.warn("弹出错误提示失败：{}", e.getMessage());
        }
    }

    /**
     * 打开日志目录，方便现场排查问题
     */
    private void openLogDirectory() {
        try {
            File directory = new File(StringUtils.hasText(logLocation) ? logLocation : "logs");
            if (!directory.exists() && !directory.mkdirs()) {
                log.warn("日志目录不存在且创建失败：{}", directory.getAbsolutePath());
            }
            Desktop.getDesktop().open(directory);
        } catch (Exception e) {
            log.warn("打开日志目录失败：{}", e.getMessage());
        }
    }

    /**
     * 菜单字体：优先挑一个系统里存在的中文字体
     *
     * @return 菜单字体
     */
    private Font resolveMenuFont() {
        Set<String> fontFamilies = new HashSet<>(Arrays.asList(
                GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames()));
        for (String name : new String[]{"Microsoft YaHei", "微软雅黑", "SimSun", "宋体"}) {
            if (fontFamilies.contains(name)) {
                return new Font(name, Font.PLAIN, 12);
            }
        }
        return new Font(Font.DIALOG, Font.PLAIN, 12);
    }

    /**
     * 托盘图标：优先用 classpath 下的 tray.png，没有就现画一个，避免少一个图片文件就跑不起来
     */
    private Image loadTrayImage() {
        try (InputStream in = getClass().getClassLoader().getResourceAsStream("tray.png")) {
            if (in != null) {
                BufferedImage image = ImageIO.read(in);
                if (image != null) {
                    return image;
                }
            }
        } catch (Exception e) {
            log.warn("读取托盘图标 tray.png 失败，改用默认图标：{}", e.getMessage());
        }
        return createDefaultTrayImage();
    }

    /**
     * 默认图标：蓝底白字 S
     */
    private Image createDefaultTrayImage() {
        BufferedImage image = new BufferedImage(DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE, BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = image.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setColor(new Color(0x2D8CF0));
            graphics.fillRoundRect(0, 0, DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE, 8, 8);
            graphics.setColor(Color.WHITE);
            graphics.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 20));
            graphics.drawString("S", 10, 24);
        } finally {
            graphics.dispose();
        }
        return image;
    }
}