Notepad.java

package nn;

import javax.swing.tree.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.text.*;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.event.*;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.List;
import java.util.function.Consumer;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.stream.Stream;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.UndoManager;
import javax.swing.undo.UndoableEdit;

public class Notepad {

    public enum Theme {
        DRACULA, ONE_DARK, NORD, LIGHT, HIGH_CONTRAST
    }

    private JFrame frame;
    private JTabbedPane tabbedPane;
    private JTextArea outputArea;
    private JTextArea inputArea;
    private JPanel consolePanel;
    private JSplitPane mainSplitPane;
    private JSplitPane workspaceSplitPane;
    private boolean projectExplorerVisible = true;
    private int projectExplorerWidth = 240;
    private JPanel projectExplorerPanel;
    private JPanel projectExplorerHeader;
    private JTree projectTree;
    private DefaultTreeModel projectTreeModel;
    private JLabel projectTitleLabel;
    private File projectRoot;
    private JSplitPane consoleSplitPane;
    private JToolBar toolBar;
    private StatusBar statusBar;

    // ——— Explorer enhancements ———
    private JTextField explorerFilterField;
    private DefaultMutableTreeNode unfilteredRoot;
    private javax.swing.Timer explorerFilterTimer;

    private JMenuBar menuBar;
    private JMenu fileMenu, editMenu, formatMenu, languageMenu, themeMenu, viewMenu, runMenu;
    private JCheckBoxMenuItem wordWrapItem;
    private JMenu fontMenu, fontSizeMenu;
    private JMenu recentFilesMenu;

    private Theme currentTheme = Theme.DRACULA;
    private int defaultFontSize = 16;
    private String currentFontFamily = "JetBrains Mono";
    private List<String> recentFiles = new ArrayList<>();
    private static final int MAX_RECENT_FILES = 10;
    private static final String TEMPLATE_PATH = "./res/";
    private static final String RECENT_FILE = "./recent_files.dat";

    private Process currentProcess;
    private PrintWriter processInputWriter;
    private javax.swing.Timer autoSaveTimer;

    // Reused fonts to avoid repeated identical Font allocation across components.
    private static final Font UI_FONT = new Font("Segoe UI", Font.PLAIN, 13);
    private static final Font UI_FONT_BOLD = new Font("Segoe UI", Font.BOLD, 14);
    private static final Font SYMBOL_FONT = new Font("Segoe UI Symbol", Font.PLAIN, 16);
    private static final Font CONSOLE_FONT = new Font("JetBrains Mono", Font.PLAIN, 13);
    private static final Font STATUS_FONT = new Font("Segoe UI", Font.PLAIN, 12);
    private static final Font STATUS_FONT_ITALIC = new Font("Segoe UI", Font.ITALIC, 11);

    // ——— Color palettes ———
    private static final Color[] DRACULA = {
            new Color(40, 42, 54), new Color(68, 71, 90), new Color(98, 114, 164),
            new Color(248, 248, 242), new Color(80, 250, 123), new Color(255, 85, 85),
            new Color(255, 184, 108), new Color(189, 147, 249), new Color(139, 233, 253),
            new Color(255, 121, 198), new Color(241, 250, 140), new Color(69, 71, 90),
    };
    private static final Color[] ONE_DARK = {
            new Color(40, 44, 52), new Color(50, 55, 65), new Color(92, 99, 112),
            new Color(171, 178, 191), new Color(152, 195, 121), new Color(224, 108, 117),
            new Color(209, 154, 102), new Color(198, 120, 221), new Color(86, 182, 194),
            new Color(229, 192, 123), new Color(97, 175, 239), new Color(44, 48, 56),
    };
    private static final Color[] NORD = {
            new Color(46, 52, 64), new Color(59, 66, 82), new Color(76, 86, 106),
            new Color(216, 222, 233), new Color(163, 190, 140), new Color(191, 97, 106),
            new Color(208, 135, 112), new Color(180, 142, 173), new Color(136, 192, 208),
            new Color(235, 203, 139), new Color(129, 161, 193), new Color(48, 54, 66),
    };
    private static final Color[] LIGHT = {
            new Color(250, 250, 250), new Color(240, 240, 240), new Color(200, 200, 200),
            new Color(30, 30, 30), new Color(0, 150, 80), new Color(220, 50, 50),
            new Color(220, 120, 0), new Color(150, 50, 200), new Color(0, 150, 200),
            new Color(200, 50, 150), new Color(180, 160, 0), new Color(235, 235, 235),
    };
    private static final Color[] HIGH_CONTRAST = {
            Color.BLACK, new Color(20, 20, 20), Color.DARK_GRAY, Color.WHITE,
            Color.GREEN, Color.RED, Color.ORANGE, Color.MAGENTA, Color.CYAN,
            Color.PINK, Color.YELLOW, Color.BLACK,
    };

    private static class Palette {
        Color bg, bgLighter, comment, fg, green, red, orange, purple, cyan, pink, yellow, lineHL;

        Palette(Color[] c) {
            bg = c[0];
            bgLighter = c[1];
            comment = c[2];
            fg = c[3];
            green = c[4];
            red = c[5];
            orange = c[6];
            purple = c[7];
            cyan = c[8];
            pink = c[9];
            yellow = c[10];
            lineHL = c[11];
        }
    }

    private Palette pal;

    // ———————————————————————————————— CONSTRUCTOR ————————————————————————————————

    public Notepad() {
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        } catch (Exception ignored) {
        }
        loadRecentFiles();
        pal = palette(currentTheme);
        createFrame();
        createToolBar();
        createTabbedEditor();
        createConsolePanel();
        createProjectExplorer();
        createMainSplitPane();
        createStatusBar();
        createMenuBar();
        applyTheme(currentTheme);
        loadProjectFolder(new File(System.getProperty("user.dir")));
        addNewTab();
        startAutoSave();
        frame.setVisible(true);
    }

    private Palette palette(Theme t) {
        switch (t) {
            case DRACULA:
                return new Palette(DRACULA);
            case ONE_DARK:
                return new Palette(ONE_DARK);
            case NORD:
                return new Palette(NORD);
            case LIGHT:
                return new Palette(LIGHT);
            case HIGH_CONTRAST:
                return new Palette(HIGH_CONTRAST);
            default:
                return new Palette(DRACULA);
        }
    }

    // ———————————————————————————————— FRAME ————————————————————————————————

    private void createFrame() {
        frame = new JFrame("pavans-Notepadplusplus");
        frame.setSize(1200, 800);
        frame.setMinimumSize(new Dimension(800, 500));
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        try {
            Image logo = Toolkit.getDefaultToolkit().getImage("./icons/pavans-notepadplus.ico");
            if (logo != null)
                frame.setIconImage(logo);
        } catch (Exception ignored) {
        }
        new DropTarget(frame, new DropTargetAdapter() {
            public void drop(DropTargetDropEvent e) {
                try {
                    e.acceptDrop(DnDConstants.ACTION_COPY);
                    @SuppressWarnings("unchecked")
                    List<File> files = (List<File>) e.getTransferable().getTransferData(DataFlavor.javaFileListFlavor);
                    for (File f : files)
                        openFileInTab(f.getAbsolutePath());
                } catch (Exception ignored) {
                }
            }
        });
        // Stop the autosave timer and any running child process cleanly on close
        // instead of leaking a live Timer/threads after disposal.
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosed(WindowEvent e) {
                if (autoSaveTimer != null)
                    autoSaveTimer.stop();
                stopRunningProcess();
            }
        });
    }

    // ———————————————————————————————— TOOLBAR ————————————————————————————————

    private void createToolBar() {
        toolBar = new JToolBar();
        toolBar.setFloatable(false);
        toolBar.setBorderPainted(false);
        toolBar.setMargin(new Insets(4, 8, 4, 8));
        toolBar.setPreferredSize(new Dimension(0, 46));

        toolBar.add(toolBtn("☰", "Show/Hide Project Explorer", e -> toggleProjectExplorer()));
        toolBar.add(toolBtn("📄", "New (Ctrl+N)", e -> addNewTab()));
        toolBar.add(toolBtn("📂", "Open (Ctrl+O)", e -> openFile()));
        toolBar.add(toolBtn("💾", "Save (Ctrl+S)", e -> saveCurrentTab(false)));
        toolBar.add(toolBtn("💿", "Save As (Ctrl+Shift+S)", e -> saveCurrentTab(true)));
        toolBar.add(sep(10));

        toolBar.add(toolBtn("⚙", "Compile (Ctrl+Shift+B)", e -> compileJavaCode()));
        toolBar.add(toolBtn("▶", "Run (F5)", e -> runCurrentFile()));
        toolBar.add(toolBtn("⏹", "Stop (Shift+F5)", e -> stopRunningProcess()));
        toolBar.add(sep(10));

        toolBar.add(toolBtn("🔍", "Find / Replace (Ctrl+F)", e -> showFindReplace()));
        toolBar.add(toolBtn("➕", "Zoom In (Ctrl++)", e -> zoomIn()));
        toolBar.add(toolBtn("➖", "Zoom Out (Ctrl+-)", e -> zoomOut()));

        frame.add(toolBar, BorderLayout.NORTH);
    }

    private JButton toolBtn(String text, String tip, ActionListener a) {
        JButton b = new JButton(text);
        b.setToolTipText(tip);
        b.setFont(SYMBOL_FONT);
        b.setFocusPainted(false);
        b.setBorderPainted(false);
        b.setContentAreaFilled(false);
        b.setForeground(pal.fg);
        b.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        b.setPreferredSize(new Dimension(36, 32));
        b.setMargin(new Insets(1, 3, 1, 3));
        b.addActionListener(a);
        b.putClientProperty("nn.hoverable", true);
        b.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                b.setContentAreaFilled(true);
                b.setBackground(pal.bgLighter);
            }

            public void mouseExited(MouseEvent e) {
                b.setContentAreaFilled(false);
            }
        });
        return b;
    }

    private Component sep(int w) {
        JLabel l = new JLabel();
        l.setPreferredSize(new Dimension(w, 0));
        return l;
    }

    // ———————————————————————————————— TABBED EDITOR
    // ————————————————————————————————

    private void createTabbedEditor() {
        tabbedPane = new JTabbedPane();
        tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
        tabbedPane.setFont(UI_FONT);
        tabbedPane.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                if (SwingUtilities.isMiddleMouseButton(e)) {
                    int i = tabbedPane.indexAtLocation(e.getX(), e.getY());
                    if (i >= 0)
                        closeTab(i);
                }
            }
        });
        tabbedPane.addChangeListener(e -> {
            updateFrameTitle();
            statusBar.refresh();
            revealCurrentFileInExplorer();
        });
    }

    private void addNewTab() {
        DocumentTab tab = new DocumentTab();
        int i = tabbedPane.getTabCount();
        tabbedPane.addTab("Untitled", tab.scrollPane);
        tabbedPane.setTabComponentAt(i, tabHeader("Untitled"));
        tabbedPane.setSelectedIndex(i);
        storeTabRef(i, tab);
        tab.textArea.requestFocusInWindow();
        tab.applyEditorColors(pal);
        updateFrameTitle();
    }

    private JPanel tabHeader(String title) {
        JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT, 4, 0));
        p.setOpaque(true);
        p.setBackground(pal.bg);
        JLabel l = new JLabel(title);
        l.setFont(UI_FONT);
        l.setForeground(pal.fg);
        JLabel x = new JLabel("\u00D7");
        x.setFont(UI_FONT);
        x.setPreferredSize(new Dimension(20, 20));
        x.setHorizontalAlignment(SwingConstants.CENTER);
        x.setForeground(pal.fg);
        x.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        x.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                x.setOpaque(true);
                x.setBackground(pal.bgLighter);
            }

            public void mouseExited(MouseEvent e) {
                x.setOpaque(false);
            }

            public void mouseClicked(MouseEvent e) {
                int idx = tabbedPane.indexOfTabComponent(p);
                if (idx >= 0)
                    closeTab(idx);
            }
        });
        p.add(l);
        p.add(x);
        return p;
    }

    private void closeTab(int idx) {
        DocumentTab tab = tabAt(idx);
        if (tab.dirty) {
            int r = JOptionPane.showConfirmDialog(frame,
                    "Save changes to " + tab.fileName + "?", "Unsaved Changes",
                    JOptionPane.YES_NO_CANCEL_OPTION);
            if (r == JOptionPane.CANCEL_OPTION)
                return;
            if (r == JOptionPane.YES_OPTION)
                saveCurrentTab(false);
        }
        // Release timers/listeners before dropping the reference so a pending
        // highlight Timer doesn't keep firing against a detached component.
        tab.dispose();
        tabbedPane.remove(idx);
        if (tabbedPane.getTabCount() == 0)
            addNewTab();
        updateFrameTitle();
    }

    // ———————————————————————————————— DocumentTab ————————————————————————————————

    class DocumentTab {
        JTextPane textArea;
        LineNumberComponent lineNumbers;
        JScrollPane scrollPane;
        String filePath;
        String fileName = "Untitled";
        String defaultExtension = "";
        boolean dirty;
        UndoManager undoManager;
        private DocumentListener syntaxHighlightListener;
        private javax.swing.Timer highlightTimer;
        private int lastCaretLine = -1;
        private DefaultHighlighter.DefaultHighlightPainter lineHighlightPainter;

        private static final int HIGHLIGHT_SIZE_LIMIT = 60_000;

        DocumentTab() {

            undoManager = new UndoManager();
            undoManager.setLimit(200);

            textArea = new JTextPane();
            textArea.setFont(new Font(currentFontFamily, Font.PLAIN, defaultFontSize));
            textArea.setMargin(new Insets(12, 12, 12, 12));

            TabSet tabs = new TabSet(new TabStop[] { new TabStop(32, TabStop.ALIGN_LEFT, TabStop.LEAD_NONE) });
            StyledDocument doc = textArea.getStyledDocument();
            SimpleAttributeSet attrs = new SimpleAttributeSet();
            StyleConstants.setTabSet(attrs, tabs);
            doc.setParagraphAttributes(0, doc.getLength(), attrs, false);

            /*
             * Store only real text changes.
             *
             * Syntax highlighting uses setCharacterAttributes(), which generates
             * DocumentEvent.EventType.CHANGE edits. Those style changes must not
             * consume the user's 100 undo entries.
             */
            doc.addUndoableEditListener(event -> {
                UndoableEdit edit = event.getEdit();

                if (edit instanceof AbstractDocument.DefaultDocumentEvent) {
                    AbstractDocument.DefaultDocumentEvent documentEvent = (AbstractDocument.DefaultDocumentEvent) edit;

                    if (documentEvent.getType() == DocumentEvent.EventType.CHANGE) {
                        return;
                    }
                }

                undoManager.addEdit(edit);
            });

            installUndoRedoKeyBindings();

            lineNumbers = new LineNumberComponent(textArea);

            JPanel editorPanel = new JPanel(new BorderLayout());
            editorPanel.add(lineNumbers, BorderLayout.WEST);
            editorPanel.add(textArea, BorderLayout.CENTER);
            editorPanel.setBackground(pal.bg);

            scrollPane = new JScrollPane(editorPanel,
                    JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                    JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
            scrollPane.getViewport().setBackground(pal.bg);
            scrollPane.setBorder(null);
            scrollPane.getVerticalScrollBar().setUnitIncrement(16);

            // Debounced, size-capped syntax highlighting: one restyle pass per
            // pause in typing instead of restarting a timer on every keystroke
            // without a real bound on cost.
            syntaxHighlightListener = new DocumentListener() {
                public void insertUpdate(DocumentEvent e) {
                    markDirty();
                    scheduleHighlight();
                }

                public void removeUpdate(DocumentEvent e) {
                    markDirty();
                    scheduleHighlight();
                }

                public void changedUpdate(DocumentEvent e) {
                    /* style-only change */ }
            };
            doc.addDocumentListener(syntaxHighlightListener);

            textArea.addCaretListener(e -> {
                statusBar.refresh();
                highlightCurrentLine();
                // Only repaint the gutter when the caret actually changed line.
                try {
                    int line = getLineOfOffset(textArea, textArea.getCaretPosition());
                    if (line != lastCaretLine) {
                        lastCaretLine = line;
                        lineNumbers.repaint();
                    }
                } catch (BadLocationException ignored) {
                }
            });

            textArea.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "auto-indent");
            textArea.getActionMap().put("auto-indent", new AbstractAction() {
                public void actionPerformed(ActionEvent e) {
                    doAutoIndent();
                }
            });

            textArea.addMouseListener(new MouseAdapter() {
                public void mousePressed(MouseEvent e) {
                    maybePopup(e);
                }

                public void mouseReleased(MouseEvent e) {
                    maybePopup(e);
                }

                void maybePopup(MouseEvent e) {
                    if (e.isPopupTrigger())
                        showPopup(e);
                }
            });

        }

        private void installUndoRedoKeyBindings() {
            int shortcutMask = Toolkit.getDefaultToolkit().getMenuShortcutKeyMaskEx();

            InputMap inputMap = textArea.getInputMap(JComponent.WHEN_FOCUSED);

            ActionMap actionMap = textArea.getActionMap();

            inputMap.put(
                    KeyStroke.getKeyStroke(
                            KeyEvent.VK_Z,
                            shortcutMask),
                    "notepad-undo");

            inputMap.put(
                    KeyStroke.getKeyStroke(
                            KeyEvent.VK_Y,
                            shortcutMask),
                    "notepad-redo");

            // Also support Ctrl+Shift+Z as an alternative redo shortcut.
            inputMap.put(
                    KeyStroke.getKeyStroke(
                            KeyEvent.VK_Z,
                            shortcutMask | InputEvent.SHIFT_DOWN_MASK),
                    "notepad-redo");

            actionMap.put("notepad-undo", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent event) {
                    performUndo();
                }
            });

            actionMap.put("notepad-redo", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent event) {
                    performRedo();
                }
            });
        }

        void performUndo() {
            try {
                if (undoManager.canUndo()) {
                    undoManager.undo();
                }
            } catch (CannotUndoException ignored) {
            }

            textArea.requestFocusInWindow();
        }

        void performRedo() {
            try {
                if (undoManager.canRedo()) {
                    undoManager.redo();
                }
            } catch (CannotRedoException ignored) {
            }

            textArea.requestFocusInWindow();
        }

        private void scheduleHighlight() {
            if (highlightTimer != null) {
                highlightTimer.stop();
            }
            highlightTimer = new javax.swing.Timer(400, e -> {
                int len = textArea.getDocument().getLength();
                if (len > HIGHLIGHT_SIZE_LIMIT) {
                    return;
                }
                try {
                    StyledDocument doc = textArea.getStyledDocument();
                    doc.removeDocumentListener(syntaxHighlightListener);
                    try {
                        JavaSyntaxHighlighter.highlightSyntax(textArea, textArea.getText());
                    } finally {
                        doc.addDocumentListener(syntaxHighlightListener);
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            });
            highlightTimer.setRepeats(false);
            highlightTimer.start();
        }

        void showPopup(MouseEvent e) {
            JPopupMenu pop = new JPopupMenu();
            pop.setBackground(pal.bgLighter);
            pop.setForeground(pal.fg);

            addItem(pop, "Undo", ev -> performUndo());
            addItem(pop, "Redo", ev -> performRedo());

            pop.addSeparator();
            addItem(pop, "Cut", ev -> textArea.cut());
            addItem(pop, "Copy", ev -> textArea.copy());
            addItem(pop, "Paste", ev -> textArea.paste());
            pop.addSeparator();
            addItem(pop, "Select All", ev -> textArea.selectAll());
            pop.addSeparator();
            addItem(pop, "📂  Reveal in Explorer", ev -> revealCurrentFileInExplorer());
            pop.show(textArea, e.getX(), e.getY());
        }

        void addItem(JPopupMenu m, String n, Consumer<ActionEvent> a) {
            JMenuItem i = new JMenuItem(n);
            i.setFont(SYMBOL_FONT);
            i.setBackground(pal.bgLighter);
            i.setForeground(pal.fg);
            i.addActionListener(ev -> a.accept(ev));
            m.add(i);
        }

        void doAutoIndent() {
            try {
                int pos = textArea.getCaretPosition();
                int line = getLineOfOffset(textArea, pos);
                int start = getLineStartOffset(textArea, line);
                String prev = textArea.getText(start, pos - start);
                StringBuilder ind = new StringBuilder();
                for (int i = 0; i < prev.length(); i++) {
                    char c = prev.charAt(i);
                    if (c == ' ' || c == '\t')
                        ind.append(c);
                    else
                        break;
                }
                String t = prev.trim();
                if (t.endsWith("{") || t.endsWith("(") || t.endsWith(":"))
                    ind.append("    ");
                textArea.getDocument().insertString(pos, "\n" + ind.toString(), null);
            } catch (BadLocationException ignored) {
            }
        }

        // O(1) dirty tracking instead of hashing the whole document text on
        // every keystroke (the previous version called getText().hashCode()
        // on the full buffer on every insert/remove — the single biggest
        // source of typing lag on non-trivial files).
        void markDirty() {
            if (!dirty) {
                dirty = true;
                updateTabTitle();
                updateFrameTitle();
            }
        }

        void markClean() {
            dirty = false;
            updateTabTitle();
            updateFrameTitle();
        }

        void updateTabTitle() {
            int idx = tabbedPane.indexOfComponent(scrollPane);
            if (idx < 0)
                return;
            JPanel h = (JPanel) tabbedPane.getTabComponentAt(idx);
            if (h != null)
                ((JLabel) h.getComponent(0)).setText((dirty ? "* " : "") + fileName);
        }

        void applyEditorColors(Palette p) {
            textArea.setBackground(p.bg);
            textArea.setForeground(p.fg);
            textArea.setCaretColor(p.fg);
            textArea.setSelectedTextColor(p.fg);

            StyledDocument doc = textArea.getStyledDocument();
            Style defaultStyle = doc.getStyle(StyleContext.DEFAULT_STYLE);
            StyleConstants.setForeground(defaultStyle, p.fg);
            StyleConstants.setBackground(defaultStyle, p.bg);

            lineNumbers.bgColor = p.bg;
            lineNumbers.fgColor = p.comment;
            scrollPane.getViewport().setBackground(p.bg);
            if (textArea.getParent() != null)
                textArea.getParent().setBackground(p.bg);

            // Cache the highlight painter once per theme change instead of
            // allocating a new Color/painter on every caret move.
            lineHighlightPainter = new DefaultHighlighter.DefaultHighlightPainter(
                    new Color(p.lineHL.getRed(), p.lineHL.getGreen(), p.lineHL.getBlue(), 80));

            highlightCurrentLine();
        }

        void highlightCurrentLine() {
            textArea.getHighlighter().removeAllHighlights();
            if (lineHighlightPainter == null)
                return;
            try {
                int pos = textArea.getCaretPosition();
                int line = getLineOfOffset(textArea, pos);
                int s = getLineStartOffset(textArea, line);
                int e = getLineEndOffset(textArea, line);
                textArea.getHighlighter().addHighlight(s, e, lineHighlightPainter);
            } catch (BadLocationException ignored) {
            }
        }

        void applyFont() {
            textArea.setFont(new Font(currentFontFamily, Font.PLAIN, defaultFontSize));
            lineNumbers.updateFont();
            highlightCurrentLine();
        }

        void setFilePath(String path) {
            this.filePath = path;
            this.fileName = new File(path).getName();
            updateTabTitle();
            updateFrameTitle();
        }

        // Stop pending timers and detach listeners so a closed tab can be
        // garbage collected and doesn't keep doing background work.
        void dispose() {
            if (highlightTimer != null) {
                highlightTimer.stop();
                highlightTimer = null;
            }
            try {
                textArea.getStyledDocument().removeDocumentListener(syntaxHighlightListener);
            } catch (Exception ignored) {
            }
        }
    }

    // ———————————————————————————————— HELPERS ————————————————————————————————

    private DocumentTab currentTab() {
        int i = tabbedPane.getSelectedIndex();
        return i < 0 ? null : tabAt(i);
    }

    private DocumentTab tabAt(int i) {
        return (DocumentTab) ((JScrollPane) tabbedPane.getComponentAt(i)).getClientProperty("tab");
    }

    private void storeTabRef(int i, DocumentTab t) {
        ((JScrollPane) tabbedPane.getComponentAt(i)).putClientProperty("tab", t);
    }

    // ———————————————————————————————— CONSOLE ————————————————————————————————

    // ———————————————————————————————— PROJECT EXPLORER
    // ————————————————————————————————

    private static class FileTreeNode extends DefaultMutableTreeNode {
        private final File file;

        FileTreeNode(File file) {
            super(file);
            this.file = file;
        }

        File getFile() {
            return file;
        }

        @Override
        public String toString() {
            String name = file.getName();
            return name.isEmpty() ? file.getAbsolutePath() : name;
        }
    }

    private void createProjectExplorer() {
        // ── Header ──
        projectTitleLabel = new JLabel("EXPLORER");
        projectTitleLabel.setFont(UI_FONT_BOLD);

        JButton openFolderButton = iconBtn("📂", "Open Folder", e -> chooseProjectFolder());
        JButton refreshButton = iconBtn("↻", "Refresh", e -> refreshProjectExplorer());
        JButton collapseAllButton = iconBtn("▲", "Collapse All", e -> {
            for (int r = projectTree.getRowCount() - 1; r > 0; r--)
                projectTree.collapseRow(r);
        });
        JButton expandAllButton = iconBtn("▼", "Expand All", e -> {
            for (int r = 0; r < projectTree.getRowCount(); r++)
                projectTree.expandRow(r);
        });

        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 1, 0));
        buttonPanel.setOpaque(false);
        buttonPanel.add(collapseAllButton);
        buttonPanel.add(expandAllButton);
        buttonPanel.add(openFolderButton);
        buttonPanel.add(refreshButton);

        projectExplorerHeader = new JPanel(new BorderLayout());
        projectExplorerHeader.setBorder(new EmptyBorder(6, 8, 4, 4));
        projectExplorerHeader.add(projectTitleLabel, BorderLayout.CENTER);
        projectExplorerHeader.add(buttonPanel, BorderLayout.EAST);

        // ── Filter bar ──
        explorerFilterField = new JTextField();
        explorerFilterField.putClientProperty("nn.filterField", true);
        explorerFilterField.setFont(SYMBOL_FONT);
        explorerFilterField.setForeground(pal.comment);
        explorerFilterField.setBackground(pal.bg);
        explorerFilterField.setBorder(new CompoundBorder(
                new MatteBorder(0, 0, 1, 0, pal.comment),
                new EmptyBorder(4, 8, 4, 8)));
        explorerFilterField.setText("🔍 Search files...");

        Runnable applyFilter = () -> filterExplorerTree(explorerFilterField.getText());

        explorerFilterField.addFocusListener(new FocusAdapter() {
            @Override
            public void focusGained(FocusEvent e) {
                if ("Search files...".equals(explorerFilterField.getText())) {
                    explorerFilterField.setText("");
                    explorerFilterField.setForeground(pal.fg);
                }
            }

            @Override
            public void focusLost(FocusEvent e) {
                if (explorerFilterField.getText().isEmpty()) {
                    explorerFilterField.setForeground(pal.comment);
                    explorerFilterField.setText("Search files...");
                    filterExplorerTree("");
                }
            }
        });

        explorerFilterField.getDocument().addDocumentListener(new DocumentListener() {
            void schedule() {
                if (explorerFilterTimer != null)
                    explorerFilterTimer.stop();
                explorerFilterTimer = new javax.swing.Timer(200, ev -> applyFilter.run());
                explorerFilterTimer.setRepeats(false);
                explorerFilterTimer.start();
            }

            @Override
            public void insertUpdate(DocumentEvent e) { schedule(); }

            @Override
            public void removeUpdate(DocumentEvent e) { schedule(); }

            @Override
            public void changedUpdate(DocumentEvent e) { schedule(); }
        });

        // ── Tree ──
        DefaultMutableTreeNode emptyRoot = new DefaultMutableTreeNode("No folder opened");
        projectTreeModel = new DefaultTreeModel(emptyRoot);

        projectTree = new JTree(projectTreeModel);
        projectTree.setRootVisible(true);
        projectTree.setShowsRootHandles(true);
        projectTree.setRowHeight(24);
        projectTree.setFont(UI_FONT);
        projectTree.setCellRenderer(new ProjectTreeRenderer());
        projectTree.setToggleClickCount(2);
        projectTree.getSelectionModel().setSelectionMode(
                TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);

        // Tooltips
        projectTree.setToolTipText("");
        ToolTipManager.sharedInstance().registerComponent(projectTree);

        // Click behavior: single-click toggles directories, double-click opens files, right-click context menu
        projectTree.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                TreePath treePath = projectTree.getPathForLocation(e.getX(), e.getY());
                if (treePath == null) return;
                Object value = treePath.getLastPathComponent();
                if (!(value instanceof FileTreeNode)) return;
                File file = ((FileTreeNode) value).getFile();

                if (SwingUtilities.isRightMouseButton(e)) {
                    projectTree.setSelectionPath(treePath);
                    showExplorerContextMenu(e);
                } else if (SwingUtilities.isLeftMouseButton(e)) {
                    if (e.getClickCount() == 1 && file.isDirectory()) {
                        if (projectTree.isExpanded(treePath)) {
                            projectTree.collapsePath(treePath);
                        } else {
                            projectTree.expandPath(treePath);
                        }
                    } else if (e.getClickCount() == 2 && !file.isDirectory()) {
                        openFileFromExplorer(file);
                    }
                }
            }

            @Override
            public void mousePressed(MouseEvent e) {
                if (e.isPopupTrigger())
                    showExplorerContextMenu(e);
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                if (e.isPopupTrigger())
                    showExplorerContextMenu(e);
            }
        });

        // Keyboard support: F2 rename, Delete delete
        projectTree.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0), "rename");
        projectTree.getActionMap().put("rename", new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                TreePath sel = projectTree.getSelectionPath();
                if (sel != null && sel.getLastPathComponent() instanceof FileTreeNode ftn)
                    renameExplorerNode(ftn);
            }
        });

        projectTree.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "delete");
        projectTree.getActionMap().put("delete", new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                TreePath sel = projectTree.getSelectionPath();
                if (sel != null && sel.getLastPathComponent() instanceof FileTreeNode ftn)
                    deleteExplorerNode(ftn);
            }
        });

        JScrollPane treeScrollPane = new JScrollPane(projectTree);
        treeScrollPane.setBorder(null);
        treeScrollPane.getVerticalScrollBar().setUnitIncrement(16);

        // ── Assemble panel ──
        JPanel explorerCenter = new JPanel(new BorderLayout());
        explorerCenter.add(explorerFilterField, BorderLayout.NORTH);
        explorerCenter.add(treeScrollPane, BorderLayout.CENTER);

        projectExplorerPanel = new JPanel(new BorderLayout());
        projectExplorerPanel.setMinimumSize(new Dimension(150, 0));
        projectExplorerPanel.setPreferredSize(new Dimension(260, 0));
        projectExplorerPanel.add(projectExplorerHeader, BorderLayout.NORTH);
        projectExplorerPanel.add(explorerCenter, BorderLayout.CENTER);
    }

    private JButton iconBtn(String text, String tip, ActionListener a) {
        JButton b = new JButton(text);
        b.setToolTipText(tip);
        b.setFont(SYMBOL_FONT);
        b.setFocusPainted(false);
        b.setBorderPainted(false);
        b.setContentAreaFilled(false);
        b.setForeground(pal.fg);
        b.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        b.setPreferredSize(new Dimension(28, 24));
        b.setMargin(new Insets(0, 2, 0, 2));
        b.addActionListener(a);
        b.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                b.setContentAreaFilled(true);
                b.setBackground(pal.bgLighter);
            }
            public void mouseExited(MouseEvent e) {
                b.setContentAreaFilled(false);
            }
        });
        return b;
    }

    private void chooseProjectFolder() {
        JFileChooser fileChooser = new JFileChooser(
                projectRoot != null
                        ? projectRoot
                        : new File(System.getProperty("user.dir")));

        fileChooser.setDialogTitle("Open Project Folder");
        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        fileChooser.setAcceptAllFileFilterUsed(false);

        if (fileChooser.showOpenDialog(frame) == JFileChooser.APPROVE_OPTION) {

            loadProjectFolder(fileChooser.getSelectedFile());
        }
    }

    private void loadProjectFolder(File folder) {
        if (folder == null || !folder.isDirectory()) {
            return;
        }

        projectRoot = folder;
        projectTitleLabel.setText(folder.getName().toUpperCase(Locale.ROOT));

        projectTreeModel.setRoot(
                new DefaultMutableTreeNode("Loading..."));

        new SwingWorker<DefaultMutableTreeNode, Void>() {
            @Override
            protected DefaultMutableTreeNode doInBackground() {
                return buildProjectTree(folder);
            }

            @Override
            protected void done() {
                try {
                    DefaultMutableTreeNode rootNode = get();
                    unfilteredRoot = rootNode;

                    projectTreeModel.setRoot(cloneNode(rootNode));
                    projectTreeModel.reload();
                    projectTree.expandRow(0);

                } catch (Exception e) {
                    projectTreeModel.setRoot(
                            new DefaultMutableTreeNode(
                                    "Could not load folder"));

                    outputArea.append(
                            "\n Explorer error: " +
                                    e.getMessage() + "\n");
                }
            }
        }.execute();
    }

    private DefaultMutableTreeNode buildProjectTree(File file) {
        FileTreeNode node = new FileTreeNode(file);

        Path path = file.toPath();

        if (!Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS)
                || Files.isSymbolicLink(path)) {
            return node;
        }

        File[] children = file.listFiles(child -> {
            String n = child.getName();
            if (n.equalsIgnoreCase(".git") || n.equalsIgnoreCase("node_modules")
                    || n.equalsIgnoreCase(".svn") || n.equalsIgnoreCase(".hg")
                    || n.equalsIgnoreCase(".DS_Store") || n.equalsIgnoreCase("__pycache__")
                    || n.equalsIgnoreCase(".idea") || n.equalsIgnoreCase(".gradle")
                    || n.equalsIgnoreCase("target") || n.equalsIgnoreCase("build")
                    || n.equalsIgnoreCase("bin") || n.equalsIgnoreCase("obj")
                    || n.equalsIgnoreCase(".settings") || n.equalsIgnoreCase(".project")
                    || n.equalsIgnoreCase(".classpath") || n.equalsIgnoreCase(".metadata")
                    || n.equalsIgnoreCase(".vscode") || n.equalsIgnoreCase("dist")
                    || n.equalsIgnoreCase(".next") || n.equalsIgnoreCase(".nuxt")
                    || n.equalsIgnoreCase("coverage") || n.equalsIgnoreCase(".nyc_output")
                    || n.equalsIgnoreCase(".cache")) {
                return false;
            }
            return true;
        });

        if (children == null) {
            return node;
        }

        Arrays.sort(
                children,
                Comparator
                        .comparing((File child) -> !child.isDirectory())
                        .thenComparing(
                                child -> child.getName().toLowerCase(Locale.ROOT)));

        for (File child : children) {
            node.add(buildProjectTree(child));
        }

        return node;
    }

    private void refreshProjectExplorer() {
        if (projectRoot != null) {
            loadProjectFolder(projectRoot);
        }
    }

    private void filterExplorerTree(String filterText) {
        if (unfilteredRoot == null) return;
        String q = filterText.trim();
        if (q.isEmpty() || "Search files...".equals(q)) {
            projectTreeModel.setRoot(cloneNode(unfilteredRoot));
            projectTreeModel.reload();
            projectTree.expandRow(0);
            return;
        }
        String lower = q.toLowerCase(Locale.ROOT);
        DefaultMutableTreeNode filtered = filterNode(unfilteredRoot, lower);
        // If the root itself was pruned, show a "no match" placeholder
        String rootObj = filtered.getUserObject().toString();
        if ("__prune__".equals(rootObj) || (filtered.getChildCount() == 0
                && !(filtered instanceof FileTreeNode && ((FileTreeNode) filtered).getFile() != null
                        && ((FileTreeNode) filtered).getFile().getName().toLowerCase(Locale.ROOT).contains(lower)))) {
            DefaultMutableTreeNode noMatch = new DefaultMutableTreeNode("(No matches)");
            projectTreeModel.setRoot(noMatch);
        } else {
            projectTreeModel.setRoot(filtered);
            projectTreeModel.reload();
            if (filtered.getChildCount() > 0)
                projectTree.expandRow(0);
        }
        projectTreeModel.reload();
    }

    @SuppressWarnings("unchecked")
    private DefaultMutableTreeNode cloneNode(DefaultMutableTreeNode src) {
        DefaultMutableTreeNode dst;
        if (src instanceof FileTreeNode) {
            dst = new FileTreeNode(((FileTreeNode) src).getFile());
        } else {
            dst = new DefaultMutableTreeNode(src.getUserObject());
        }
        Enumeration<DefaultMutableTreeNode> children = (Enumeration<DefaultMutableTreeNode>) (Object) src.children();
        while (children.hasMoreElements()) {
            dst.add(cloneNode(children.nextElement()));
        }
        return dst;
    }

    @SuppressWarnings("unchecked")
    private DefaultMutableTreeNode filterNode(DefaultMutableTreeNode node, String lower) {
        boolean isFileNode = node instanceof FileTreeNode;
        File file = isFileNode ? ((FileTreeNode) node).getFile() : null;
        String name = (file != null) ? file.getName().toLowerCase(Locale.ROOT)
                : node.getUserObject().toString().toLowerCase(Locale.ROOT);

        DefaultMutableTreeNode result;
        if (isFileNode) {
            result = new FileTreeNode(file);
        } else {
            result = new DefaultMutableTreeNode(node.getUserObject());
        }

        Enumeration<DefaultMutableTreeNode> children = (Enumeration<DefaultMutableTreeNode>) (Object) node.children();
        boolean childMatch = false;
        while (children.hasMoreElements()) {
            DefaultMutableTreeNode matched = filterNode(children.nextElement(), lower);
            if (matched.getChildCount() > 0 || (matched instanceof FileTreeNode
                    && ((FileTreeNode) matched).getFile() != null
                    && ((FileTreeNode) matched).getFile().getName().toLowerCase(Locale.ROOT).contains(lower))) {
                result.add(matched);
                childMatch = true;
            }
        }

        // Show leaf nodes that match, and directories that either match or have matching children
        boolean selfMatch = name.contains(lower);
        if (!selfMatch && !childMatch && file != null && !file.isDirectory())
            return new DefaultMutableTreeNode("__prune__");

        return result;
    }

    // ── Explorer context menu ──
    private void showExplorerContextMenu(MouseEvent e) {
        TreePath path = projectTree.getPathForLocation(e.getX(), e.getY());
        if (path == null) return;
        Object value = path.getLastPathComponent();
        if (!(value instanceof FileTreeNode)) return;

        projectTree.setSelectionPath(path);
        File file = ((FileTreeNode) value).getFile();

        JPopupMenu menu = new JPopupMenu();
        menu.setBackground(pal.bgLighter);
        menu.setForeground(pal.fg);

        if (file.isDirectory()) {
            addExplorerMenuItem(menu, "📁  New File", ev -> createNewFileIn(file));
            addExplorerMenuItem(menu, "📂  New Folder", ev -> createNewFolderIn(file));
            menu.addSeparator();
            addExplorerMenuItem(menu, "🔃  Refresh", ev -> refreshProjectExplorer());
        }

        addExplorerMenuItem(menu, "✏️  Rename  (F2)", ev -> renameExplorerNode((FileTreeNode) value));
        addExplorerMenuItem(menu, "🗑  Delete  (Del)", ev -> deleteExplorerNode((FileTreeNode) value));
        menu.addSeparator();
        addExplorerMenuItem(menu, "📋  Copy Path", ev -> {
            StringSelection sel = new StringSelection(file.getAbsolutePath());
            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(sel, null);
        });
        addExplorerMenuItem(menu, "📋  Copy Relative Path", ev -> {
            String rel = projectRoot != null ? projectRoot.toPath().relativize(file.toPath()).toString() : file.getName();
            StringSelection sel = new StringSelection(rel);
            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(sel, null);
        });
        menu.addSeparator();
        addExplorerMenuItem(menu, "🖥  Open in Explorer", ev -> {
            try {
                Runtime.getRuntime().exec("explorer.exe /select,\"" + file.getAbsolutePath() + "\"");
            } catch (IOException ex) {
                outputArea.append(" Cannot open explorer: " + ex.getMessage() + "\n");
            }
        });
        if (file.isDirectory()) {
            addExplorerMenuItem(menu, "⌨  Open in Terminal", ev -> {
                try {
                    Runtime.getRuntime().exec("cmd.exe /k start", null, file);
                } catch (IOException ex) {
                    outputArea.append(" Cannot open terminal: " + ex.getMessage() + "\n");
                }
            });
        }
        addExplorerMenuItem(menu, "🔍  Show Properties", ev -> showFileProperties(file));

        menu.show(projectTree, e.getX(), e.getY());
    }

    private void addExplorerMenuItem(JPopupMenu menu, String text, ActionListener action) {
        JMenuItem item = new JMenuItem(text);
        item.setFont(SYMBOL_FONT);
        item.setBackground(pal.bgLighter);
        item.setForeground(pal.fg);
        item.addActionListener(action);
        item.addMouseListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                item.setBackground(pal.comment);
            }
            public void mouseExited(MouseEvent e) {
                item.setBackground(pal.bgLighter);
            }
        });
        menu.add(item);
    }

    private void createNewFileIn(File dir) {
        String name = JOptionPane.showInputDialog(frame, "File name:", "New File", JOptionPane.PLAIN_MESSAGE);
        if (name == null || name.trim().isEmpty()) return;
        try {
            File f = new File(dir, name.trim());
            if (f.createNewFile()) {
                refreshProjectExplorer();
                openFileInTab(f.getAbsolutePath());
            } else {
                JOptionPane.showMessageDialog(frame, "File already exists.", "Error", JOptionPane.ERROR_MESSAGE);
            }
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(frame, "Could not create file:\n" + ex.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private void createNewFolderIn(File dir) {
        String name = JOptionPane.showInputDialog(frame, "Folder name:", "New Folder", JOptionPane.PLAIN_MESSAGE);
        if (name == null || name.trim().isEmpty()) return;
        File f = new File(dir, name.trim());
        if (f.mkdir()) {
            refreshProjectExplorer();
        } else {
            JOptionPane.showMessageDialog(frame, "Could not create folder.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    private void renameExplorerNode(FileTreeNode node) {
        File file = node.getFile();
        String name = JOptionPane.showInputDialog(frame, "New name:", file.getName());
        if (name == null || name.trim().isEmpty() || name.equals(file.getName())) return;
        File dest = new File(file.getParent(), name.trim());
        if (file.renameTo(dest)) {
            refreshProjectExplorer();
        } else {
            JOptionPane.showMessageDialog(frame, "Could not rename.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    private void deleteExplorerNode(FileTreeNode node) {
        File file = node.getFile();
        int r = JOptionPane.showConfirmDialog(frame,
                "Delete " + (file.isDirectory() ? "folder" : "file") + ":\n" + file.getName() + "?",
                "Confirm Delete", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
        if (r != JOptionPane.YES_OPTION) return;
        if (deleteRecursive(file)) {
            refreshProjectExplorer();
        } else {
            JOptionPane.showMessageDialog(frame, "Could not delete.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    private boolean deleteRecursive(File f) {
        if (f.isDirectory()) {
            File[] children = f.listFiles();
            if (children != null) {
                for (File child : children) {
                    if (!deleteRecursive(child)) return false;
                }
            }
        }
        return f.delete();
    }

    private void showFileProperties(File file) {
        long size = file.length();
        long mod = file.lastModified();
        String sizeStr = size < 1024 ? size + " B"
                : size < 1024 * 1024 ? String.format("%.1f KB", size / 1024.0)
                : String.format("%.1f MB", size / (1024.0 * 1024.0));
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String info = "Name: " + file.getName() + "\n"
                + "Path: " + file.getAbsolutePath() + "\n"
                + "Size: " + sizeStr + "\n"
                + "Modified: " + sdf.format(new java.util.Date(mod)) + "\n"
                + "Type: " + (file.isDirectory() ? "Directory" : "File");
        JOptionPane.showMessageDialog(frame, info, "Properties", JOptionPane.PLAIN_MESSAGE);
    }

    // ── Reveal active file in explorer tree ──
    private void revealCurrentFileInExplorer() {
        if (projectRoot == null || projectTreeModel == null) return;
        DocumentTab tab = currentTab();
        if (tab == null || tab.filePath == null) return;
        File targetFile = new File(tab.filePath);
        // Don't reveal "Untitled" files
        if (!targetFile.exists()) return;

        DefaultMutableTreeNode root = (DefaultMutableTreeNode) projectTreeModel.getRoot();
        if (root == null) return;

        TreePath found = findNodePath(root, targetFile);
        if (found != null) {
            projectTree.setSelectionPath(found);
            projectTree.scrollPathToVisible(found);
        }
    }

    @SuppressWarnings("unchecked")
    private TreePath findNodePath(DefaultMutableTreeNode node, File target) {
        if (node instanceof FileTreeNode) {
            File nodeFile = ((FileTreeNode) node).getFile();
            if (nodeFile.equals(target)) {
                return new TreePath(node.getPath());
            }
        }
        Enumeration<DefaultMutableTreeNode> children = (Enumeration<DefaultMutableTreeNode>) (Object) node.children();
        while (children.hasMoreElements()) {
            DefaultMutableTreeNode child = children.nextElement();
            TreePath found = findNodePath(child, target);
            if (found != null) return found;
        }
        return null;
    }

    private void openFileFromExplorer(File file) {
        Path selectedPath = file.toPath()
                .toAbsolutePath()
                .normalize();

        // Select an existing tab instead of opening duplicates.
        for (int i = 0; i < tabbedPane.getTabCount(); i++) {
            DocumentTab tab = tabAt(i);

            if (tab == null || tab.filePath == null) {
                continue;
            }

            try {
                Path openPath = Paths.get(tab.filePath)
                        .toAbsolutePath()
                        .normalize();

                if (openPath.equals(selectedPath)) {
                    tabbedPane.setSelectedIndex(i);
                    tab.textArea.requestFocusInWindow();
                    return;
                }
            } catch (InvalidPathException ignored) {
            }
        }

        openFileInTab(selectedPath.toString());
    }

    private static class FileType {
        static final Map<String, String> EXT_ICONS = new HashMap<>();

        static {
            EXT_ICONS.put("java", "\u2615");
            EXT_ICONS.put("class", "\u2699");
            EXT_ICONS.put("jar", "\uD83D\uDCE6");
            EXT_ICONS.put("html", "\uD83C\uDF10");
            EXT_ICONS.put("htm", "\uD83C\uDF10");
            EXT_ICONS.put("css", "\uD83C\uDFA8");
            EXT_ICONS.put("js", "\uD83D\uDCDC");
            EXT_ICONS.put("ts", "\uD83D\uDCDC");
            EXT_ICONS.put("jsx", "\u26A1");
            EXT_ICONS.put("tsx", "\u26A1");
            EXT_ICONS.put("json", "\uD83D\uDCCB");
            EXT_ICONS.put("xml", "\uD83D\uDCC4");
            EXT_ICONS.put("yaml", "\uD83D\uDCC4");
            EXT_ICONS.put("yml", "\uD83D\uDCC4");
            EXT_ICONS.put("properties", "\uD83D\uDCCB");
            EXT_ICONS.put("py", "\uD83D\uDC0D");
            EXT_ICONS.put("c", "\uD83D\uDCBB");
            EXT_ICONS.put("cpp", "\uD83D\uDCBB");
            EXT_ICONS.put("h", "\uD83D\uDCBB");
            EXT_ICONS.put("cs", "\uD83D\uDCBB");
            EXT_ICONS.put("txt", "\uD83D\uDCC4");
            EXT_ICONS.put("md", "\uD83D\uDCD6");
            EXT_ICONS.put("markdown", "\uD83D\uDCD6");
            EXT_ICONS.put("pdf", "\uD83D\uDCD5");
            EXT_ICONS.put("png", "\uD83D\uDDFC");
            EXT_ICONS.put("jpg", "\uD83D\uDDFC");
            EXT_ICONS.put("jpeg", "\uD83D\uDDFC");
            EXT_ICONS.put("gif", "\uD83D\uDDFC");
            EXT_ICONS.put("svg", "\uD83D\uDDFC");
            EXT_ICONS.put("ico", "\uD83D\uDDFC");
            EXT_ICONS.put("zip", "\uD83D\uDCE6");
            EXT_ICONS.put("gz", "\uD83D\uDCE6");
            EXT_ICONS.put("tar", "\uD83D\uDCE6");
            EXT_ICONS.put("rar", "\uD83D\uDCE6");
            EXT_ICONS.put("7z", "\uD83D\uDCE6");
            EXT_ICONS.put("sql", "\uD83D\uDCBE");
            EXT_ICONS.put("db", "\uD83D\uDCBE");
            EXT_ICONS.put("sqlite", "\uD83D\uDCBE");
            EXT_ICONS.put("sh", "\uD83D\uDCBB");
            EXT_ICONS.put("bat", "\uD83D\uDCBB");
            EXT_ICONS.put("cmd", "\uD83D\uDCBB");
            EXT_ICONS.put("ps1", "\uD83D\uDCBB");
            EXT_ICONS.put("gradle", "\uD83D\uDCE6");
            EXT_ICONS.put("kt", "\uD83D\uDCBB");
            EXT_ICONS.put("kts", "\uD83D\uDCBB");
            EXT_ICONS.put("dart", "\uD83D\uDCBB");
            EXT_ICONS.put("go", "\uD83D\uDCBB");
            EXT_ICONS.put("rs", "\uD83D\uDCBB");
            EXT_ICONS.put("rb", "\uD83D\uDCBB");
            EXT_ICONS.put("php", "\uD83D\uDCBB");
            EXT_ICONS.put("swift", "\uD83D\uDCBB");
            EXT_ICONS.put("lock", "\uD83D\uDD12");
            EXT_ICONS.put("log", "\uD83D\uDCDD");
            EXT_ICONS.put("toml", "\uD83D\uDCC4");
            EXT_ICONS.put("cfg", "\uD83D\uDCC4");
            EXT_ICONS.put("conf", "\uD83D\uDCC4");
            EXT_ICONS.put("ini", "\uD83D\uDCC4");
            EXT_ICONS.put("env", "\uD83D\uDD12");
            EXT_ICONS.put("gitignore", "\uD83D\uDCC4");
            EXT_ICONS.put("gitkeep", "\uD83D\uDCC4");
            EXT_ICONS.put("DS_Store", "\uD83D\uDDD1");
            EXT_ICONS.put("ttf", "\uD83D\uDCD6");
            EXT_ICONS.put("otf", "\uD83D\uDCD6");
            EXT_ICONS.put("woff", "\uD83D\uDCD6");
            EXT_ICONS.put("woff2", "\uD83D\uDCD6");
            EXT_ICONS.put("mp3", "\uD83C\uDFB5");
            EXT_ICONS.put("wav", "\uD83C\uDFB5");
            EXT_ICONS.put("mp4", "\uD83C\uDFAC");
            EXT_ICONS.put("mov", "\uD83C\uDFAC");
            EXT_ICONS.put("avi", "\uD83C\uDFAC");
            EXT_ICONS.put("mkv", "\uD83C\uDFAC");
            EXT_ICONS.put("exe", "\u2699");
            EXT_ICONS.put("dll", "\u2699");
            EXT_ICONS.put("so", "\u2699");
            EXT_ICONS.put("pom", "\uD83D\uDCE6");
            EXT_ICONS.put("iml", "\uD83D\uDCC4");
            EXT_ICONS.put("idea", "\uD83D\uDCC4");
        }

        static String iconFor(File f) {
            if (f.isDirectory()) return "\uD83D\uDCC1";
            String name = f.getName().toLowerCase(Locale.ROOT);
            int dot = name.lastIndexOf('.');
            String ext = (dot >= 0) ? name.substring(dot + 1) : name;
            return EXT_ICONS.getOrDefault(ext, "\uD83D\uDCC4");
        }

        static String descriptionFor(File f) {
            long size = f.length();
            long mod = f.lastModified();
            String sizeStr = size < 1024 ? size + " B"
                    : size < 1024 * 1024 ? String.format("%.1f KB", size / 1024.0)
                    : String.format("%.1f MB", size / (1024.0 * 1024.0));
            String dateStr = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm").format(new java.util.Date(mod));
            return "<html><b>" + f.getName() + "</b><br>"
                    + "Size: " + sizeStr + "<br>"
                    + "Modified: " + dateStr + "<br>"
                    + (f.isDirectory() ? "Directory" : "File") + "</html>";
        }
    }

    private class ProjectTreeRenderer extends DefaultTreeCellRenderer {
        @Override
        public Component getTreeCellRendererComponent(
                JTree tree,
                Object value,
                boolean selected,
                boolean expanded,
                boolean leaf,
                int row,
                boolean hasFocus) {
            super.getTreeCellRendererComponent(
                    tree,
                    value,
                    selected,
                    expanded,
                    leaf,
                    row,
                    hasFocus);

            setFont(SYMBOL_FONT);
            setBorder(new EmptyBorder(2, 8, 2, 8));

            setBackgroundNonSelectionColor(pal.bgLighter);
            setTextNonSelectionColor(pal.fg);
            setBackgroundSelectionColor(pal.comment);
            setTextSelectionColor(pal.fg);

            if (value instanceof FileTreeNode) {
                File file = ((FileTreeNode) value).getFile();
                String icon = FileType.iconFor(file);
                setText(icon + "  " + file.getName());

                // Tooltip with file details
                String tip = FileType.descriptionFor(file);
                tree.setToolTipText(tip);
            }

            return this;
        }
    }

    private void createConsolePanel() {
        outputArea = new JTextArea();
        outputArea.setEditable(false);
        outputArea.setFont(CONSOLE_FONT);
        outputArea.setMargin(new Insets(8, 8, 8, 8));
        outputArea.setText(" \u2514 Welcome to pavans-Notepadplusplus \u2500 Compile & Run Java code here\n");

        inputArea = new JTextArea();
        inputArea.setFont(CONSOLE_FONT);
        inputArea.setMargin(new Insets(8, 8, 8, 8));
        inputArea.setEnabled(false);
        inputArea.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                    sendInput();
                    e.consume();
                }
            }
        });

        JScrollPane inSc = new JScrollPane(inputArea);
        inSc.setBorder(null);
        inSc.setPreferredSize(new Dimension(0, 70));

        JScrollPane outputScroll = new JScrollPane(outputArea);
        outputScroll.setBorder(null);

        consoleSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, outputScroll, inSc);
        consoleSplitPane.setResizeWeight(1.0);
        consoleSplitPane.setDividerSize(0);
        consoleSplitPane.setBorder(null);

        consolePanel = new JPanel(new BorderLayout());
        consolePanel.add(consoleSplitPane, BorderLayout.CENTER);
    }

    private void createStatusBar() {
        statusBar = new StatusBar();
        frame.add(statusBar, BorderLayout.SOUTH);
    }

    private void createMainSplitPane() {
        // Existing editor and console split.
        mainSplitPane = new JSplitPane(
                JSplitPane.HORIZONTAL_SPLIT,
                tabbedPane,
                consolePanel);

        mainSplitPane.setDividerLocation(750);
        mainSplitPane.setResizeWeight(0.75);
        mainSplitPane.setBorder(null);
        mainSplitPane.setOneTouchExpandable(true);

        // New outer split: explorer on left, workspace on right.
        workspaceSplitPane = new JSplitPane(
                JSplitPane.HORIZONTAL_SPLIT,
                projectExplorerPanel,
                mainSplitPane);

        workspaceSplitPane.setDividerLocation(240);
        workspaceSplitPane.setResizeWeight(0.0);
        workspaceSplitPane.setDividerSize(6);
        workspaceSplitPane.setBorder(null);
        workspaceSplitPane.setOneTouchExpandable(true);

        frame.add(workspaceSplitPane, BorderLayout.CENTER);
    }

    private void toggleProjectExplorer() {
        if (workspaceSplitPane == null) {
            return;
        }

        if (projectExplorerVisible) {
            int currentWidth = workspaceSplitPane.getDividerLocation();

            if (currentWidth > 0) {
                projectExplorerWidth = currentWidth;
            }

            projectExplorerPanel.setVisible(false);
            workspaceSplitPane.setDividerSize(0);
            workspaceSplitPane.setDividerLocation(0);

            projectExplorerVisible = false;
        } else {
            projectExplorerPanel.setVisible(true);
            workspaceSplitPane.setDividerSize(6);
            workspaceSplitPane.setDividerLocation(projectExplorerWidth);

            projectExplorerVisible = true;
        }

        workspaceSplitPane.revalidate();
        workspaceSplitPane.repaint();
    }

    // ———————————————————————————————— STATUS BAR ————————————————————————————————

    private class StatusBar extends JPanel {
        JLabel fileLbl, cursorLbl, encLbl, themeLbl, autoSaveLbl;
        private javax.swing.Timer autoSaveMsgTimer;

        StatusBar() {
            setLayout(new BorderLayout());
            setPreferredSize(new Dimension(0, 26));
            setBorder(new EmptyBorder(2, 10, 2, 10));

            fileLbl = new JLabel("  Untitled");
            fileLbl.setFont(STATUS_FONT);
            cursorLbl = new JLabel("Ln 1, Col 1");
            cursorLbl.setFont(STATUS_FONT);
            encLbl = new JLabel("UTF-8");
            encLbl.setFont(STATUS_FONT);
            themeLbl = new JLabel(currentTheme.name().replace('_', ' '));
            themeLbl.setFont(STATUS_FONT);
            autoSaveLbl = new JLabel("");
            autoSaveLbl.setFont(STATUS_FONT_ITALIC);

            JPanel left = new JPanel(new FlowLayout(FlowLayout.LEFT, 14, 0));
            left.setOpaque(false);
            left.add(fileLbl);
            JPanel right = new JPanel(new FlowLayout(FlowLayout.RIGHT, 14, 0));
            right.setOpaque(false);
            right.add(autoSaveLbl);
            right.add(cursorLbl);
            JSeparator s1 = new JSeparator(JSeparator.VERTICAL);
            s1.setPreferredSize(new Dimension(1, 14));
            right.add(s1);
            right.add(encLbl);
            JSeparator s2 = new JSeparator(JSeparator.VERTICAL);
            s2.setPreferredSize(new Dimension(1, 14));
            right.add(s2);
            right.add(themeLbl);

            add(left, BorderLayout.WEST);
            add(right, BorderLayout.EAST);
        }

        // Cache last-rendered values so refresh() (called on every caret move)
        // doesn't force redundant Swing text/layout updates.
        private int lastLine = -1, lastCol = -1;
        private boolean lastDirty;
        private String lastFileName;

        void refresh() {
            DocumentTab t = currentTab();
            if (t == null)
                return;
            try {
                int pos = t.textArea.getCaretPosition();
                int line = getLineOfOffset(t.textArea, pos);
                int col = pos - getLineStartOffset(t.textArea, line);
                if (line != lastLine || col != lastCol) {
                    lastLine = line;
                    lastCol = col;
                    cursorLbl.setText("Ln " + (line + 1) + ", Col " + (col + 1));
                }
            } catch (BadLocationException ignored) {
            }
            if (t.dirty != lastDirty || !t.fileName.equals(lastFileName)) {
                lastDirty = t.dirty;
                lastFileName = t.fileName;
                fileLbl.setText((t.dirty ? "* " : "  ") + t.fileName);
            }
        }

        void showAutoSaveMessage(String msg) {
            autoSaveLbl.setText(msg);
            if (autoSaveMsgTimer != null)
                autoSaveMsgTimer.stop();
            autoSaveMsgTimer = new javax.swing.Timer(3000, e -> autoSaveLbl.setText(""));
            autoSaveMsgTimer.setRepeats(false);
            autoSaveMsgTimer.start();
        }

        void applyColors(Palette p) {
            setBackground(p.bgLighter);
            fileLbl.setForeground(p.fg);
            cursorLbl.setForeground(p.comment);
            encLbl.setForeground(p.comment);
            themeLbl.setForeground(p.comment);
            autoSaveLbl.setForeground(p.green);
            themeLbl.setText(currentTheme.name().replace('_', ' '));
        }
    }

    // ———————————————————————————————— MENU BAR ————————————————————————————————

    private void createMenuBar() {
        menuBar = new JMenuBar();
        menuBar.setBorder(new EmptyBorder(2, 4, 2, 4));
        menuBar.setFont(UI_FONT);
        buildFileMenu();
        buildEditMenu();
        buildFormatMenu();
        buildLanguageMenu();
        buildRunMenu();
        buildViewMenu();
        buildThemeMenu();
        frame.setJMenuBar(menuBar);
    }

    private void buildFileMenu() {
        fileMenu = menu("File");
        mitem("New", fileMenu, e -> addNewTab(), KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_DOWN_MASK));
        mitem("New Window", fileMenu, e -> new Notepad(),
                KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
        mitem("Open", fileMenu, e -> openFile(), KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK));
        mitem("Open Folder", fileMenu, e -> chooseProjectFolder(),
                KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
        mitem("Save", fileMenu, e -> saveCurrentTab(false),
                KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
        mitem("Save As", fileMenu, e -> saveCurrentTab(true),
                KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
        fileMenu.addSeparator();
        recentFilesMenu = new JMenu("Recent Files");
        recentFilesMenu.setFont(UI_FONT);
        fileMenu.add(recentFilesMenu);
        rebuildRecentFiles();
        fileMenu.addSeparator();
        mitem("Exit", fileMenu, e -> frame.dispose(), KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_DOWN_MASK));
        menuBar.add(fileMenu);
    }

    private void buildEditMenu() {
        editMenu = menu("Edit");
        mitem("Undo", editMenu, e -> undo(), KeyStroke.getKeyStroke(KeyEvent.VK_Z, InputEvent.CTRL_DOWN_MASK));
        mitem("Redo", editMenu, e -> redo(), KeyStroke.getKeyStroke(KeyEvent.VK_Y, InputEvent.CTRL_DOWN_MASK));
        editMenu.addSeparator();
        mitem("Cut", editMenu, e -> doEdit(JTextPane::cut),
                KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_DOWN_MASK));
        mitem("Copy", editMenu, e -> doEdit(JTextPane::copy),
                KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_DOWN_MASK));
        mitem("Paste", editMenu, e -> doEdit(JTextPane::paste),
                KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_DOWN_MASK));
        mitem("Select All", editMenu, e -> doEdit(JTextPane::selectAll),
                KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_DOWN_MASK));
        editMenu.addSeparator();
        mitem("Find / Replace", editMenu, e -> showFindReplace(),
                KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_DOWN_MASK));
        editMenu.addSeparator();
        mitem("Comment/Uncomment", editMenu, e -> commentUncommentLines(),
                KeyStroke.getKeyStroke(KeyEvent.VK_SLASH, InputEvent.CTRL_DOWN_MASK));
        menuBar.add(editMenu);
    }

    private void undo() {
        DocumentTab tab = currentTab();

        if (tab != null) {
            tab.performUndo();
        }
    }

    private void redo() {
        DocumentTab tab = currentTab();

        if (tab != null) {
            tab.performRedo();
        }
    }

    private void doEdit(Consumer<JTextPane> a) {
        DocumentTab t = currentTab();
        if (t != null)
            a.accept(t.textArea);
    }

    private int getLineOfOffset(JTextPane pane, int offset) throws BadLocationException {
        Element root = pane.getDocument().getDefaultRootElement();
        return root.getElementIndex(offset);
    }

    private int getLineStartOffset(JTextPane pane, int line) {
        Element root = pane.getDocument().getDefaultRootElement();
        return root.getElement(line).getStartOffset();
    }

    private int getLineEndOffset(JTextPane pane, int line) {
        Element root = pane.getDocument().getDefaultRootElement();
        return root.getElement(line).getEndOffset();
    }

    private int getLineCount(JTextPane pane) {
        return pane.getDocument().getDefaultRootElement().getElementCount();
    }

    private void buildFormatMenu() {
        formatMenu = menu("Format");
        wordWrapItem = new JCheckBoxMenuItem("Word Wrap", true);
        wordWrapItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, InputEvent.CTRL_DOWN_MASK));
        wordWrapItem.addActionListener(e -> toggleWrap());
        formatMenu.add(wordWrapItem);
        formatMenu.addSeparator();
        fontMenu = new JMenu("Font Family");
        fontMenu.setFont(UI_FONT);
        for (String f : new String[] { "JetBrains Mono", "Consolas", "Fira Code", "Monospaced", "Arial", "Segoe UI" }) {
            JMenuItem fi = new JMenuItem(f);
            fi.addActionListener(ev -> {
                currentFontFamily = f;
                forAllTabs(DocumentTab::applyFont);
            });
            fontMenu.add(fi);
        }
        formatMenu.add(fontMenu);
        fontSizeMenu = new JMenu("Font Size");
        fontSizeMenu.setFont(UI_FONT);
        for (int s : new int[] { 12, 14, 16, 18, 20, 22, 24, 28, 32, 36, 40, 48, 56, 64 }) {
            JMenuItem si = new JMenuItem(String.valueOf(s));
            si.addActionListener(ev -> {
                defaultFontSize = s;
                forAllTabs(DocumentTab::applyFont);
            });
            fontSizeMenu.add(si);
        }
        formatMenu.add(fontSizeMenu);
        menuBar.add(formatMenu);
    }

    private void forAllTabs(Consumer<DocumentTab> a) {
        for (int i = 0; i < tabbedPane.getTabCount(); i++)
            a.accept(tabAt(i));
    }

    private void toggleWrap() {
        JOptionPane.showMessageDialog(
                frame,
                "Word Wrap is not supported with JTextPane.");
        wordWrapItem.setSelected(false);
    }

    private void buildLanguageMenu() {
        languageMenu = menu("Language");
        for (String lang : new String[] { "Java", "HTML", "C", "CPP", "Python", "JavaScript" }) {
            mitem(lang, languageMenu, e -> loadTemplate(lang));
        }
        menuBar.add(languageMenu);
    }

    private void buildRunMenu() {
        runMenu = menu("Run");
        mitem("Compile", runMenu, e -> compileJavaCode(),
                KeyStroke.getKeyStroke(KeyEvent.VK_B, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
        mitem("Run", runMenu, e -> runCurrentFile(), KeyStroke.getKeyStroke(KeyEvent.VK_F5, 0));
        mitem("Stop", runMenu, e -> stopRunningProcess(),
                KeyStroke.getKeyStroke(KeyEvent.VK_F5, InputEvent.SHIFT_DOWN_MASK));
        runMenu.addSeparator();
        mitem("Open CMD Here", runMenu, e -> openCmd());
        menuBar.add(runMenu);
    }

    private void buildViewMenu() {
        viewMenu = menu("View");
        mitem("Zoom In", viewMenu, e -> zoomIn(),
                KeyStroke.getKeyStroke(KeyEvent.VK_EQUALS, InputEvent.CTRL_DOWN_MASK));
        mitem("Zoom Out", viewMenu, e -> zoomOut(),
                KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, InputEvent.CTRL_DOWN_MASK));
        mitem("Reset Zoom", viewMenu, e -> resetZoom(),
                KeyStroke.getKeyStroke(KeyEvent.VK_0, InputEvent.CTRL_DOWN_MASK));
        viewMenu.addSeparator();
        mitem("Reveal in Explorer", viewMenu, e -> revealCurrentFileInExplorer(),
                KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK));
        viewMenu.addSeparator();
        mitem("Toggle Project Explorer", viewMenu, e -> toggleProjectExplorer());
        menuBar.add(viewMenu);
    }

    private void buildThemeMenu() {
        themeMenu = menu("Theme");
        for (Theme t : Theme.values()) {
            mitem(t.name().replace('_', ' '), themeMenu, e -> setTheme(t));
        }
        menuBar.add(themeMenu);
    }

    private JMenu menu(String name) {
        JMenu m = new JMenu(name);
        m.setFont(UI_FONT);
        return m;
    }

    private JMenuItem mitem(String name, JMenu m, Consumer<ActionEvent> a, KeyStroke ks) {
        JMenuItem i = new JMenuItem(name);
        i.setFont(UI_FONT);
        i.addActionListener(e -> a.accept(e));
        if (ks != null)
            i.setAccelerator(ks);
        m.add(i);
        return i;
    }

    private void mitem(String name, JMenu m, Consumer<ActionEvent> a) {
        mitem(name, m, a, null);
    }

    // ———————————————————————————————— FILE OPERATIONS
    // ————————————————————————————————

    private void openFile() {
        JFileChooser fc = new JFileChooser();
        fc.setDialogTitle("Open File");
        if (fc.showOpenDialog(frame) == JFileChooser.APPROVE_OPTION)
            openFileInTab(fc.getSelectedFile().getAbsolutePath());
    }

    private void openFileInTab(String path) {
        try {
            String content = readFileToString(path);
            addRecentFile(path);
            DocumentTab tab = new DocumentTab();
            tab.textArea.setText(content);

            /*
             * Opening the file is its initial state, not something that the user
             * should be able to undo.
             */
            tab.undoManager.discardAllEdits();

            tab.setFilePath(path);
            tab.markClean();
            int i = tabbedPane.getTabCount();
            tabbedPane.addTab(tab.fileName, tab.scrollPane);
            tabbedPane.setTabComponentAt(i, tabHeader(tab.fileName));
            tabbedPane.setSelectedIndex(i);
            storeTabRef(i, tab);
            tab.textArea.setCaretPosition(0);
            tab.textArea.requestFocusInWindow();
            tab.applyEditorColors(pal);
            updateFrameTitle();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(frame, "Could not open file:\n" + e.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    // Streams the file through a buffered reader instead of reading all bytes
    // and then converting to a String, avoiding holding two full copies of
    // large files in memory at once.
    private String readFileToString(String path) throws IOException {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader r = Files.newBufferedReader(Paths.get(path))) {
            char[] buf = new char[8192];
            int n;
            while ((n = r.read(buf)) != -1)
                sb.append(buf, 0, n);
        }
        return sb.toString();
    }

    private void saveCurrentTab(boolean saveAs) {
        DocumentTab t = currentTab();
        if (t == null)
            return;
        if (saveAs || t.filePath == null) {
            JFileChooser fc = new JFileChooser();
            fc.setDialogTitle("Save As");
            if (fc.showSaveDialog(frame) == JFileChooser.APPROVE_OPTION) {
                String path = fc.getSelectedFile().getAbsolutePath();
                path = addExtensionIfMissing(path, t.defaultExtension);
                writeFile(path, t.textArea.getText());
                t.setFilePath(path);
                t.markClean();
            }
        } else {
            writeFile(t.filePath, t.textArea.getText());
            t.markClean();
        }
    }

    private void writeFile(String path, String content) {
        try {
            Files.write(Paths.get(path), content.getBytes());
        } catch (IOException e) {
            JOptionPane.showMessageDialog(frame, "Could not save:\n" + e.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    // ———————————————————————————————— RECENT FILES
    // ————————————————————————————————

    private void loadRecentFiles() {
        File f = new File(RECENT_FILE);
        if (f.exists()) {
            try (Stream<String> lines = Files.lines(f.toPath())) {
                lines.forEach(recentFiles::add);
            } catch (IOException ignored) {
            }
        }
    }

    private void saveRecentFiles() {
        try {
            Files.write(Paths.get(RECENT_FILE), recentFiles);
        } catch (IOException ignored) {
        }
    }

    private void addRecentFile(String path) {
        recentFiles.remove(path);
        recentFiles.add(0, path);
        if (recentFiles.size() > MAX_RECENT_FILES)
            recentFiles = new ArrayList<>(recentFiles.subList(0, MAX_RECENT_FILES));
        saveRecentFiles();
        rebuildRecentFiles();
    }

    private void rebuildRecentFiles() {
        recentFilesMenu.removeAll();
        if (recentFiles.isEmpty()) {
            JMenuItem e = new JMenuItem("(No recent files)");
            e.setEnabled(false);
            recentFilesMenu.add(e);
            return;
        }
        for (String p : recentFiles) {
            JMenuItem i = new JMenuItem(p);
            i.addActionListener(e -> {
                if (new File(p).exists())
                    openFileInTab(p);
                else {
                    recentFiles.remove(p);
                    rebuildRecentFiles();
                    JOptionPane.showMessageDialog(frame, "File not found:\n" + p, "Error", JOptionPane.ERROR_MESSAGE);
                }
            });
            recentFilesMenu.add(i);
        }
        recentFilesMenu.addSeparator();
        JMenuItem cl = new JMenuItem("Clear Recent Files");
        cl.addActionListener(e -> {
            recentFiles.clear();
            rebuildRecentFiles();
            saveRecentFiles();
        });
        recentFilesMenu.add(cl);
    }

    // ———————————————————————————————— FIND / REPLACE
    // ————————————————————————————————

    private JDialog findDialog;
    private JTextField findField, replaceField;

    private void showFindReplace() {
        if (findDialog != null && findDialog.isVisible()) {
            findDialog.requestFocus();
            return;
        }
        findDialog = new JDialog(frame, "Find / Replace", false);
        findDialog.setSize(460, 200);
        findDialog.setLocationRelativeTo(frame);

        JPanel p = new JPanel(new GridBagLayout());
        p.setBorder(new EmptyBorder(14, 14, 14, 14));
        GridBagConstraints g = new GridBagConstraints();
        g.fill = GridBagConstraints.HORIZONTAL;
        g.insets = new Insets(4, 4, 4, 4);

        g.gridx = 0;
        g.gridy = 0;
        g.weightx = 0;
        p.add(new JLabel("Find:"), g);
        g.gridx = 1;
        g.weightx = 1;
        findField = new JTextField(25);
        p.add(findField, g);

        g.gridx = 0;
        g.gridy = 1;
        g.weightx = 0;
        p.add(new JLabel("Replace:"), g);
        g.gridx = 1;
        g.weightx = 1;
        replaceField = new JTextField(25);
        p.add(replaceField, g);

        g.gridx = 0;
        g.gridy = 2;
        g.weightx = 0;
        g.insets = new Insets(10, 4, 4, 4);

        JButton fb = new JButton("Find Next");
        fb.addActionListener(e -> findNext());
        p.add(fb, g);
        g.gridx = 1;
        JButton rb = new JButton("Replace");
        rb.addActionListener(e -> {
            replaceCurrent();
        });
        p.add(rb, g);
        g.gridx = 2;
        JButton rab = new JButton("Replace All");
        rab.addActionListener(e -> replaceAll());
        p.add(rab, g);

        findField.addActionListener(e -> findNext());
        findDialog.add(p);
        findDialog.setVisible(true);
        findField.requestFocusInWindow();
    }

    private void findNext() {
        DocumentTab t = currentTab();
        if (t == null)
            return;
        String s = findField.getText();
        if (s.isEmpty())
            return;
        String text = t.textArea.getText();
        int start = t.textArea.getCaretPosition();
        int idx = text.indexOf(s, start);
        if (idx < 0)
            idx = text.indexOf(s, 0);
        if (idx >= 0) {
            t.textArea.setCaretPosition(idx);
            t.textArea.select(idx, idx + s.length());
        }
    }

    private void replaceCurrent() {
        DocumentTab t = currentTab();
        if (t == null)
            return;
        String sel = t.textArea.getSelectedText();
        String s = findField.getText();
        if (sel != null && sel.equals(s))
            t.textArea.replaceSelection(replaceField.getText());
        findNext();
    }

    private void replaceAll() {
        DocumentTab t = currentTab();
        if (t == null)
            return;
        String s = findField.getText();
        String r = replaceField.getText();
        if (s.isEmpty())
            return;
        t.textArea.setText(t.textArea.getText().replace(s, r));
    }

    // ———————————————————————————————— COMMENT / UNCOMMENT
    // ————————————————————————————————

    private void commentUncommentLines() {
        DocumentTab t = currentTab();
        if (t == null)
            return;

        JTextPane textArea = t.textArea;
        int start = textArea.getSelectionStart();
        int end = textArea.getSelectionEnd();

        try {
            int startLine = getLineOfOffset(textArea, start);
            int endLine = getLineOfOffset(textArea, end);

            if (start == end) {
                startLine = endLine = getLineOfOffset(textArea, textArea.getCaretPosition());
            }

            StringBuilder sb = new StringBuilder(textArea.getText());
            boolean shouldComment = shouldCommentLines(sb, startLine, endLine);

            for (int i = endLine; i >= startLine; i--) {
                int lineStart = getLineStartOffset(textArea, i);
                int lineEnd = getLineEndOffset(textArea, i);
                String line = sb.substring(lineStart, Math.min(lineEnd, sb.length()));

                if (shouldComment) {
                    String trimmed = line.replaceFirst("^(\\s*)", "$1// ");
                    sb.replace(lineStart, Math.min(lineEnd, sb.length()), trimmed);
                } else {
                    String uncommented = line.replaceFirst("^(\\s*)//\\s?", "$1");
                    sb.replace(lineStart, Math.min(lineEnd, sb.length()), uncommented);
                }
            }

            textArea.setText(sb.toString());
            textArea.setSelectionStart(getLineStartOffset(textArea, startLine));
            textArea.setSelectionEnd(getLineEndOffset(textArea, endLine));

        } catch (BadLocationException e) {
            JOptionPane.showMessageDialog(frame, "Error commenting lines: " + e.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private boolean shouldCommentLines(StringBuilder text, int startLine, int endLine) throws BadLocationException {
        DocumentTab t = currentTab();
        if (t == null)
            return true;

        for (int i = startLine; i <= endLine; i++) {
            int lineStart = getLineStartOffset(t.textArea, i);
            int lineEnd = getLineEndOffset(t.textArea, i);
            String line = text.substring(lineStart, Math.min(lineEnd, text.length())).trim();

            if (!line.isEmpty() && !line.startsWith("//")) {
                return true;
            }
        }
        return false;
    }

    // ———————————————————————————————— ZOOM ————————————————————————————————

    private void zoomIn() {
        defaultFontSize = Math.min(defaultFontSize + 2, 72);
        forAllTabs(DocumentTab::applyFont);
    }

    private void zoomOut() {
        defaultFontSize = Math.max(defaultFontSize - 2, 8);
        forAllTabs(DocumentTab::applyFont);
    }

    private void resetZoom() {
        defaultFontSize = 16;
        forAllTabs(DocumentTab::applyFont);
    }

    // ———————————————————————————————— TEMPLATES ————————————————————————————————

    private String extensionForLanguage(String language) {
        switch (language) {
            case "Java":
                return ".java";
            case "HTML":
                return ".html";
            case "C":
                return ".c";
            case "CPP":
                return ".cpp";
            case "Python":
                return ".py";
            case "JavaScript":
                return ".js";
            default:
                return "";
        }
    }

    private String addExtensionIfMissing(String path, String extension) {
        if (extension == null || extension.isEmpty())
            return path;

        String name = new File(path).getName();
        int dot = name.lastIndexOf('.');

        if (dot > 0 && dot < name.length() - 1) {
            return path;
        }

        if (name.endsWith(".")) {
            return path + extension.substring(1);
        }

        return path + extension;
    }

    private void loadTemplate(String lang) {
        File dir = new File(TEMPLATE_PATH);
        if (!dir.exists())
            dir.mkdirs();
        String tf = TEMPLATE_PATH + lang + "Format.txt";
        File f = new File(tf);
        if (!f.exists())
            createTemplateFile(lang, tf);
        try {
            String content = readFileToString(tf);

            DocumentTab tab = new DocumentTab();
            tab.textArea.setText(content);

            /*
             * Treat the loaded template as the initial editor state.
             */
            tab.undoManager.discardAllEdits();

            tab.defaultExtension = extensionForLanguage(lang);
            tab.fileName = "new" + tab.defaultExtension;
            tab.markClean();
            int i = tabbedPane.getTabCount();
            tabbedPane.addTab(tab.fileName, tab.scrollPane);
            tabbedPane.setTabComponentAt(i, tabHeader(tab.fileName));
            tabbedPane.setSelectedIndex(i);
            storeTabRef(i, tab);
            tab.textArea.setCaretPosition(0);
            tab.textArea.requestFocusInWindow();
            tab.applyEditorColors(pal);
            updateFrameTitle();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(frame, "Could not load template:\n" + e.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private void createTemplateFile(String lang, String path) {
        String c;
        switch (lang) {
            case "Java":
                c = "public class Main {\n\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}\n";
                break;
            case "HTML":
                c = "<!DOCTYPE html>\n<html>\n<head>\n    <title>Title</title>\n</head>\n<body>\n    <h1>Hello, World!</h1>\n</body>\n</html>\n";
                break;
            case "C":
                c = "#include <stdio.h>\n\nint main() {\n    printf(\"Hello, World!\\n\");\n    return 0;\n}\n";
                break;
            case "CPP":
                c = "#include <iostream>\n\nint main() {\n    std::cout << \"Hello, World!\" << std::endl;\n    return 0;\n}\n";
                break;
            case "Python":
                c = "def main():\n    print(\"Hello, World!\")\n\nif __name__ == \"__main__\":\n    main()\n";
                break;
            case "JavaScript":
                c = "function main() {\n    console.log(\"Hello, World!\");\n}\n\nmain();\n";
                break;
            default:
                c = "";
        }
        try {
            Files.write(Paths.get(path), c.getBytes());
        } catch (IOException ignored) {
        }
    }

    private static final Pattern PACKAGE_DECLARATION_PATTERN = Pattern.compile(
            "(?m)^\\s*package\\s+([A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*)*)\\s*;");

    private static class BuildInfo {
        final Path sourceFile;
        final Path sourceRoot;
        final Path projectDirectory;
        final Path binDirectory;
        final String mainClassName;

        BuildInfo(
                Path sourceFile,
                Path sourceRoot,
                Path projectDirectory,
                Path binDirectory,
                String mainClassName) {
            this.sourceFile = sourceFile;
            this.sourceRoot = sourceRoot;
            this.projectDirectory = projectDirectory;
            this.binDirectory = binDirectory;
            this.mainClassName = mainClassName;
        }
    }

    private BuildInfo getBuildInfo(String sourcePath) throws IOException {
        Path sourceFile = Paths.get(sourcePath)
                .toAbsolutePath()
                .normalize();

        String sourceCode = Files.readString(sourceFile);

        Matcher packageMatcher = PACKAGE_DECLARATION_PATTERN.matcher(sourceCode);

        String packageName = packageMatcher.find() ? packageMatcher.group(1) : "";

        Path sourceDirectory = sourceFile.getParent();
        Path sourceRoot = sourceDirectory;

        /*
         * Example:
         *
         * project/src/nn/Main.java
         * package nn;
         *
         * sourceRoot becomes project/src.
         */
        if (!packageName.isEmpty()) {
            String[] packageParts = packageName.split("\\.");
            Path cursor = sourceDirectory;
            boolean packagePathMatches = true;

            for (int i = packageParts.length - 1; i >= 0; i--) {
                if (cursor == null
                        || cursor.getFileName() == null
                        || !cursor.getFileName().toString().equals(packageParts[i])) {

                    packagePathMatches = false;
                    break;
                }

                cursor = cursor.getParent();
            }

            if (packagePathMatches && cursor != null) {
                sourceRoot = cursor;
            }
        }

        /*
         * project/src becomes project, so compiled files go to project/bin.
         * For projects without a src directory, bin is created in the source root.
         */
        Path projectDirectory = sourceRoot;

        if (sourceRoot.getFileName() != null
                && sourceRoot.getFileName().toString().equalsIgnoreCase("src")
                && sourceRoot.getParent() != null) {

            projectDirectory = sourceRoot.getParent();
        }

        Path binDirectory = projectDirectory.resolve("bin");

        String fileName = sourceFile.getFileName().toString();
        String simpleClassName = fileName.substring(0, fileName.length() - ".java".length());

        String mainClassName = packageName.isEmpty()
                ? simpleClassName
                : packageName + "." + simpleClassName;

        return new BuildInfo(
                sourceFile,
                sourceRoot,
                projectDirectory,
                binDirectory,
                mainClassName);
    }

    private ProcessBuilder createJavaCompiler(BuildInfo build) {
        ProcessBuilder processBuilder = new ProcessBuilder(
                "javac",
                "-encoding", "UTF-8",
                "-classpath", build.binDirectory.toString(),
                "-sourcepath", build.sourceRoot.toString(),
                "-d", build.binDirectory.toString(),
                build.sourceFile.toString());

        processBuilder.directory(build.projectDirectory.toFile());
        processBuilder.redirectErrorStream(true);

        return processBuilder;
    }

    // ———————————————————————————————— COMPILE / RUN
    // ————————————————————————————————

    private void compileJavaCode() {
        DocumentTab tab = currentTab();
        if (tab == null) {
            return;
        }

        if (tab.filePath == null || !tab.filePath.endsWith(".java")) {
            saveCurrentTab(true);
        } else {
            saveCurrentTab(false);
        }

        tab = currentTab();

        if (tab == null || tab.filePath == null) {
            return;
        }

        if (!tab.filePath.endsWith(".java")) {
            outputArea.setText(" Please save the file as .java first.\n");
            return;
        }

        final BuildInfo build;

        try {
            build = getBuildInfo(tab.filePath);
        } catch (IOException e) {
            outputArea.setText(
                    " Could not prepare compilation:\n" +
                            e.getMessage() + "\n");
            return;
        }

        outputArea.setText(
                " ⚙ Compiling...\n" +
                        " Output directory: " + build.binDirectory + "\n");

        new Thread(() -> {
            try {
                Files.createDirectories(build.binDirectory);

                Process process = createJavaCompiler(build).start();
                String compilerOutput = new String(process.getInputStream().readAllBytes());

                int exitCode = process.waitFor();

                SwingUtilities.invokeLater(() -> {
                    if (exitCode == 0) {
                        outputArea.append(
                                " ✓ Compilation successful!\n" +
                                        " Class files saved in:\n " +
                                        build.binDirectory + "\n");
                    } else {
                        outputArea.append(
                                " ✗ Compilation failed:\n" +
                                        compilerOutput + "\n");
                    }
                });
            } catch (Exception e) {
                SwingUtilities.invokeLater(() -> outputArea.append(
                        " ✗ Compilation error:\n" +
                                e.getMessage() + "\n"));
            }
        }, "compile-thread").start();
    }

    private void runCurrentFile() {
        DocumentTab tab = currentTab();

        if (tab == null) {
            return;
        }

        if (tab.filePath == null) {
            saveCurrentTab(false);
            tab = currentTab();
        } else {
            saveCurrentTab(false);
        }

        if (tab == null || tab.filePath == null) {
            return;
        }

        String path = tab.filePath;
        String lowerPath = path.toLowerCase(Locale.ROOT);

        if (lowerPath.endsWith(".java")) {
            runJavaCode();

        } else if (lowerPath.endsWith(".py")) {
            runPythonFile(path);

        } else if (lowerPath.endsWith(".js")) {
            runJavaScriptFile(path);

        } else {
            outputArea.setText(
                    " Running this file type is not supported:\n" +
                            path + "\n");
        }
    }

    private void runPythonFile(String path) {
        List<List<String>> commands = new ArrayList<>();

        if (System.getProperty("os.name")
                .toLowerCase(Locale.ROOT)
                .contains("win")) {

            commands.add(Arrays.asList("python", "-u", path));
            commands.add(Arrays.asList("py", "-u", path));

        } else {
            commands.add(Arrays.asList("python3", "-u", path));
            commands.add(Arrays.asList("python", "-u", path));
        }

        launchScriptWithFallback(
                commands,
                new File(path),
                "Python");
    }

    private void runJavaScriptFile(String path) {
        List<List<String>> commands = new ArrayList<>();

        commands.add(Arrays.asList(
                "node",
                path));

        launchScriptWithFallback(
                commands,
                new File(path),
                "JavaScript");
    }

    private void launchScriptWithFallback(
            List<List<String>> commands,
            File scriptFile,
            String runtimeName) {
        outputArea.setText(
                " Starting " + runtimeName + "...\n");

        new Thread(() -> {
            IOException lastError = null;

            for (List<String> command : commands) {
                try {
                    ProcessBuilder processBuilder = new ProcessBuilder(command);

                    processBuilder.directory(
                            scriptFile.getParentFile());

                    processBuilder.redirectErrorStream(false);

                    Process process = processBuilder.start();

                    SwingUtilities.invokeLater(() -> attachProcess(
                            process,
                            runtimeName + " - " +
                                    scriptFile.getName()));

                    return;

                } catch (IOException e) {
                    lastError = e;
                }
            }

            final IOException error = lastError;

            SwingUtilities.invokeLater(() -> {
                outputArea.setText(
                        " Could not start " + runtimeName + ".\n");

                if ("Python".equals(runtimeName)) {
                    outputArea.append(
                            " Install Python and ensure `python`, " +
                                    "`python3`, or `py` is available in PATH.\n");
                } else if ("JavaScript".equals(runtimeName)) {
                    outputArea.append(
                            " Install Node.js and ensure `node` " +
                                    "is available in PATH.\n");
                }

                if (error != null) {
                    outputArea.append(
                            "\n Error: " + error.getMessage() + "\n");
                }
            });

        }, runtimeName.toLowerCase(Locale.ROOT) + "-runner").start();
    }

    private void attachProcess(
            Process process,
            String displayName) {
        if (currentProcess != null && currentProcess.isAlive()) {
            currentProcess.destroy();
        }

        currentProcess = process;

        processInputWriter = new PrintWriter(
                new OutputStreamWriter(process.getOutputStream()),
                true);

        outputArea.setText(
                " Running " + displayName + "...\n\n");

        consoleSplitPane.setDividerSize(6);
        inputArea.setEnabled(true);
        inputArea.requestFocusInWindow();

        final Process runningProcess = process;
        final StringBuilder pendingOutput = new StringBuilder();
        final Object outputLock = new Object();

        javax.swing.Timer flushTimer = new javax.swing.Timer(50, event -> {

            String output;

            synchronized (outputLock) {
                if (pendingOutput.length() == 0) {
                    return;
                }

                output = pendingOutput.toString();
                pendingOutput.setLength(0);
            }

            outputArea.append(output);
            outputArea.setCaretPosition(
                    outputArea.getDocument().getLength());
        });

        flushTimer.start();

        new Thread(() -> {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(
                            runningProcess.getInputStream()))) {

                String line;

                while ((line = reader.readLine()) != null) {
                    synchronized (outputLock) {
                        pendingOutput
                                .append(' ')
                                .append(line)
                                .append('\n');
                    }
                }

            } catch (IOException ignored) {
            }
        }, "script-stdout-reader").start();

        new Thread(() -> {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(
                            runningProcess.getErrorStream()))) {

                String line;

                while ((line = reader.readLine()) != null) {
                    synchronized (outputLock) {
                        pendingOutput
                                .append(" [ERROR] ")
                                .append(line)
                                .append('\n');
                    }
                }

            } catch (IOException ignored) {
            }
        }, "script-stderr-reader").start();

        new Thread(() -> {
            try {
                int exitCode = runningProcess.waitFor();

                SwingUtilities.invokeLater(() -> {
                    flushTimer.stop();

                    String remainingOutput;

                    synchronized (outputLock) {
                        remainingOutput = pendingOutput.toString();

                        pendingOutput.setLength(0);
                    }

                    if (!remainingOutput.isEmpty()) {
                        outputArea.append(remainingOutput);
                    }

                    outputArea.append(
                            "\n ← Process exited with code " +
                                    exitCode + "\n");

                    inputArea.setEnabled(false);
                    consoleSplitPane.setDividerSize(0);

                    if (processInputWriter != null) {
                        processInputWriter.close();
                        processInputWriter = null;
                    }

                    if (currentProcess == runningProcess) {
                        currentProcess = null;
                    }
                });

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "script-wait-thread").start();
    }

    private void runJavaCode() {
        DocumentTab tab = currentTab();

        if (tab == null || tab.filePath == null) {
            outputArea.setText(" Please save the file first.\n");
            return;
        }

        if (!tab.filePath.endsWith(".java")) {
            outputArea.setText(" Please save the file as .java first.\n");
            return;
        }

        saveCurrentTab(false);

        final BuildInfo build;

        try {
            build = getBuildInfo(tab.filePath);
        } catch (IOException e) {
            outputArea.setText(
                    " Could not prepare the program:\n" +
                            e.getMessage() + "\n");
            return;
        }

        outputArea.setText(
                " ⚙ Compiling...\n" +
                        " Output directory: " + build.binDirectory + "\n");

        new Thread(() -> {
            try {
                Files.createDirectories(build.binDirectory);

                Process compilerProcess = createJavaCompiler(build).start();

                String compilerOutput = new String(compilerProcess.getInputStream().readAllBytes());

                int exitCode = compilerProcess.waitFor();

                if (exitCode != 0) {
                    SwingUtilities.invokeLater(() -> outputArea.append(
                            " ✗ Compilation failed:\n" +
                                    compilerOutput + "\n"));
                    return;
                }

                SwingUtilities.invokeLater(() -> {
                    outputArea.append(" ✓ Compilation successful!\n");
                    launchJavaProcess(build);
                });

            } catch (Exception e) {
                SwingUtilities.invokeLater(() -> outputArea.append(
                        " ✗ Compilation error:\n" +
                                e.getMessage() + "\n"));
            }
        }, "run-compile-thread").start();
    }

    private void launchJavaProcess(BuildInfo build) {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder(
                    "java",
                    "-cp",
                    build.binDirectory.toString(),
                    build.mainClassName);

            processBuilder.directory(build.projectDirectory.toFile());
            processBuilder.redirectErrorStream(false);

            currentProcess = processBuilder.start();

            processInputWriter = new PrintWriter(
                    new OutputStreamWriter(currentProcess.getOutputStream()),
                    true);

            outputArea.setText(
                    " Running " + build.mainClassName + "...\n" +
                            " Classpath: " + build.binDirectory + "\n\n");

            consoleSplitPane.setDividerSize(6);
            inputArea.setEnabled(true);
            inputArea.requestFocusInWindow();

            final Process runningProcess = currentProcess;
            final StringBuilder pendingOutput = new StringBuilder();
            final Object outputLock = new Object();

            javax.swing.Timer flushTimer = new javax.swing.Timer(50, event -> {

                String chunk;

                synchronized (outputLock) {
                    if (pendingOutput.length() == 0) {
                        return;
                    }

                    chunk = pendingOutput.toString();
                    pendingOutput.setLength(0);
                }

                outputArea.append(chunk);
                outputArea.setCaretPosition(
                        outputArea.getDocument().getLength());
            });

            flushTimer.start();

            new Thread(() -> {
                try (BufferedReader reader = new BufferedReader(
                        new InputStreamReader(runningProcess.getInputStream()))) {

                    String line;

                    while ((line = reader.readLine()) != null) {
                        synchronized (outputLock) {
                            pendingOutput
                                    .append(' ')
                                    .append(line)
                                    .append('\n');
                        }
                    }
                } catch (IOException ignored) {
                }
            }, "stdout-reader").start();

            new Thread(() -> {
                try (BufferedReader reader = new BufferedReader(
                        new InputStreamReader(runningProcess.getErrorStream()))) {

                    String line;

                    while ((line = reader.readLine()) != null) {
                        synchronized (outputLock) {
                            pendingOutput
                                    .append(" [ERROR] ")
                                    .append(line)
                                    .append('\n');
                        }
                    }
                } catch (IOException ignored) {
                }
            }, "stderr-reader").start();

            new Thread(() -> {
                try {
                    int exitCode = runningProcess.waitFor();

                    SwingUtilities.invokeLater(() -> {
                        flushTimer.stop();

                        String remainingOutput;

                        synchronized (outputLock) {
                            remainingOutput = pendingOutput.toString();
                            pendingOutput.setLength(0);
                        }

                        if (!remainingOutput.isEmpty()) {
                            outputArea.append(remainingOutput);
                        }

                        outputArea.append(
                                "\n ← Process exited with code " +
                                        exitCode + "\n");

                        outputArea.setCaretPosition(
                                outputArea.getDocument().getLength());

                        inputArea.setEnabled(false);
                        consoleSplitPane.setDividerSize(0);

                        if (processInputWriter != null) {
                            processInputWriter.close();
                            processInputWriter = null;
                        }

                        if (currentProcess == runningProcess) {
                            currentProcess = null;
                        }
                    });

                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "wait-thread").start();

        } catch (IOException e) {
            JOptionPane.showMessageDialog(
                    frame,
                    "Run error:\n" + e.getMessage(),
                    "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    private void sendInput() {
        if (currentProcess != null && currentProcess.isAlive() && processInputWriter != null) {
            String in = inputArea.getText();
            outputArea.append(" > " + in + "\n");
            processInputWriter.println(in);
            processInputWriter.flush();
            inputArea.setText("");
        }
    }

    private void stopRunningProcess() {
        if (currentProcess != null && currentProcess.isAlive()) {
            if (processInputWriter != null) {
                processInputWriter.close();
                processInputWriter = null;
            }
            currentProcess.destroy();
            outputArea.append("\n \u2717 Process terminated\n");
            inputArea.setEnabled(false);
            consoleSplitPane.setDividerSize(0);
        }
    }

    private void openCmd() {
        DocumentTab t = currentTab();
        try {
            String dir = (t != null && t.filePath != null) ? new File(t.filePath).getParent()
                    : System.getProperty("user.dir");
            Runtime.getRuntime().exec(new String[] { "cmd", "/k", "start" }, null, new File(dir));
        } catch (IOException e) {
            JOptionPane.showMessageDialog(frame, "Could not open CMD:\n" + e.getMessage(), "Error",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    // ———————————————————————————————— THEMES ————————————————————————————————

    private void setTheme(Theme t) {
        currentTheme = t;
        pal = palette(t);
        applyTheme(t);
    }

    private void applyTheme(Theme theme) {
        pal = palette(theme);

        frame.getContentPane().setBackground(pal.bg);

        toolBar.setBackground(pal.bg);
        for (Component c : toolBar.getComponents()) {
            if (c instanceof JButton && Boolean.TRUE.equals(((JButton) c).getClientProperty("nn.hoverable"))) {
                c.setForeground(pal.fg);
                ((JButton) c).setBackground(pal.bg);
            }
        }

        UIManager.put("Menu.background", pal.bgLighter);
        UIManager.put("Menu.foreground", pal.fg);
        UIManager.put("MenuItem.background", pal.bgLighter);
        UIManager.put("MenuItem.foreground", pal.fg);
        UIManager.put("PopupMenu.background", pal.bgLighter);
        UIManager.put("PopupMenu.foreground", pal.fg);
        UIManager.put("MenuBar.background", pal.bgLighter);
        UIManager.put("MenuBar.foreground", pal.fg);
        UIManager.put("CheckBoxMenuItem.background", pal.bgLighter);
        UIManager.put("CheckBoxMenuItem.foreground", pal.fg);

        menuBar.setBackground(pal.bgLighter);
        menuBar.setForeground(pal.fg);
        for (int i = 0; i < menuBar.getMenuCount(); i++) {
            JMenu m = menuBar.getMenu(i);
            if (m == null)
                continue;
            m.setForeground(pal.fg);
            m.setBackground(pal.bgLighter);
            for (int j = 0; j < m.getItemCount(); j++) {
                JMenuItem mi = m.getItem(j);
                if (mi != null) {
                    mi.setForeground(pal.fg);
                    mi.setBackground(pal.bgLighter);
                }
            }
        }

        UIManager.put("TabbedPane.background", pal.bg);
        UIManager.put("TabbedPane.foreground", pal.fg);
        UIManager.put("TabbedPane.selected", pal.bg);
        tabbedPane.setBackground(pal.bg);
        tabbedPane.setForeground(pal.fg);
        for (int i = 0; i < tabbedPane.getTabCount(); i++) {
            DocumentTab tab = tabAt(i);
            if (tab != null)
                tab.applyEditorColors(pal);
            JPanel tabComp = (JPanel) tabbedPane.getTabComponentAt(i);
            if (tabComp != null) {
                tabComp.setBackground(pal.bg);
                for (Component comp : tabComp.getComponents()) {
                    if (comp instanceof JLabel)
                        comp.setForeground(pal.fg);
                    if (comp instanceof JButton) {
                        comp.setForeground(pal.fg);
                    }
                }
            }
        }

        outputArea.setBackground(pal.bg);
        outputArea.setForeground(pal.fg);
        outputArea.setCaretColor(pal.fg);

        inputArea.setBackground(pal.bgLighter);
        inputArea.setForeground(pal.fg);
        inputArea.setCaretColor(pal.fg);

        consolePanel.setBackground(pal.bg);

        statusBar.applyColors(pal);

        if (projectExplorerPanel != null) {
            projectExplorerPanel.setBackground(pal.bgLighter);
            projectExplorerHeader.setBackground(pal.bgLighter);

            projectTitleLabel.setForeground(pal.fg);

            if (explorerFilterField != null) {
                explorerFilterField.setBackground(pal.bg);
                explorerFilterField.setForeground(pal.fg);
                explorerFilterField.setBorder(new CompoundBorder(
                        new MatteBorder(0, 0, 1, 0, pal.comment),
                        new EmptyBorder(4, 8, 4, 8)));
            }

            projectTree.setBackground(pal.bgLighter);
            projectTree.setForeground(pal.fg);
            projectTree.setCellRenderer(new ProjectTreeRenderer());

            if (projectTree.getParent() != null) {
                projectTree.getParent().setBackground(pal.bgLighter);
            }

            // Theme icon buttons in the explorer header
            for (Component c : projectExplorerHeader.getComponents()) {
                if (c instanceof JPanel) {
                    for (Component b : ((JPanel) c).getComponents()) {
                        if (b instanceof JButton) {
                            b.setForeground(pal.fg);
                        }
                    }
                }
            }
        }
        SwingUtilities.updateComponentTreeUI(frame);
        frame.repaint();
        frame.revalidate();
    }

    // ———————————————————————————————— FRAME TITLE ————————————————————————————————

    private String lastTitle = null;

    private void updateFrameTitle() {
        DocumentTab t = currentTab();
        String title = (t != null) ? ((t.dirty ? "* " : "") + t.fileName + " - pavans-Notepadplusplus") : "pavans-Notepadplusplus";
        // Skip redundant setTitle() calls (native window repaint) when nothing
        // actually changed.
        if (!title.equals(lastTitle)) {
            lastTitle = title;
            frame.setTitle(title);
        }
    }

    // ———————————————————————————————— LINE NUMBERS
    // ————————————————————————————————

    class LineNumberComponent extends JComponent {
        private static final long serialVersionUID = 1L;
        private final JTextPane textArea;
        Font font;
        Color bgColor = pal.bg;
        Color fgColor = pal.comment;

        LineNumberComponent(JTextPane ta) {
            this.textArea = ta;
            this.font = new Font(currentFontFamily, Font.PLAIN, defaultFontSize);
            setPreferredSize(new Dimension(48, 10));
            DocumentListener dl = new DocumentListener() {
                public void insertUpdate(DocumentEvent e) {
                    repaint();
                }

                public void removeUpdate(DocumentEvent e) {
                    repaint();
                }

                public void changedUpdate(DocumentEvent e) {
                    /* style-only: no line-count change */ }
            };
            textArea.getDocument().addDocumentListener(dl);
            textArea.addComponentListener(new ComponentAdapter() {
                public void componentResized(ComponentEvent e) {
                    repaint();
                }
            });
            // Caret-triggered repaints are handled by DocumentTab's caret
            // listener (only repaints on an actual line change), so no
            // separate caretListener here — halves gutter repaints per keystroke.
        }

        @Override
        protected void paintComponent(Graphics g) {
            Graphics2D g2 = (Graphics2D) g.create();
            g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

            Rectangle clip = g2.getClipBounds();
            g2.setColor(bgColor);
            g2.fillRect(clip.x, clip.y, clip.width, clip.height);

            g2.setColor(new Color(fgColor.getRed(), fgColor.getGreen(), fgColor.getBlue(), 60));
            g2.fillRect(getWidth() - 2, clip.y, 2, clip.height);

            FontMetrics fm = g2.getFontMetrics(font);
            g2.setFont(font);
            g2.setColor(fgColor);

            try {
                int first = Math.max(0, getLineOfOffset(textArea,
                        textArea.viewToModel2D(new Point2D.Double(0, clip.y))) - 1);
                int last = Math.min(getLineCount(textArea) - 1,
                        getLineOfOffset(textArea, textArea.viewToModel2D(new Point2D.Double(0, clip.y + clip.height)))
                                + 1);

                int caretLine = getLineOfOffset(textArea, textArea.getCaretPosition());

                for (int i = first; i <= last; i++) {
                    Rectangle2D r2d = textArea.modelToView2D(getLineStartOffset(textArea, i));
                    if (r2d == null)
                        continue;
                    Rectangle r = r2d.getBounds();
                    if (r == null)
                        continue;
                    String num = String.valueOf(i + 1);
                    int x = getWidth() - fm.stringWidth(num) - 8;
                    if (i == caretLine) {
                        g2.setColor(pal.pink);
                        g2.drawString(num, x, r.y + fm.getAscent());
                        g2.setColor(fgColor);
                    } else {
                        g2.drawString(num, x, r.y + fm.getAscent());
                    }
                }
            } catch (Exception ignored) {
            }

            g2.dispose();
        }

        void updateFont() {
            this.font = new Font(currentFontFamily, Font.PLAIN, defaultFontSize);
            repaint();
        }
    }

    // ———————————————————————————————— AUTO-SAVE ————————————————————————————————

    private void startAutoSave() {
        autoSaveTimer = new javax.swing.Timer(30000, e -> performAutoSave());
        autoSaveTimer.start();
    }

    private void performAutoSave() {
        for (int i = 0; i < tabbedPane.getTabCount(); i++) {
            DocumentTab tab = tabAt(i);
            if (tab != null && tab.dirty && tab.filePath != null && tab.filePath.endsWith(".java")) {
                try {
                    writeFile(tab.filePath, tab.textArea.getText());
                    statusBar.showAutoSaveMessage("Auto-saved: " + tab.fileName);
                } catch (Exception ignored) {
                }
            }
        }
    }

    // ———————————————————————————————— SYNTAX HIGHLIGHTING
    // ————————————————————————————————

    private static class JavaSyntaxHighlighter {

        private static final Pattern COMMENT_PATTERN = Pattern.compile("//.*|/\\*[\\s\\S]*?\\*/");
        private static final Pattern STRING_PATTERN = Pattern.compile("\"([^\"\\\\]|\\\\.)*\"");
        private static final Pattern CHAR_PATTERN = Pattern.compile("'([^'\\\\]|\\\\.)*'");
        private static final Pattern NUMBER_PATTERN = Pattern.compile("\\b[0-9]+(\\.[0-9]+)?[fFlLdD]?\\b");
        private static final Pattern ANNOTATION_PATTERN = Pattern.compile("@\\b[A-Za-z_][A-Za-z0-9_]*\\b");

        private static final String[] KEYWORDS = {
                // Reserved keywords
                "abstract", "assert", "boolean", "break", "byte",
                "case", "catch", "char", "class", "const",
                "continue", "default", "do", "double", "else",
                "enum", "extends", "final", "finally", "float",
                "for", "goto", "if", "implements", "import",
                "instanceof", "int", "interface", "long", "native",
                "new", "package", "private", "protected", "public",
                "return", "short", "static", "strictfp", "super",
                "switch", "synchronized", "this", "throw", "throws",
                "transient", "try", "void", "volatile", "while", "_",

                // Contextual keywords
                "exports", "module", "open", "opens", "permits",
                "provides", "record", "requires", "sealed", "to",
                "transitive", "uses", "var", "when", "with",
                "yield", "non-sealed"
        };

        private static final String[] LITERALS = {
                "true", "false", "null"
        };

        private static final String[] PRIMITIVES = {
                "byte", "short", "int", "long",
                "float", "double", "char", "boolean", "void"
        };

        private static final String[] JAVA_CLASSES = {
                // java.lang and core types
                "Object", "String", "StringBuilder", "StringBuffer",
                "CharSequence", "Appendable", "Readable", "System",
                "Math", "StrictMath", "Number", "Integer", "Long",
                "Short", "Byte", "Double", "Float", "Boolean",
                "Character", "Void", "Class", "ClassLoader",
                "ClassValue", "Module", "ModuleLayer", "Package",
                "Enum", "Record", "Process", "ProcessBuilder",
                "ProcessHandle", "Runtime", "RuntimePermission",
                "SecurityManager", "Thread", "ThreadGroup",
                "ThreadLocal", "InheritableThreadLocal", "Runnable",
                "StackTraceElement", "Compiler", "Comparable",
                "Cloneable", "AutoCloseable",

                // Exceptions and errors
                "Throwable", "Exception", "RuntimeException", "Error",
                "AssertionError", "ArithmeticException",
                "ArrayIndexOutOfBoundsException", "ArrayStoreException",
                "ClassCastException", "ClassNotFoundException",
                "CloneNotSupportedException", "EnumConstantNotPresentException",
                "IllegalAccessException", "IllegalArgumentException",
                "IllegalCallerException", "IllegalMonitorStateException",
                "IllegalStateException", "IllegalThreadStateException",
                "IndexOutOfBoundsException", "InstantiationException",
                "InterruptedException", "NegativeArraySizeException",
                "NoSuchFieldException", "NoSuchMethodException",
                "NullPointerException", "NumberFormatException",
                "ReflectiveOperationException", "SecurityException",
                "StringIndexOutOfBoundsException", "TypeNotPresentException",
                "UnsupportedOperationException", "AbstractMethodError",
                "BootstrapMethodError", "ClassCircularityError",
                "ClassFormatError", "ExceptionInInitializerError",
                "IllegalAccessError", "IncompatibleClassChangeError",
                "InstantiationError", "InternalError", "LinkageError",
                "NoClassDefFoundError", "NoSuchFieldError",
                "NoSuchMethodError", "OutOfMemoryError",
                "StackOverflowError", "ThreadDeath", "UnknownError",
                "UnsatisfiedLinkError", "UnsupportedClassVersionError",
                "VerifyError", "VirtualMachineError",

                // Numbers, utilities and text
                "BigInteger", "BigDecimal", "RoundingMode",
                "Objects", "Optional", "OptionalInt", "OptionalLong",
                "OptionalDouble", "UUID", "Locale", "Currency",
                "ResourceBundle", "PropertyResourceBundle",
                "Random", "SplittableRandom", "SecureRandom",
                "Scanner", "Formatter", "StringJoiner",
                "StringTokenizer", "Base64", "HexFormat",
                "BitSet", "Date", "Calendar", "GregorianCalendar",
                "Properties", "ServiceLoader", "Timer", "TimerTask",
                "Pattern", "Matcher", "MatchResult",

                // Input/output
                "File", "FileDescriptor", "FilePermission",
                "InputStream", "OutputStream", "Reader", "Writer",
                "BufferedInputStream", "BufferedOutputStream",
                "BufferedReader", "BufferedWriter",
                "ByteArrayInputStream", "ByteArrayOutputStream",
                "CharArrayReader", "CharArrayWriter",
                "DataInputStream", "DataOutputStream",
                "FileInputStream", "FileOutputStream",
                "FileReader", "FileWriter",
                "FilterInputStream", "FilterOutputStream",
                "InputStreamReader", "OutputStreamWriter",
                "ObjectInputStream", "ObjectOutputStream",
                "PipedInputStream", "PipedOutputStream",
                "PrintStream", "PrintWriter", "PushbackReader",
                "RandomAccessFile", "SequenceInputStream",
                "Serializable", "Externalizable", "Closeable",
                "Flushable", "Console", "IOException",
                "EOFException", "FileNotFoundException",
                "InterruptedIOException", "NotSerializableException",
                "ObjectStreamException", "UncheckedIOException",

                // NIO
                "Path", "Paths", "Files", "FileSystem", "FileSystems",
                "FileStore", "WatchService", "WatchKey", "WatchEvent",
                "StandardWatchEventKinds", "StandardOpenOption",
                "StandardCopyOption", "LinkOption",
                "ByteBuffer", "CharBuffer", "IntBuffer", "LongBuffer",
                "FloatBuffer", "DoubleBuffer", "ShortBuffer",
                "MappedByteBuffer", "ByteOrder",
                "Charset", "CharsetDecoder", "CharsetEncoder",
                "StandardCharsets", "FileChannel", "SocketChannel",
                "ServerSocketChannel", "DatagramChannel",
                "AsynchronousFileChannel", "AsynchronousSocketChannel",
                "Selector", "SelectionKey",

                // Date and time
                "Instant", "Duration", "Period", "Clock",
                "LocalDate", "LocalTime", "LocalDateTime",
                "OffsetTime", "OffsetDateTime", "ZonedDateTime",
                "ZoneId", "ZoneOffset", "ZoneRules",
                "Year", "YearMonth", "MonthDay", "Month", "DayOfWeek",
                "DateTimeFormatter", "DateTimeFormatterBuilder",
                "DateTimeException", "Temporal", "TemporalAccessor",
                "TemporalAdjuster", "TemporalAdjusters",
                "ChronoUnit", "ChronoField",

                // Streams and functional programming
                "Stream", "BaseStream", "IntStream", "LongStream",
                "DoubleStream", "StreamSupport", "Collector", "Collectors",
                "Predicate", "BiPredicate", "Function", "BiFunction",
                "Consumer", "BiConsumer", "Supplier",
                "UnaryOperator", "BinaryOperator",
                "IntPredicate", "LongPredicate", "DoublePredicate",
                "IntFunction", "LongFunction", "DoubleFunction",
                "IntConsumer", "LongConsumer", "DoubleConsumer",
                "IntSupplier", "LongSupplier", "DoubleSupplier",

                // Concurrency
                "Callable", "Executor", "ExecutorService",
                "ScheduledExecutorService", "Executors",
                "Future", "FutureTask", "CompletableFuture",
                "CompletionStage", "CompletionService",
                "ExecutorCompletionService", "ForkJoinPool",
                "ForkJoinTask", "RecursiveTask", "RecursiveAction",
                "CountDownLatch", "CyclicBarrier", "Semaphore",
                "Phaser", "Exchanger", "TimeUnit",
                "ThreadFactory", "ThreadPoolExecutor",
                "ScheduledThreadPoolExecutor", "RejectedExecutionHandler",
                "ReentrantLock", "ReadWriteLock",
                "ReentrantReadWriteLock", "StampedLock",
                "Condition", "LockSupport",
                "AtomicBoolean", "AtomicInteger", "AtomicLong",
                "AtomicReference", "AtomicIntegerArray",
                "AtomicLongArray", "AtomicReferenceArray",
                "LongAdder", "DoubleAdder", "LongAccumulator",
                "Flow", "SubmissionPublisher", "ScopedValue",
                "StructuredTaskScope",

                // Networking and HTTP
                "URI", "URL", "URLConnection", "HttpURLConnection",
                "InetAddress", "Inet4Address", "Inet6Address",
                "InetSocketAddress", "SocketAddress",
                "Socket", "ServerSocket", "DatagramSocket",
                "DatagramPacket", "NetworkInterface",
                "Proxy", "CookieManager", "CookieHandler",
                "Authenticator", "PasswordAuthentication",
                "HttpClient", "HttpRequest", "HttpResponse",
                "WebSocket",

                // Reflection
                "AccessibleObject", "AnnotatedElement", "Constructor",
                "Field", "Method", "Modifier", "Parameter",
                "RecordComponent", "InvocationHandler",
                "ParameterizedType", "GenericArrayType",
                "Type", "TypeVariable", "WildcardType",

                // JDBC
                "Driver", "DriverManager", "DataSource", "Connection",
                "Statement", "PreparedStatement", "CallableStatement",
                "ResultSet", "ResultSetMetaData", "DatabaseMetaData",
                "ParameterMetaData", "Savepoint", "RowId",
                "Blob", "Clob", "NClob", "SQLXML",
                "SQLException", "SQLWarning", "BatchUpdateException",
                "Timestamp", "Time",

                // XML
                "Document", "Element", "Node", "NodeList", "Attr",
                "DocumentBuilder", "DocumentBuilderFactory",
                "SAXParser", "SAXParserFactory",
                "Transformer", "TransformerFactory",
                "XPath", "XPathFactory",

                // Security and cryptography
                "MessageDigest", "SecureRandom", "KeyStore",
                "KeyPair", "KeyPairGenerator", "PublicKey",
                "PrivateKey", "Signature", "Certificate",
                "Cipher", "SecretKey", "SecretKeyFactory",

                // Spring and Spring Boot
                "SpringApplication", "SpringApplicationBuilder",
                "ApplicationContext", "ConfigurableApplicationContext",
                "BeanFactory", "Environment", "Resource",
                "ResponseEntity", "HttpHeaders", "HttpStatus",
                "HttpMethod", "MediaType", "RestTemplate",
                "RestClient", "WebClient", "JdbcTemplate",
                "NamedParameterJdbcTemplate", "TransactionTemplate",
                "Model", "ModelMap", "ModelAndView", "BindingResult",
                "MultipartFile", "Page", "Pageable", "PageRequest",
                "Sort", "CrudRepository", "ListCrudRepository",
                "PagingAndSortingRepository", "JpaRepository",
                "Specification", "ApplicationEvent",
                "ApplicationEventPublisher",

                // Jakarta EE, JPA and Hibernate
                "Servlet", "HttpServlet", "HttpServletRequest",
                "HttpServletResponse", "HttpSession", "ServletContext",
                "ServletConfig", "Filter", "FilterChain",
                "AsyncContext", "RequestDispatcher",
                "Response", "ResponseBuilder", "EntityManager",
                "EntityManagerFactory", "EntityTransaction",
                "TypedQuery", "CriteriaBuilder", "CriteriaQuery",
                "Validator", "ValidatorFactory", "ConstraintViolation",
                "Session", "SessionFactory", "Transaction",

                // JSON and serialization
                "ObjectMapper", "JsonNode", "ObjectNode", "ArrayNode",
                "JsonParser", "JsonGenerator", "TypeReference",
                "Gson", "GsonBuilder", "JsonElement", "JsonObject",
                "JsonArray", "JsonPrimitive",

                // Logging
                "Logger", "LoggerFactory", "LogManager",
                "Level", "Marker", "MDC",

                // Testing
                "Assertions", "Assumptions", "Assert", "Mockito",
                "ArgumentCaptor", "MockedStatic", "MockMvc",
                "WebTestClient", "TestInfo", "TestReporter",
                "GenericContainer", "PostgreSQLContainer",
                "MySQLContainer", "DockerImageName",

                // Reactive, messaging and cloud
                "Mono", "Flux", "Scheduler", "Schedulers",
                "Observable", "Flowable", "Single", "Maybe",
                "KafkaTemplate", "KafkaListenerContainerFactory",
                "RabbitTemplate", "MeterRegistry", "Counter",
                "Gauge", "DistributionSummary",

                // Common third-party utilities
                "StringUtils", "ObjectUtils", "ArrayUtils",
                "NumberUtils", "BooleanUtils", "IOUtils",
                "FileUtils", "CollectionUtils", "Validate",
                "Preconditions", "MoreObjects", "Stopwatch",
                "Mappers",

                // JavaFX
                "Application", "Stage", "Scene", "Parent",
                "Button", "Label", "TextField", "TextArea",
                "TableView", "ListView", "TreeView",
                "BorderPane", "VBox", "HBox",
                "FXMLLoader", "ObservableList",

                // Android
                "Activity", "Fragment", "Intent", "Context",
                "Bundle", "View", "ViewGroup", "TextView",
                "EditText", "RecyclerView", "ViewModel",
                "LiveData", "MutableLiveData"
        };

        private static final String[] COLLECTIONS = {
                // Core collection interfaces and implementations
                "Collection", "AbstractCollection",
                "List", "AbstractList", "AbstractSequentialList",
                "ArrayList", "LinkedList", "Vector", "Stack",
                "Set", "AbstractSet", "HashSet", "LinkedHashSet",
                "SortedSet", "NavigableSet", "TreeSet", "EnumSet",
                "Queue", "AbstractQueue", "Deque", "ArrayDeque",
                "PriorityQueue",
                "Map", "Entry", "AbstractMap", "HashMap",
                "LinkedHashMap", "SortedMap", "NavigableMap",
                "TreeMap", "EnumMap", "WeakHashMap",
                "IdentityHashMap", "Hashtable", "Dictionary",

                // Sequenced collections
                "SequencedCollection", "SequencedSet", "SequencedMap",

                // Concurrent collections
                "ConcurrentMap", "ConcurrentNavigableMap",
                "ConcurrentHashMap", "ConcurrentSkipListMap",
                "ConcurrentSkipListSet", "ConcurrentLinkedQueue",
                "ConcurrentLinkedDeque", "CopyOnWriteArrayList",
                "CopyOnWriteArraySet", "BlockingQueue",
                "BlockingDeque", "TransferQueue",
                "ArrayBlockingQueue", "LinkedBlockingQueue",
                "LinkedBlockingDeque", "LinkedTransferQueue",
                "PriorityBlockingQueue", "DelayQueue",
                "SynchronousQueue",

                // Traversal and helper types
                "Iterable", "Iterator", "ListIterator",
                "Spliterator", "Spliterators", "Enumeration",
                "RandomAccess", "Comparator", "Comparable",
                "Collections", "Arrays",

                // Guava collections
                "Multimap", "ListMultimap", "SetMultimap",
                "Multiset", "BiMap", "Table", "Range",
                "RangeSet", "RangeMap",
                "ImmutableCollection", "ImmutableList",
                "ImmutableSet", "ImmutableMap", "ImmutableMultimap",
                "ImmutableTable", "ImmutableBiMap",
                "HashMultimap", "ArrayListMultimap",
                "LinkedHashMultimap", "TreeMultimap",
                "HashMultiset", "TreeMultiset"
        };

        private static final String[] ANNOTATIONS = {
                // Java
                "Override", "Deprecated", "SuppressWarnings",
                "FunctionalInterface", "SafeVarargs", "Retention",
                "Target", "Documented", "Inherited", "Repeatable",
                "Native", "Serial", "Generated",
                "SupportedAnnotationTypes", "SupportedOptions",
                "SupportedSourceVersion",

                // Jakarta annotations, CDI and security
                "Inject", "Named", "Singleton", "Resource", "Resources",
                "PostConstruct", "PreDestroy", "Priority",
                "ManagedBean", "RolesAllowed", "PermitAll", "DenyAll",
                "DeclareRoles", "RunAs",
                "ApplicationScoped", "RequestScoped", "SessionScoped",
                "ConversationScoped", "Dependent",
                "Produces", "Disposes", "Alternative", "Specializes",
                "Vetoed", "Observes", "ObservesAsync",
                "Interceptor", "AroundInvoke", "AroundConstruct",
                "Decorator", "Delegate",

                // JPA
                "Entity", "Table", "Id", "IdClass", "EmbeddedId",
                "GeneratedValue", "SequenceGenerator", "TableGenerator",
                "Column", "Basic", "Version", "Enumerated", "Temporal",
                "Lob", "Convert", "Converts", "Converter",
                "AttributeOverride", "AttributeOverrides",
                "AssociationOverride", "AssociationOverrides",
                "Embedded", "Embeddable", "MappedSuperclass",
                "Inheritance", "DiscriminatorColumn",
                "DiscriminatorValue", "PrimaryKeyJoinColumn",
                "PrimaryKeyJoinColumns", "SecondaryTable",
                "SecondaryTables", "OneToOne", "OneToMany",
                "ManyToOne", "ManyToMany", "JoinColumn",
                "JoinColumns", "JoinTable", "MapKey",
                "MapKeyColumn", "MapKeyEnumerated", "MapKeyTemporal",
                "OrderBy", "OrderColumn", "ElementCollection",
                "CollectionTable", "NamedQuery", "NamedQueries",
                "NamedNativeQuery", "NamedNativeQueries",
                "NamedStoredProcedureQuery", "NamedStoredProcedureQueries",
                "SqlResultSetMapping", "SqlResultSetMappings",
                "ConstructorResult", "ColumnResult", "EntityResult",
                "FieldResult", "Cacheable", "EntityListeners",
                "ExcludeDefaultListeners", "ExcludeSuperclassListeners",
                "PrePersist", "PostPersist", "PreUpdate", "PostUpdate",
                "PreRemove", "PostRemove", "PostLoad",
                "PersistenceContext", "PersistenceUnit", "Access",
                "MapsId",

                // Jakarta Validation
                "Valid", "Constraint", "GroupSequence",
                "ConvertGroup", "ReportAsSingleViolation",
                "AssertTrue", "AssertFalse", "DecimalMax", "DecimalMin",
                "Digits", "Email", "Future", "FutureOrPresent",
                "Max", "Min", "Negative", "NegativeOrZero",
                "NotBlank", "NotEmpty", "NotNull", "Null",
                "Past", "PastOrPresent", "Pattern",
                "Positive", "PositiveOrZero", "Size",

                // Servlet and Jakarta REST
                "WebServlet", "WebFilter", "WebListener",
                "MultipartConfig", "ServletSecurity",
                "HttpConstraint", "HttpMethodConstraint", "HandlesTypes",
                "ApplicationPath", "Path", "GET", "POST", "PUT",
                "PATCH", "DELETE", "HEAD", "OPTIONS",
                "Produces", "Consumes", "PathParam", "QueryParam",
                "FormParam", "HeaderParam", "CookieParam",
                "MatrixParam", "BeanParam", "DefaultValue",
                "Provider", "NameBinding", "HttpMethod",
                "Suspended",

                // Spring and Spring Boot
                "SpringBootApplication", "EnableAutoConfiguration",
                "Configuration", "Bean", "ComponentScan",
                "Import", "ImportResource", "PropertySource",
                "Profile", "Conditional",
                "Component", "Service", "Repository",
                "Controller", "RestController",
                "ControllerAdvice", "RestControllerAdvice",
                "ConfigurationProperties", "EnableConfigurationProperties",
                "Autowired", "Qualifier", "Primary", "Lazy",
                "Value", "Scope", "Lookup",
                "RequestMapping", "GetMapping", "PostMapping",
                "PutMapping", "PatchMapping", "DeleteMapping",
                "RequestBody", "ResponseBody", "ResponseStatus",
                "PathVariable", "RequestParam", "RequestHeader",
                "CookieValue", "ModelAttribute", "SessionAttribute",
                "RequestAttribute", "CrossOrigin",
                "ExceptionHandler", "InitBinder",
                "Validated", "Transactional",
                "Async", "EnableAsync", "Scheduled", "Schedules",
                "EnableScheduling", "Cacheable", "CachePut",
                "CacheEvict", "Caching", "EnableCaching",
                "EventListener", "EnableWebMvc", "EnableWebFlux",
                "EnableJpaRepositories", "EntityScan",
                "EnableTransactionManagement",
                "SpringBootTest", "WebMvcTest", "WebFluxTest",
                "DataJpaTest", "JdbcTest", "JsonTest",
                "RestClientTest", "AutoConfigureMockMvc",
                "MockBean", "SpyBean", "MockitoBean", "MockitoSpyBean",
                "ActiveProfiles", "ContextConfiguration",
                "TestPropertySource", "DirtiesContext",
                "Sql", "Rollback", "Commit",

                // JUnit
                "Test", "BeforeEach", "AfterEach",
                "BeforeAll", "AfterAll", "DisplayName",
                "DisplayNameGeneration", "Disabled", "Nested",
                "Tag", "Tags", "Timeout", "RepeatedTest",
                "ParameterizedTest", "ValueSource", "NullSource",
                "EmptySource", "NullAndEmptySource",
                "CsvSource", "CsvFileSource", "MethodSource",
                "EnumSource", "ArgumentsSource", "TestFactory",
                "TestTemplate", "ExtendWith", "RegisterExtension",
                "TempDir", "Order", "TestMethodOrder",
                "TestClassOrder", "TestInstance",

                // TestNG and Mockito
                "BeforeSuite", "AfterSuite", "BeforeTest", "AfterTest",
                "BeforeClass", "AfterClass", "BeforeMethod", "AfterMethod",
                "BeforeGroups", "AfterGroups", "DataProvider",
                "Factory", "Listeners", "Parameters",
                "Mock", "Spy", "InjectMocks", "Captor",
                "MockitoSettings",

                // Jackson, Gson and JAXB
                "JsonProperty", "JsonIgnore", "JsonIgnoreProperties",
                "JsonInclude", "JsonFormat", "JsonCreator",
                "JsonValue", "JsonAlias", "JsonGetter", "JsonSetter",
                "JsonAnyGetter", "JsonAnySetter",
                "JsonTypeInfo", "JsonSubTypes", "JsonTypeName",
                "JsonIdentityInfo", "JsonDeserialize", "JsonSerialize",
                "SerializedName", "Expose", "JsonAdapter",
                "XmlRootElement", "XmlElement", "XmlElements",
                "XmlAttribute", "XmlAccessorType", "XmlAccessorOrder",
                "XmlType", "XmlTransient", "XmlElementWrapper",
                "XmlJavaTypeAdapter", "XmlJavaTypeAdapters",
                "XmlEnum", "XmlEnumValue", "XmlID", "XmlIDREF",

                // Lombok
                "Getter", "Setter", "Data", "Builder", "SuperBuilder",
                "NoArgsConstructor", "RequiredArgsConstructor",
                "AllArgsConstructor", "EqualsAndHashCode", "ToString",
                "With", "SneakyThrows", "Synchronized", "Cleanup",
                "Slf4j", "Log", "Log4j", "Log4j2",
                "UtilityClass", "FieldDefaults", "Accessors",

                // Hibernate
                "CreationTimestamp", "UpdateTimestamp",
                "Formula", "JdbcTypeCode", "UuidGenerator",
                "NaturalId", "NaturalIdCache", "BatchSize",
                "Fetch", "FetchProfile", "Filter", "FilterDef",
                "SQLDelete", "SQLInsert", "SQLUpdate",
                "SoftDelete", "DynamicInsert", "DynamicUpdate",
                "Immutable", "OnDelete", "ColumnDefault",

                // MicroProfile, Quarkus and Micronaut
                "ConfigProperty", "ConfigMapping",
                "RegisterRestClient", "RestClient",
                "QuarkusMain", "QuarkusTest",
                "RegisterForReflection", "ReactiveTransactional",
                "ConsumeEvent", "MicronautTest", "Introspected",
                "Requires", "EachBean", "EachProperty",
                "ConfigurationReader",

                // MapStruct and dependency injection
                "Mapper", "Mapping", "Mappings", "BeanMapping",
                "IterableMapping", "MapMapping",
                "InheritConfiguration", "InheritInverseConfiguration",
                "MappingTarget", "ObjectFactory",
                "BeforeMapping", "AfterMapping",
                "ValueMapping", "ValueMappings", "EnumMapping",
                "Module", "Provides", "Binds",
                "BindsInstance", "Subcomponent",

                // OpenAPI and Swagger
                "Operation", "ApiResponse", "ApiResponses",
                "Parameter", "Parameters", "Schema",
                "Tag", "SecurityRequirement", "SecurityScheme",
                "OpenAPIDefinition", "Hidden", "RequestBody",

                // Retrofit
                "HTTP", "Streaming", "Multipart", "FormUrlEncoded",
                "Body", "Field", "FieldMap", "Part", "PartMap",
                "Query", "QueryMap", "Header", "HeaderMap", "Url",

                // JMH
                "Benchmark", "BenchmarkMode", "OutputTimeUnit",
                "State", "Setup", "TearDown", "Param",
                "Fork", "Warmup", "Measurement",
                "Threads", "Group", "GroupThreads",

                // Android
                "SuppressLint", "RequiresApi", "Keep",
                "WorkerThread", "MainThread", "UiThread",
                "Nullable", "NonNull"
        };

        private static final Pattern KEYWORD_PATTERN = buildPattern(KEYWORDS);
        private static final Pattern PRIMITIVE_PATTERN = buildPattern(PRIMITIVES);
        private static final Pattern LITERAL_PATTERN = buildPattern(LITERALS);
        private static final Pattern CLASS_PATTERN = buildPattern(concat(JAVA_CLASSES, COLLECTIONS));

        private static Pattern buildPattern(String[] words) {
            return Pattern.compile("\\b(" + String.join("|", words) + ")\\b");
        }

        private static String[] concat(String[] a, String[] b) {
            String[] result = new String[a.length + b.length];
            System.arraycopy(a, 0, result, 0, a.length);
            System.arraycopy(b, 0, result, a.length, b.length);
            return result;
        }

        // Styles are cached per-JTextPane (via client property flag) instead of
        // being re-added to the StyledDocument on every highlight pass.
        private static final String STYLES_CACHED_KEY = "nn.stylesCached";

        static void highlightSyntax(JTextPane textPane, String text) {
            StyledDocument doc = textPane.getStyledDocument();

            Style defaultStyle = doc.getStyle(StyleContext.DEFAULT_STYLE);
            if (defaultStyle == null)
                defaultStyle = StyleContext.getDefaultStyleContext().getStyle(StyleContext.DEFAULT_STYLE);

            if (doc.getLength() < 60000)
                doc.setCharacterAttributes(0, doc.getLength(), defaultStyle, true);

            Style keywordStyle, literalStyle, primitiveStyle, stringStyle,
                    commentStyle, numberStyle, classStyle, annotationStyle;

            if (Boolean.TRUE.equals(textPane.getClientProperty(STYLES_CACHED_KEY))) {
                keywordStyle = doc.getStyle("keyword");
                literalStyle = doc.getStyle("literal");
                primitiveStyle = doc.getStyle("primitive");
                stringStyle = doc.getStyle("string");
                commentStyle = doc.getStyle("comment");
                numberStyle = doc.getStyle("number");
                classStyle = doc.getStyle("class");
                annotationStyle = doc.getStyle("annotation");
            } else {
                Color keywordColor = new Color(189, 147, 249);
                Color literalColor = new Color(255, 121, 198);
                Color primitiveColor = new Color(139, 233, 253);
                Color stringColor = new Color(241, 250, 140);
                Color commentColor = new Color(98, 114, 164);
                Color numberColor = new Color(255, 184, 108);
                Color classColor = new Color(80, 250, 123);
                Color annotationColor = new Color(255, 184, 108);

                keywordStyle = createStyle(doc, "keyword", defaultStyle, keywordColor, true);
                literalStyle = createStyle(doc, "literal", defaultStyle, literalColor, false);
                primitiveStyle = createStyle(doc, "primitive", defaultStyle, primitiveColor, true);
                stringStyle = createStyle(doc, "string", defaultStyle, stringColor, false);
                commentStyle = createStyle(doc, "comment", defaultStyle, commentColor, true);
                numberStyle = createStyle(doc, "number", defaultStyle, numberColor, false);
                classStyle = createStyle(doc, "class", defaultStyle, classColor, false);
                annotationStyle = createStyle(doc, "annotation", defaultStyle, annotationColor, true);

                textPane.putClientProperty(STYLES_CACHED_KEY, Boolean.TRUE);
            }

            highlightPattern(doc, text, COMMENT_PATTERN, commentStyle);
            highlightPattern(doc, text, STRING_PATTERN, stringStyle);
            highlightPattern(doc, text, CHAR_PATTERN, stringStyle);
            highlightPattern(doc, text, NUMBER_PATTERN, numberStyle);
            highlightPattern(doc, text, ANNOTATION_PATTERN, annotationStyle);
            highlightPattern(doc, text, KEYWORD_PATTERN, keywordStyle);
            highlightPattern(doc, text, PRIMITIVE_PATTERN, primitiveStyle);
            highlightPattern(doc, text, LITERAL_PATTERN, literalStyle);
            highlightPattern(doc, text, CLASS_PATTERN, classStyle);
        }

        private static Style createStyle(StyledDocument doc, String name, Style parent, Color color, boolean bold) {
            Style style = doc.addStyle(name, parent);
            StyleConstants.setForeground(style, color);
            if (bold)
                StyleConstants.setBold(style, true);
            return style;
        }

        private static void highlightPattern(StyledDocument doc, String text, Pattern pattern, Style style) {
            try {
                Matcher matcher = pattern.matcher(text);
                while (matcher.find()) {
                    doc.setCharacterAttributes(matcher.start(), matcher.end() - matcher.start(), style, false);
                }
            } catch (Exception ignored) {
            }
        }
    }

    // ———————————————————————————————— MAIN ————————————————————————————————

    public static void main(String[] args) {
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        } catch (Exception ignored) {
        }
        SwingUtilities.invokeLater(Notepad::new);
    }
}