CustomNPC-Plus/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java

package noppes.npcs.client.gui.util;

import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.util.ChatAllowedCharacters;
import noppes.npcs.NoppesStringUtils;
import noppes.npcs.client.ClientProxy;
import noppes.npcs.client.gui.util.script.*;
import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;

import static net.minecraft.client.gui.GuiScreen.isCtrlKeyDown;

/**
 * Script text editor component with syntax highlighting, bracket matching,
 * smooth scrolling, and IDE-like features.
 * 
 * Helper classes used:
 * - BracketMatcher: bracket matching and brace span computation
 * - IndentHelper: indentation utilities and text formatting
 * - CommentHandler: line comment toggling
 * - CursorNavigation: cursor movement logic
 */
public class GuiScriptTextArea extends GuiNpcTextField {
    
    // ==================== DIMENSIONS & POSITION ====================
    public int id;
    public int x;
    public int y;
    public int width;
    public int height;
    
    // ==================== STATE FLAGS ====================
    public boolean active = false;
    public boolean enabled = true;
    public boolean visible = true;
    public boolean clicked = false;
    public boolean doubleClicked = false;
    public boolean tripleClicked = false;
    public boolean clickScrolling = false;
    private int clickCount = 0;
    private long lastClicked = 0L;
    
    // ==================== TEXT & CONTAINER ====================
    public String text = null;
    private JavaTextContainer container = null;
    private boolean enableCodeHighlighting = false;
    
    // ==================== SELECTION STATE ====================
    private int startSelection;
    private int endSelection;
    private int cursorPosition;
    
    // ==================== SCROLL STATE ====================
    private int scrolledLine = 0;
    private double scrollPos = 0.0;
    private double targetScroll = 0.0;
    private double scrollVelocity = 0.0;
    private long lastScrollTime = 0L;
    private int scrollbarDragOffset = 0;
    
    // Scroll animation constants
    private static final double SCROLL_TAU = 0.1;        // Time constant (~55ms)
    private static final double SCROLL_SNAP = 0.01;       // Snap threshold
    private static final double SCROLL_MAX_DT = 0.05;     // Max delta time
    
    // ==================== UI COMPONENTS ====================
    private int cursorCounter;
    private long lastInputTime = 0L;
    private ITextChangeListener listener;
    private static int LINE_NUMBER_GUTTER_WIDTH = 25;
    
    // ==================== UNDO/REDO ====================
    public List<UndoData> undoList = new ArrayList<>();
    public List<UndoData> redoList = new ArrayList<>();
    public boolean undoing = false;
    
    // ==================== CONSTRUCTOR ====================

    public GuiScriptTextArea(GuiScreen guiScreen, int id, int x, int y, int width, int height, String text) {
        super(id, guiScreen, x, y, width, height, null);
        this.id = id;
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        this.undoing = true;
        this.setText(text);
        this.undoing = false;
    }
    
    // ==================== RENDERING ====================

    public void drawTextBox(int xMouse, int yMouse) {
        if (!visible)
            return;
        clampSelectionBounds();
        
        // Dynamically calculate gutter width based on line count digits
        if (container != null && container.linesCount > 0) {
            int maxLineNum = container.linesCount;
            String maxLineStr = String.valueOf(maxLineNum);
            int digitWidth = ClientProxy.Font.width(maxLineStr);
            LINE_NUMBER_GUTTER_WIDTH = digitWidth + 10; // 10px total padding (5px left + 5px right)
        }
        // Draw outer border around entire area
        drawRect(x - 1, y - 1, x + width + 1, y + height + 1, 0xffa0a0a0);
        // Draw line number gutter background
        drawRect(x, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff000000);
        // Draw text viewport background (starts after gutter)
        drawRect(x + LINE_NUMBER_GUTTER_WIDTH, y, x + width, y + height, 0xff000000);
        // Draw separator line between gutter and text area
        drawRect(x + LINE_NUMBER_GUTTER_WIDTH-1, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff3c3f41);

        // Enable scissor test to clip drawing to the TEXT viewport rectangle (excludes gutter)
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        Minecraft mc = Minecraft.getMinecraft();
        ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
        int scaleFactor = sr.getScaleFactor();
        int scissorX = (this.x ) * scaleFactor;
        int scissorY = (sr.getScaledHeight() - (this.y + this.height)) * scaleFactor;
        int scissorW = (this.width ) * scaleFactor;
        int scissorH = this.height * scaleFactor;
        GL11.glScissor(scissorX, scissorY, scissorW, scissorH);
        
        container.visibleLines = height / container.lineHeight-1;

        int maxScroll = Math.max(0, this.container.linesCount - container.visibleLines);
        if (listener instanceof GuiNPCInterface) {
            int k2 = ((GuiNPCInterface) listener).mouseScroll = Mouse.getDWheel();
            if (k2 != 0) {
                // update target scroll smoothly instead of jumping
                double sign = Math.copySign(1, k2);
                targetScroll -= sign * 2.0; // one line per wheel tick
                if (targetScroll < 0) targetScroll = 0;
                if (targetScroll > maxScroll) targetScroll = maxScroll;
            }
        }

        if (clickScrolling) {
            // keep dragging while mouse button is down
            clickScrolling = Mouse.isButtonDown(0);
            int diff = Math.max(0, container.linesCount - container.visibleLines);
            if (diff > 0) {
                int sbSize = Math.max((int) (1f * container.visibleLines / container.linesCount * height), 2);
                int trackTop = y + 1;
                int trackHeight = Math.max(1, height - 4);
                int thumbRange = Math.max(1, trackHeight - sbSize);

                // current thumb top for hit testing
                double linesCountD = Math.max(1, (double) container.linesCount);
                int thumbTop = (int) (y + 1f * scrollPos / linesCountD * (height - 4)) + 1;

                // If user clicked on the track (outside the thumb), jump to proportional position
                if (yMouse < thumbTop || yMouse > thumbTop + sbSize) {
                    double centerRatio = (double) (yMouse - trackTop) / (double) trackHeight;
                    centerRatio = Math.max(0.0, Math.min(1.0, centerRatio));
                    targetScroll = Math.max(0, Math.min(diff, centerRatio * diff));
                    // prepare drag offset for subsequent drags (center grab)
                    scrollbarDragOffset = sbSize / 2;
                } else {
                    // Dragging the thumb itself: preserve initial grab offset
                    int desiredTop = yMouse - scrollbarDragOffset;
                    desiredTop = Math.max(trackTop, Math.min(trackTop + thumbRange, desiredTop));
                    double ratio = (double) (desiredTop - trackTop) / (double) thumbRange;
                    ratio = Math.max(0.0, Math.min(1.0, ratio));
                    targetScroll = Math.max(0, Math.min(diff, ratio * diff));
                }
            }
            if (!clickScrolling) {
                // reset drag offset when released
                scrollbarDragOffset = 0;
            }
        }

        // Animate scrollPos towards targetScroll using exponential smoothing
        long nowMs = System.currentTimeMillis();
        if (scrollPos < 0) {
            scrollPos = scrolledLine; // initialize
            lastScrollTime = nowMs;
        }
        double dt = Math.min(0.05, (nowMs - lastScrollTime) / 1000.0); // clamp dt for stability
        lastScrollTime = nowMs;

        double dist = targetScroll - scrollPos;
        // If close enough, snap to target to avoid long slow tail
        if (Math.abs(dist) < 0.01) {
            scrollPos = targetScroll;
            scrollVelocity = 0.0;
        } else {
            // Time constant controlling speed (seconds). Smaller -> faster snap.
            final double tau = 0.1; // ~55ms time constant feels snappy
            double alpha = 1.0 - Math.exp(-dt / Math.max(1e-6, tau));
            double prev = scrollPos;
            scrollPos += dist * alpha;
            scrollVelocity = (scrollPos - prev) / (dt > 0 ? dt : 1e-6);
            // Clamp overshoot
            if ((dist > 0 && scrollPos > targetScroll) || (dist < 0 && scrollPos < targetScroll)) {
                scrollPos = targetScroll;
                scrollVelocity = 0.0;
            }
        }
        // Ensure scrollPos stays in valid bounds
        if (scrollPos < 0) scrollPos = 0;
        if (scrollPos > maxScroll) scrollPos = maxScroll;
        
        // Update integer scrolledLine for compatibility
        scrolledLine = Math.max(0, Math.min((int) Math.floor(scrollPos), maxScroll));


        if (clicked) {
            clicked = Mouse.isButtonDown(0);
            int i = getSelectionPos(xMouse, yMouse);
            if (i != cursorPosition) {
                if (doubleClicked || tripleClicked) {
                    startSelection = endSelection = cursorPosition;
                    doubleClicked = false;
                    tripleClicked = false;
                }
                setCursor(i, true);
            }
        } else if (doubleClicked || tripleClicked) {
            doubleClicked = false;
            tripleClicked = false;
        }

        //Calculate braces next to cursor to highlight
        int startBracket = 0, endBracket = 0;
        if (startSelection >= 0 && text != null && text.length() > 0 &&
                (endSelection - startSelection == 1 || startSelection == endSelection)) {
            int[] span = findBracketSpanAt(startSelection);
            if (span != null) {
                startBracket = span[0];
                endBracket = span[1];
            }
        }

        List<JavaTextContainer.LineData> list = new ArrayList<>(container.lines);

        // Build brace spans: {origDepth, open line, close line, adjustedDepth}
        List<int[]> braceSpans = computeBraceSpans(text, list);

        // Determine which exact brace span (openLine/closeLine) should be highlighted based on bracket under caret
        int highlightedOpenLine = -1;
        int highlightedCloseLine = -1;
        if (startBracket != endBracket && startBracket >= 0) {
            int bracketLineIdx = -1;
            for (int li = 0; li < list.size(); li++) {
                LineData ld = list.get(li);
                if (startBracket >= ld.start && startBracket < ld.end) {
                    bracketLineIdx = li;
                    break;
                }
            }
            if (bracketLineIdx >= 0) {
                for (int[] span : braceSpans) {
                    int openLine = span[1];
                    int closeLine = span[2];
                    if (bracketLineIdx >= openLine && bracketLineIdx <= closeLine) {
                        highlightedOpenLine = openLine;
                        highlightedCloseLine = closeLine;
                        break;
                    }
                }
            }
        }

        String wordHightLight = null;
        if (startSelection != endSelection) {
            Matcher m = container.regexWord.matcher(text);
            while (m.find()) {
                if (m.start() == startSelection && m.end() == endSelection) {
                    wordHightLight = text.substring(startSelection, endSelection);
                }
            }
        }
        // Expand render range by one line above/below so partially-visible lines are drawn
        int renderStart = Math.max(0, scrolledLine - 1);
        int renderEnd = Math.min(list.size() - 1, scrolledLine + container.visibleLines + 1);

        // Apply fractional GL translate for sub-pixel smooth scrolling
        double fracOffset = scrollPos - scrolledLine;
        float fracPixels = (float) (fracOffset * container.lineHeight);
        GL11.glPushMatrix();
        GL11.glTranslatef(0.0f, -fracPixels, 0.0f);

        // Render line numbers in the gutter (outside scissor region, so pop first)
        GL11.glPopMatrix();
       // GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPushMatrix();
        GL11.glTranslatef(0.0f, -fracPixels, 0.0f);
        
        int stringYOffset = 2;

        // Render LINE GUTTER numbers
        for (int i = renderStart; i <= renderEnd; i++) {
            int posY = y + (i - scrolledLine) * container.lineHeight + stringYOffset;
            String lineNum = String.valueOf(i + 1);
            int lineNumWidth = ClientProxy.Font.width(lineNum);
            int lineNumX = x + LINE_NUMBER_GUTTER_WIDTH - lineNumWidth - 5; // right-align with 5px padding
            int lineNumY = posY + 1;
            // Highlight current line number
            int lineNumColor = 0xFF606366;
            if (active && isEnabled()) {
                for (int li = 0; li < list.size(); li++) {
                    LineData ld = list.get(li);
                    if (cursorPosition >= ld.start && cursorPosition < ld.end || (li == list.size() - 1 && cursorPosition == text.length())) {
                        if (li == i) {
                            lineNumColor = 0xFFb9c7d6;
                            break;
                        }
                    }
                }
            }
            ClientProxy.Font.drawString(lineNum, lineNumX, lineNumY, lineNumColor);
        }
        GL11.glPopMatrix();
        // Re-enable scissor for text area and push matrix again
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        GL11.glPushMatrix();
        GL11.glTranslatef(0.0f, -fracPixels, 0.0f);

        renderStart = Math.max(0, scrolledLine - 1);
        for (int i = renderStart; i <= renderEnd; i++) {
            LineData data = list.get(i);
            String line = data.text;
            int w = line.length();
            // Use integer Y relative to scrolledLine; fractional offset applied via GL translate
            int posY = y + (i - scrolledLine) * container.lineHeight;
            if (i >= renderStart && i <= renderEnd) {
                //Highlight braces the cursor position is on
                if (startBracket != endBracket) {
                    if (startBracket >= data.start && startBracket < data.end) {
                        int s = ClientProxy.Font.width(line.substring(0, startBracket - data.start));
                        int e = ClientProxy.Font.width(line.substring(0, startBracket - data.start + 1)) + 1;
                        drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight + 0, 0x9900cc00);
                    }
                    if (endBracket >= data.start && endBracket < data.end) {
                        int s = ClientProxy.Font.width(line.substring(0, endBracket - data.start));
                        int e = ClientProxy.Font.width(line.substring(0, endBracket - data.start + 1)) + 1;
                        drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight + 0, 0x9900cc00);
                    }
                }
                //Highlight words
                if (wordHightLight != null) {
                    Matcher m = container.regexWord.matcher(line);
                    while (m.find()) {
                        if (line.substring(m.start(), m.end()).equals(wordHightLight)) {
                            int s = ClientProxy.Font.width(line.substring(0, m.start()));
                            int e = ClientProxy.Font.width(line.substring(0, m.end())) + 1;
                            drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0x99004c00);
                        }
                    }
                }
                // Highlight the current line (light gray) under any selection
                if (active && isEnabled() && (cursorPosition >= data.start && cursorPosition < data.end || (i == list.size() - 1 && cursorPosition == text.length()))) {
                    drawRect(x , posY, x + width - 1, posY + container.lineHeight, 0x22e0e0e0);
                }
                // Highlight selection
                if (startSelection != endSelection && endSelection > data.start && startSelection <= data.end) {
                    if (startSelection < data.end) {
                        int s = ClientProxy.Font.width(line.substring(0, Math.max(startSelection - data.start, 0)));
                        int e = ClientProxy.Font.width(line.substring(0, Math.min(endSelection - data.start, w))) + 1;
                        drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0x992172ff);
                    }
                }

                // Draw indent guides once per visible block based on brace spans
                if (i == Math.max(0, scrolledLine) && !braceSpans.isEmpty()) {
                    int visStart = Math.max(0, scrolledLine);
                    int visEnd = Math.min(list.size() - 1, visStart + container.visibleLines - 0);
                    for (int[] span : braceSpans) {
                        int originalDepth = span[0];
                        int openLine = span[1];
                        int closeLine = span[2];
                        int depth = span.length > 3 ? span[3] : originalDepth;
                        // Skip top-level (depth 1) using the original depth to avoid hiding nested guides when adjusted
                        if (originalDepth <= 1)
                            continue;
                        int startLine = openLine + 1; // start under the opening brace
                        int endLine = closeLine - 1;  // stop before the closing brace
                        if (startLine > endLine)
                            continue;
                        if (endLine < visStart || startLine > visEnd)
                            continue;

                        int drawStart = Math.max(startLine, visStart);
                        int drawEnd = Math.min(endLine, visEnd);
                        // Compute horizontal position: 4 spaces per indent level, minus a tiny left offset
                        int safeDepth = Math.max(1, depth);
                        int spaces = (safeDepth - 1) * 4;
                        StringBuilder sb = new StringBuilder();
                        for (int k = 0; k < spaces; k++)
                            sb.append(' ');
                        int px = ClientProxy.Font.width(sb.toString());
                        int gx = x + LINE_NUMBER_GUTTER_WIDTH + 4 + px - 2; // shift left ~2px for the IntelliJ feel

                        int topY = y + (drawStart - scrolledLine) * container.lineHeight;
                        int bottomY = y + (endLine - scrolledLine + 1) * container.lineHeight;
                            int guideColor = (openLine == highlightedOpenLine && closeLine == highlightedCloseLine) ? 0x9933cc00 : 0x33FFFFFF;
                            drawRect(gx, topY, gx + 1, bottomY, guideColor);
                    }
                }
                int yPos = posY + stringYOffset;
                data.drawString(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0);

                // Draw cursor: pause blinking while user is active recently
                boolean recentInput = System.currentTimeMillis() - this.lastInputTime < 500;
                if (active && isEnabled() && (recentInput || (cursorCounter / 10) % 2 == 0) && (cursorPosition >= data.start && cursorPosition < data.end || (i == list.size() - 1 && cursorPosition == text.length()))) {
                    int posX = x + LINE_NUMBER_GUTTER_WIDTH + ClientProxy.Font.width(
                            line.substring(0, Math.min(cursorPosition - data.start, line.length())));
                    drawRect(posX + 1, yPos -1, posX + 2, yPos - 1 + container.lineHeight, 0xffffffff);
                }
            }
        }
        GL11.glPopMatrix();

        if (hasVerticalScrollbar()) {
            Minecraft.getMinecraft().renderEngine.bindTexture(GuiCustomScroll.resource);
            int sbSize = Math.max((int) (1f * (container.visibleLines) / container.linesCount * height), 2);

            int posX = x + width - 6;
            double linesCount = Math.max(1, (double) container.linesCount);
            int posY = (int) (y + 1f * scrollPos / linesCount * (height - 4)) + 1;

            drawRect(posX, posY, posX + 5, posY + sbSize + 2, 0xFFe0e0e0);
        }
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
    }
    // ==================== BRACKET MATCHING ====================
    // Uses BracketMatcher helper for bracket span detection
    
    private int[] findBracketSpanAt(int pos) {
        return BracketMatcher.findBracketSpanAt(text, pos);
    }
    
    private int findClosingBracket(String str, char s, char e) {
        return BracketMatcher.findClosingBracket(str, s, e);
    }

    private int findOpeningBracket(String str, char s, char e) {
        return BracketMatcher.findOpeningBracket(str, s, e);
    }

    private List<int[]> computeBraceSpans(String fullText, List<LineData> lines) {
        return BracketMatcher.computeBraceSpans(fullText, lines);
    }

    // ==================== SELECTION & CURSOR POSITION ====================

    private int getSelectionPos(int xMouse, int yMouse) {
        xMouse -= (this.x + LINE_NUMBER_GUTTER_WIDTH + 1);
        yMouse -= this.y + 1;
        // Adjust yMouse to account for fractional GL translation (negative offset applied in rendering)
        double fracOffset = scrollPos - scrolledLine;
        double fracPixels = fracOffset * container.lineHeight;
        yMouse = (int) Math.round(yMouse + fracPixels);
        
        ArrayList list = new ArrayList(this.container.lines);

        for (int i = 0; i < list.size(); ++i) {
            LineData data = (LineData) list.get(i);
            if (i >= this.scrolledLine && i <= this.scrolledLine + this.container.visibleLines) {
                int yPos = (i - this.scrolledLine) * this.container.lineHeight;
                if (yMouse >= yPos && yMouse < yPos + this.container.lineHeight) {
                    int lineWidth = 0;
                    char[] chars = data.text.toCharArray();

                    for (int j = 1; j <= chars.length; ++j) {
                        int w = ClientProxy.Font.width(data.text.substring(0, j));
                        if (xMouse < lineWidth + (w - lineWidth) / 2) {
                            return data.start + j - 1;
                        }

                        lineWidth = w;
                    }

                    // Place cursor after the last visible character of the line.
                    // `data.end - 1` previously pointed at the newline for non-last lines
                    // which made clicks land on the newline rather than after the text.
                    // Use data.start + chars.length to return the position directly
                    // after the line's characters, clamped to the total text length.
                    int posAfterChars = data.start + chars.length;
                    return Math.min(posAfterChars, text.length());
                }
            }
        }

        return this.container.text.length();
    }

    // Find which line the cursor is on (0-indexed)
    private int getCursorLineIndex() {
        if (container == null || container.lines == null || container.lines.isEmpty()) return 0;
        for (int i = 0; i < container.lines.size(); i++) {
            LineData ld = container.lines.get(i);
            // For last line, use <= since end doesn't include +1 for newline
            // For other lines, use < since end includes the newline position
            boolean isLastLine = (i == container.lines.size() - 1);
            boolean isOnLine = isLastLine 
                    ? (cursorPosition >= ld.start && cursorPosition <= ld.end)
                    : (cursorPosition >= ld.start && cursorPosition < ld.end);
            if (isOnLine) {
                return i;
            }
        }
        return container.lines.size() - 1;
    }
    
    // Check if cursor is on a specific line, handling the last line specially
    // (last line doesn't have trailing newline, so use <= for end boundary)
    private boolean isCursorOnLine(int lineIndex, LineData line) {
        boolean isLastLine = (lineIndex == container.lines.size() - 1);
        return isLastLine 
                ? (cursorPosition >= line.start && cursorPosition <= line.end)
                : (cursorPosition >= line.start && cursorPosition < line.end);
    }
    
    // Scroll viewport to keep cursor visible (minimal adjustment, like IntelliJ)
    // Only scrolls if cursor is outside the visible area
    private void scrollToCursor() {
        if (container == null || container.lines == null || container.lines.isEmpty()) return;
        
        int lineIdx = getCursorLineIndex();
        int visible = Math.max(1, container.visibleLines);
        int maxScroll = Math.max(0, container.linesCount - visible);
        
        int firstVisible = scrolledLine;
        int lastFullyVisible = scrolledLine + visible;
        
        if (lineIdx < firstVisible) {
            // Cursor is above viewport - scroll up just enough to show it
            targetScroll = lineIdx;
        } else if (lineIdx > lastFullyVisible) {
            // Cursor is below viewport - scroll down just enough to show it
            targetScroll = Math.min(lineIdx - visible, maxScroll);
        }
        // If cursor is visible, don't change scroll
    }
    
    // Legacy method name for compatibility
    private void ensureCursorVisible() {
        scrollToCursor();
    }
    
    // ==================== KEYBOARD INPUT HANDLING ====================

    @Override
    public boolean textboxKeyTyped(char c, int i) {
        if (!active)
            return false;

        if (this.isKeyComboCtrlA(i)) {
            startSelection = cursorPosition = 0;
            endSelection = text.length();
            return true;
        }

        if (!isEnabled())
            return false;

        LineData currentLine = null;
        for (LineData line : this.container.lines) {
            if (startSelection >= line.start && startSelection < line.end) {
                currentLine = line;
                break;
            }
        }

        String original = text;
        if (i == Keyboard.KEY_LEFT) {
            int j = 1;
            if (isCtrlKeyDown()) {
                Matcher m = container.regexWord.matcher(text.substring(0, cursorPosition));
                while (m.find()) {
                    if (m.start() == m.end())
                        continue;
                    j = cursorPosition - m.start();
                }
            }
            int newPos = Math.max(cursorPosition - j, 0);
            setCursor(newPos, GuiScreen.isShiftKeyDown());
            return true;
        }
        if (i == Keyboard.KEY_RIGHT) {
            int j = 1;
            if (isCtrlKeyDown()) {
                Matcher m = container.regexWord.matcher(text.substring(cursorPosition));
                if (m.find() && m.start() > 0 || m.find()) {
                    j = m.start();
                }
            }
            int newPos = Math.min(cursorPosition + j, text.length());
            setCursor(newPos, GuiScreen.isShiftKeyDown());
            return true;
        }
        if (i == Keyboard.KEY_UP) {
            setCursor(cursorUp(), GuiScreen.isShiftKeyDown());
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_DOWN) {
            setCursor(cursorDown(), GuiScreen.isShiftKeyDown());
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_DELETE) {
            String s = getSelectionAfterText();
            if (!s.isEmpty() && startSelection == endSelection)
                s = s.substring(1);
            setText(getSelectionBeforeText() + s);
            endSelection = cursorPosition = startSelection;
            return true;
        }
        if (isKeyComboCtrlBackspace(i)) {
            String s = getSelectionBeforeText();
            if (startSelection > 0 && startSelection == endSelection) {
                int nearestCondition = cursorPosition;
                int g;
                boolean cursorInWhitespace = Character.isWhitespace(s.charAt(cursorPosition - 1));
                if (cursorInWhitespace) {
                    // Find the nearest word if we are starting in whitespace
                    for (g = cursorPosition - 1; g >= 0; g--) {
                        char currentChar = s.charAt(g);
                        if (!Character.isWhitespace(currentChar)) {
                            nearestCondition = g;
                            break;
                        }
                        if (g == 0) {
                            nearestCondition = 0;
                        }
                    }
                } else {
                    // Find the nearest blank space or new line
                    for (g = cursorPosition - 1; g >= 0; g--) {
                        char currentChar = s.charAt(g);
                        if (Character.isWhitespace(currentChar) || currentChar == '\n') {
                            nearestCondition = g;
                            break;
                        }
                        if (g == 0) {
                            nearestCondition = 0;
                        }
                    }
                }

                // Remove all text to the left up to the nearest boundary
                s = s.substring(0, nearestCondition);
                startSelection -= (cursorPosition - nearestCondition);
            }
            setText(s + getSelectionAfterText());
            endSelection = cursorPosition = startSelection;
            return true;
        }
        if (i == Keyboard.KEY_BACK) {
            // Handle selection deletion first
            if (startSelection != endSelection) {
                String s = getSelectionBeforeText();
                setText(s + getSelectionAfterText());
                endSelection = cursorPosition = startSelection;
                scrollToCursor();
                return true;
            }
            
            // Nothing to delete if at start
            if (startSelection <= 0) {
                return true;
            }
            
            // Find current line for indent-aware backspace
            LineData curr = null;
            for (int idx = 0; idx < container.lines.size(); idx++) {
                LineData line = container.lines.get(idx);
                boolean isLastLine = (idx == container.lines.size() - 1);
                boolean isOnLine = isLastLine 
                        ? (cursorPosition >= line.start && cursorPosition <= line.end)
                        : (cursorPosition >= line.start && cursorPosition < line.end);
                if (isOnLine) {
                    curr = line;
                    break;
                }
            }
            
            // Indent-aware backspace: if cursor is at or before the EXPECTED indent, merge with previous line
            // If cursor is after expected indent (even in extra whitespace), do normal backspace
            if (curr != null && curr.start > 0) {
                int col = cursorPosition - curr.start;
                int actualIndent = getLineIndent(curr.text);
                int expectedIndent = getExpectedIndent(curr);
                
                // Only trigger smart merge if cursor is at or before the expected indent position
                if (col <= expectedIndent) {
                    boolean lineHasContent = curr.text.trim().length() > 0;
                    int newlinePos = curr.start - 1;  // Position of newline before this line
                    
                    if (!lineHasContent) {
                        // Empty/whitespace-only line: remove the entire line including its trailing newline
                        int removeEnd = text.indexOf('\n', curr.start);
                        if (removeEnd == -1) {
                            removeEnd = text.length();
                        } else {
                            removeEnd = removeEnd + 1;  // Include the newline
                        }
                        String before = text.substring(0, curr.start);
                        String after = removeEnd <= text.length() ? text.substring(removeEnd) : "";
                        setText(before + after);
                        // Cursor goes to end of previous line (at the newline position, which is now end of prev line content)
                        int newCursor = Math.max(0, curr.start - 1);
                        endSelection = cursorPosition = startSelection = newCursor;
                        scrollToCursor();
                        return true;
                    } else {
                        // Line has content: merge with previous line
                        // Remove newline + indent, keep content
                        int contentStart = curr.start + actualIndent;
                        
                        String before = text.substring(0, newlinePos);
                        String content = contentStart <= text.length() ? text.substring(contentStart) : "";
                        
                        // Determine if we need spacing between merged content
                        String spacer = "";
                        if (before.length() > 0 && content.length() > 0) {
                            char lastChar = before.charAt(before.length() - 1);
                            char firstChar = content.charAt(0);
                            // Add space unless previous ends with whitespace/open bracket or current starts with close bracket/punctuation
                            if (!Character.isWhitespace(lastChar) && 
                                lastChar != '{' && lastChar != '(' && lastChar != '[' &&
                                firstChar != '}' && firstChar != ')' && firstChar != ']' && 
                                firstChar != ';' && firstChar != ',' && firstChar != '.' &&
                                firstChar != '\n') {
                                spacer = " ";
                            }
                        }
                        
                        setText(before + spacer + content);
                        int newCursor = before.length() + spacer.length();
                        endSelection = cursorPosition = startSelection = newCursor;
                        scrollToCursor();
                        return true;
                    }
                }
            }
            
            // Auto-pair deletion: if deleting an opening bracket/quote and next char is the matching closer
            if (startSelection > 0 && startSelection < text.length()) {
                char prev = text.charAt(startSelection - 1);
                char nextc = text.charAt(startSelection);
                if ((prev == '(' && nextc == ')') || 
                    (prev == '[' && nextc == ']') || 
                    (prev == '{' && nextc == '}') || 
                    (prev == '\'' && nextc == '\'') || 
                    (prev == '"' && nextc == '"')) {
                    String before = text.substring(0, startSelection - 1);
                    String after = startSelection + 1 < text.length() ? text.substring(startSelection + 1) : "";
                    setText(before + after);
                    startSelection -= 1;
                    endSelection = cursorPosition = startSelection;
                    scrollToCursor();
                    return true;
                }
            }

            // Normal backspace: delete one character
            String s = getSelectionBeforeText();
            s = s.substring(0, s.length() - 1);
            startSelection--;
            setText(s + getSelectionAfterText());
            endSelection = cursorPosition = startSelection;
            scrollToCursor();
            return true;
        }
        if (this.isKeyComboCtrlX(i)) {
            if (startSelection != endSelection) {
                NoppesStringUtils.setClipboardContents(text.substring(startSelection, endSelection));
                String s = getSelectionBeforeText();
                setText(s + getSelectionAfterText());
                endSelection = startSelection = cursorPosition = s.length();
                scrollToCursor();
            }
            return true;
        }
        if (this.isKeyComboCtrlC(i)) {
            if (startSelection != endSelection) {
                NoppesStringUtils.setClipboardContents(text.substring(startSelection, endSelection));
            }
            return true;
        }
        if (this.isKeyComboCtrlV(i)) {
            addText(NoppesStringUtils.getClipboardContents());
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_Z && isCtrlKeyDown()) {
            if (undoList.isEmpty())
                return false;
            undoing = true;
            redoList.add(new UndoData(this.text, this.cursorPosition));
            UndoData data = undoList.remove(undoList.size() - 1);
            setText(data.text);
            endSelection = startSelection = cursorPosition = data.cursorPosition;
            undoing = false;
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_Y && isCtrlKeyDown()) {
            if (redoList.isEmpty())
                return false;
            undoing = true;
            undoList.add(new UndoData(this.text, this.cursorPosition));
            UndoData data = redoList.remove(redoList.size() - 1);
            setText(data.text);
            endSelection = startSelection = cursorPosition = data.cursorPosition;
            undoing = false;
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_TAB) {
            boolean shift = isShiftKeyDown();
            if (shift) {
                handleShiftTab();
            } else {
                handleTab();
            }
            scrollToCursor();
            return true;
        }
        if (i == Keyboard.KEY_F && isCtrlKeyDown()) {
            formatText();
            return true;
        }
        if (i == Keyboard.KEY_RETURN) {
            if (cursorPosition > 0 && cursorPosition <= text.length() && text.charAt(cursorPosition - 1) == '{') {
                String indent = getIndentCurrentLine();
                String childIndent = indent + "    ";
                String before = getSelectionBeforeText();
                String after = getSelectionAfterText();

                // If there is non-empty code on the same line after the brace (before the next newline),
                // treat it as code that should be moved into the newly created inner line. In that case
                // just insert the child indent and return — do not insert the closing brace before that code.
                int firstNewline = after.indexOf('\n');
                String leadingSegment = firstNewline == -1 ? after : after.substring(0, firstNewline);
                if (leadingSegment.trim().length() > 0) {
                    addText("\n" + childIndent);
                    scrollToCursor();
                    return true;
                }

                // Determine whether this opening brace already has a matching closing
                // brace at the same scope (and indent). Prefer using the brace-span
                // computation which skips strings/comments and handles nesting.
                boolean hasMatchingCloseSameIndent = false;
                try {
                    // Find the line index containing the opening brace (cursorPosition-1)
                    int openLineIdx = -1;
                    int bracePos = cursorPosition - 1;
                    for (int li = 0; li < this.container.lines.size(); li++) {
                        LineData ld = this.container.lines.get(li);
                        if (bracePos >= ld.start && bracePos < ld.end) {
                            openLineIdx = li;
                            break;
                        }
                    }

                    if (openLineIdx >= 0) {
                        List<int[]> spans = computeBraceSpans(text, this.container.lines);
                        for (int[] span : spans) {
                            int spanOpen = span[1];
                            int spanClose = span[2];
                            if (spanOpen == openLineIdx) {
                                // Found a matching close; check its indent equals current indent
                                int closeIndent = getLineIndent(this.container.lines.get(spanClose).text);
                                if (closeIndent == indent.length()) {
                                    hasMatchingCloseSameIndent = true;
                                }
                                break;
                            }
                        }
                    }
                } catch (Exception ex) {
                    // Fallback: if anything goes wrong, conservatively behave as before
                    hasMatchingCloseSameIndent = false;
                }


                if (hasMatchingCloseSameIndent) {
                    addText("\n" + childIndent);
                    scrollToCursor();
                } else {
                    String insert = "\n" + childIndent + "\n" + indent + "}";
                    setText(before + insert + after);
                    int newCursor = before.length() + 1 + childIndent.length();
                    startSelection = endSelection = cursorPosition = newCursor;
                    scrollToCursor();
                }
            } else {
                addText(Character.toString('\n') + getAutoIndentForEnter());
                scrollToCursor();
            }
        }
        if (ChatAllowedCharacters.isAllowedCharacter(c)) {
            String before = getSelectionBeforeText();
            String after = getSelectionAfterText();

            // If typing a closing char and the next char is already that closer, skip over it
            if ((c == ')' || c == ']' || c == '"' || c == '\'' ) && after.length() > 0 && after.charAt(0) == c) {
                // move cursor forward over existing closer
                startSelection = endSelection = cursorPosition = before.length() + 1;
                scrollToCursor();
                return true;
            }

            if (c == '"') {
                setText(before + "\"\"" + after);
                startSelection = endSelection = cursorPosition = before.length() + 1;
                scrollToCursor();
                return true;
            }
            if (c == '\'') {
                setText(before + "''" + after);
                startSelection = endSelection = cursorPosition = before.length() + 1;
                scrollToCursor();
                return true;
            }
            if (c == '[') {
                setText(before + "[]" + after);
                startSelection = endSelection = cursorPosition = before.length() + 1;
                scrollToCursor();
                return true;
            }
            if (c == '(') {
                setText(before + "()" + after);
                startSelection = endSelection = cursorPosition = before.length() + 1;
                scrollToCursor();
                return true;
            }

            addText(Character.toString(c));
            scrollToCursor();
        }

        if (i == Keyboard.KEY_SLASH && isCtrlKeyDown()) {
            if (startSelection != endSelection) {
                toggleCommentSelection();
            } else {
                toggleCommentLineAtCursor();
            }
            return true;
        }

        if (i == Keyboard.KEY_D && isCtrlKeyDown()) {
            if (startSelection != endSelection) {
                // Handle multi-line selection duplication
                LineData firstLine = null, lastLine = null;
                for (LineData line : container.lines) {
                    if (line.end > startSelection && line.start < endSelection) {
                        if (firstLine == null) firstLine = line;
                        lastLine = line;
                    }
                }
                if (firstLine != null && lastLine != null) {
                    String selectedText = text.substring(firstLine.start, lastLine.end);
                    // Insert the selected block immediately after the last line without adding an extra newline
                    String insertText = selectedText;
                    // Save selection before setText
                    int savedStart = startSelection;
                    int savedEnd = endSelection;
                    int insertAt = lastLine.end;
                    setText(text.substring(0, insertAt) + insertText + text.substring(insertAt));
                    // Restore cursor and selection
                    startSelection = savedStart;
                    endSelection = this.cursorPosition =  savedEnd;
                    return true;
                }
            } else {
                // Single line duplication (existing logic)
                for (LineData line : container.lines) {
                    if (cursorPosition >= line.start && cursorPosition <= line.end) {
                        int lineStart = line.start, lineEnd = line.end;
                        String lineText = text.substring(lineStart, lineEnd);
                        // Avoid inserting an extra blank line: if lineText already ends with a newline,
                        // reuse it; otherwise prepend a newline so the duplicate appears immediately after.
                        String insertText;
                        if (lineText.endsWith("\n")) {
                            insertText = lineText;
                        } else {
                            insertText = "\n" + lineText;
                        }
                        int insertionPoint = lineEnd;
                        setText(text.substring(0, insertionPoint) + insertText + text.substring(insertionPoint));
                        // Place cursor at end of duplicated line (just before any trailing newline)
                        int newCursor = insertionPoint + insertText.length() - (insertText.endsWith("\n") ? 1 : 0);
                        startSelection = endSelection = cursorPosition = Math.max(0, Math.min(newCursor, this.text.length()));
                        return true;
                    }
                }
            }
        }

        return true;
    }

    private boolean isShiftKeyDown() {
        return Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54);
    }

    // ==================== COMMENT TOGGLING ====================
    // Uses CommentHandler helper for comment operations
    
    private void toggleCommentSelection() {
        CommentHandler.SelectionToggleResult result = CommentHandler.toggleCommentSelection(
                text, container.lines, startSelection, endSelection);
        setText(result.newText);
        startSelection = result.newStartSelection;
        endSelection = result.newEndSelection;
        cursorPosition = endSelection;
    }

    private void toggleCommentLineAtCursor() {
        CommentHandler.SingleLineToggleResult result = CommentHandler.toggleCommentAtCursor(
                text, container.lines, cursorPosition);
        setText(result.newText);
        setCursor(result.newCursorPosition, false);
    }
    
    // ==================== KEYBOARD MODIFIERS ====================

    private boolean isAltKeyDown() {
        return Keyboard.isKeyDown(56) || Keyboard.isKeyDown(184);
    }

    private boolean isKeyComboCtrlX(int keyID) {
        return keyID == 45 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown();
    }

    private boolean isKeyComboCtrlBackspace(int keyID) {
        return keyID == Keyboard.KEY_BACK && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown();
    }

    private boolean isKeyComboCtrlV(int keyID) {
        return keyID == 47 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown();
    }

    private boolean isKeyComboCtrlC(int keyID) {
        return keyID == 46 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown();
    }

    private boolean isKeyComboCtrlA(int keyID) {
        return keyID == 30 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown();
    }

    private String getIndentCurrentLine() {
        for (LineData data : this.container.lines) {
            if (this.cursorPosition > data.start && this.cursorPosition <= data.end) {
                int i;
                for (i = 0; i < data.text.length() && data.text.charAt(i) == ' '; ++i) {
                }
                return data.text.substring(0, i);
            }
        }
        return "";
    }

    private String getAutoIndentForEnter() {
        LineData currentLine = null;
        for (LineData line : this.container.lines) {
            if (this.cursorPosition >= line.start && this.cursorPosition < line.end) {
                currentLine = line;
                break;
            }
        }

        if (currentLine == null) {
            return "";
        }

        String lineText = currentLine.text;
        int leading = 0;
        while (leading < lineText.length() && (lineText.charAt(leading) == ' ' || lineText.charAt(leading) == '\t')) {
            leading++;
        }

        String baseIndent = lineText.substring(0, leading);
        int relativeCursor = Math.max(0, Math.min(this.cursorPosition - currentLine.start, lineText.length()));
        String beforeCursor = lineText.substring(0, relativeCursor);

        // Find last non-whitespace before cursor
        int lastNonWs = -1;
        for (int idx = beforeCursor.length() - 1; idx >= 0; idx--) {
            if (!Character.isWhitespace(beforeCursor.charAt(idx))) {
                lastNonWs = idx;
                break;
            }
        }

        // Only add extra indent if cursor is actually after the opening brace (not just in trailing whitespace)
        // Check that the last non-whitespace is at or after the line's indent position
        boolean opensBlock = lastNonWs >= 0 && lastNonWs >= leading && beforeCursor.charAt(lastNonWs) == '{';
        if (opensBlock) {
            return baseIndent + "    ";
        }

        return baseIndent;
    }

    private int getLineIndent(String lineText) {
        int leading = 0;
        while (leading < lineText.length() && (lineText.charAt(leading) == ' ' || lineText.charAt(
                leading) == '\t')) {
            leading++;
        }
        return leading;
    }

    // Calculate the expected/proper indent for the current line based on surrounding context
    private int getExpectedIndent(LineData currentLine) {
        if (currentLine == null) {
            return 0;
        }

        int idx = container.lines.indexOf(currentLine);
        if (idx <= 0) {
            return 0; // First line has no expected indent
        }

        // Find the previous non-empty line
        LineData prevLine = null;
        for (int i = idx - 1; i >= 0; i--) {
            LineData line = container.lines.get(i);
            if (line.text.trim().length() > 0) {
                prevLine = line;
                break;
            }
        }

        if (prevLine == null) {
            return 0;
        }

        int prevIndent = getLineIndent(prevLine.text);
        String prevTrimmed = prevLine.text.trim();
        String currTrimmed = currentLine.text.trim();

        // If current line starts with }, expected indent is one level back
        if (currTrimmed.startsWith("}")) {
            return Math.max(0, prevIndent - getTabSize());
        }

        // If previous line ends with {, expected indent is one level forward
        if (prevTrimmed.endsWith("{")) {
            return prevIndent + getTabSize();
        }

        // Otherwise, expected indent matches previous line
        return prevIndent;
    }

    // ==================== TEXT FORMATTING ====================
    
    private int getTabSize() {
        return IndentHelper.TAB_SIZE;
    }

    private String repeatSpace(int count) {
        return IndentHelper.spaces(count);
    }

    private void formatText() {
        IndentHelper.FormatResult result = IndentHelper.formatText(text, cursorPosition);
        setText(result.text);
        startSelection = endSelection = cursorPosition = Math.max(0, Math.min(result.cursorPosition, this.text.length()));
    }
    
    // ==================== TAB HANDLING ====================

    private void handleTab() {
        LineData currentLine = null;
        for (int i = 0; i < this.container.lines.size(); i++) {
            LineData line = this.container.lines.get(i);
            boolean isLastLine = (i == this.container.lines.size() - 1);
            boolean isOnLine = isLastLine 
                    ? (this.cursorPosition >= line.start && this.cursorPosition <= line.end)
                    : (this.cursorPosition >= line.start && this.cursorPosition < line.end);
            if (isOnLine) {
                currentLine = line;
                break;
            }
        }
        if (currentLine == null) {
            addText("    ");
            return;
        }
        int tab = getTabSize();
        int indentLen = getLineIndent(currentLine.text);
        int textStartPos = currentLine.start + indentLen;

        if (this.cursorPosition <= textStartPos) {
            // Cursor before any text: if cursor is exactly at text start, move forward to next tab stop.
            // If cursor is inside leading whitespace (before text start), choose nearest tab stop (tie -> forward).
            int targetIndent;
            if (this.cursorPosition == textStartPos) {
                targetIndent = ((indentLen / tab) + 1) * tab;
            } else {
                int remainder = indentLen % tab;
                if (remainder == 0) {
                    targetIndent = indentLen + tab; // already aligned -> next level
                } else {
                    int down = indentLen - remainder;
                    int up = indentLen + (tab - remainder);
                    int distDown = remainder;
                    int distUp = tab - remainder;
                    if (distUp < distDown) targetIndent = up;
                    else if (distUp > distDown) targetIndent = down;
                    else targetIndent = up; // tie -> forward
                }
            }
            if (targetIndent < 0) targetIndent = 0;
            String newIndent = repeatSpace(targetIndent);
            String rest = currentLine.text.substring(indentLen);
            String before = text.substring(0, currentLine.start);
            int contentEnd = Math.min(currentLine.start + currentLine.text.length(), text.length());
            int sepEnd = Math.min(currentLine.end, text.length());
            String sep = contentEnd < sepEnd ? text.substring(contentEnd, sepEnd) : "";
            String after = text.substring(sepEnd);
            setText(before + newIndent + rest + sep + after);
            int newCursor = currentLine.start + targetIndent;
            startSelection = endSelection = cursorPosition = Math.min(newCursor, this.text.length());
        } else {
            // Cursor is after start of text: insert spaces at cursor to move following text to next tab stop
            int column = this.cursorPosition - currentLine.start;
            int targetColumn = ((column / tab) + 1) * tab;
            int toInsert = Math.max(0, targetColumn - column);
            if (toInsert > 0) {
                String spaces = repeatSpace(toInsert);
                addText(spaces);
            }
        }
    }

    private void handleShiftTab() {
        LineData currentLine = null;
        for (int i = 0; i < this.container.lines.size(); i++) {
            LineData line = this.container.lines.get(i);
            boolean isLastLine = (i == this.container.lines.size() - 1);
            boolean isOnLine = isLastLine 
                    ? (this.cursorPosition >= line.start && this.cursorPosition <= line.end)
                    : (this.cursorPosition >= line.start && this.cursorPosition < line.end);
            if (isOnLine) {
                currentLine = line;
                break;
            }
        }
        if (currentLine == null)
            return;
        int tab = getTabSize();
        int indentLen = getLineIndent(currentLine.text);
        int textStartPos = currentLine.start + indentLen;

        if (this.cursorPosition <= textStartPos) {
            // Cursor before any text: reduce leading indent to previous tab stop
            int targetIndent = Math.max(0, ((indentLen - 1) / tab) * tab);
            String newIndent = repeatSpace(targetIndent);
            String rest = currentLine.text.substring(indentLen);
            String before = text.substring(0, currentLine.start);
            int contentEnd = Math.min(currentLine.start + currentLine.text.length(), text.length());
            int sepEnd = Math.min(currentLine.end, text.length());
            String sep = contentEnd < sepEnd ? text.substring(contentEnd, sepEnd) : "";
            String after = text.substring(sepEnd);
            setText(before + newIndent + rest + sep + after);
            int newCursor = currentLine.start + targetIndent;
            startSelection = endSelection = cursorPosition = Math.min(newCursor, this.text.length());
        } else {
            // Cursor after start of text: remove up to previous tab stop worth of spaces immediately before cursor
            int column = this.cursorPosition - currentLine.start;
            int mod = column % tab;
            int toRemove = mod == 0 ? tab : mod;
            int removed = 0;
            int pos = this.cursorPosition - 1;
            while (pos >= currentLine.start && removed < toRemove && text.charAt(pos) == ' ') {
                pos--;
                removed++;
            }
            if (removed > 0) {
                int removeStart = pos + 1;
                String before = text.substring(0, removeStart);
                String after = text.substring(this.cursorPosition);
                setText(before + after);
                int newCursor = removeStart;
                startSelection = endSelection = cursorPosition = Math.min(newCursor, this.text.length());
            }
        }
    }
    
    // ==================== CURSOR MANAGEMENT ====================

    private void setCursor(int i, boolean select) {
        i = Math.min(Math.max(i, 0), this.text.length());
        if (i != this.cursorPosition) {
            if (!select) {
                this.endSelection = this.startSelection = this.cursorPosition = i;
            } else {
                int diff = this.cursorPosition - i;
                if (this.cursorPosition == this.startSelection) {
                    this.startSelection -= diff;
                } else if (this.cursorPosition == this.endSelection) {
                    this.endSelection -= diff;
                }

                if (this.startSelection > this.endSelection) {
                    int j = this.endSelection;
                    this.endSelection = this.startSelection;
                    this.startSelection = j;
                }

                this.cursorPosition = i;
            }

            clampSelectionBounds();
            // Moving the cursor is user activity — pause blinking briefly
            this.lastInputTime = System.currentTimeMillis();
        }
    }

    private void addText(String s) {
        this.setText(this.getSelectionBeforeText() + s + this.getSelectionAfterText());
        this.endSelection = this.startSelection = this.cursorPosition = this.startSelection + s.length();
        this.lastInputTime = System.currentTimeMillis();
    }

    private int cursorUp() {
        for (int i = 0; i < this.container.lines.size(); ++i) {
            LineData data = (LineData) this.container.lines.get(i);
            // For last line, use <= since end doesn't include +1 for newline
            // For other lines, use < since end includes the newline position
            boolean isLastLine = (i == this.container.lines.size() - 1);
            boolean isOnLine = isLastLine 
                    ? (this.cursorPosition >= data.start && this.cursorPosition <= data.end)
                    : (this.cursorPosition >= data.start && this.cursorPosition < data.end);
            if (isOnLine) {
                if (i == 0) {
                    return 0;
                }

                int column = Math.min(this.cursorPosition - data.start, data.text.length());
                LineData target = this.container.lines.get(i - 1);
                // Calculate target position on the line above, maintaining column if possible
                int targetColumn = Math.min(column, target.text.length());
                int targetIndent = getLineIndent(target.text);
                int minPos = target.start + Math.min(targetIndent, target.text.length());
                int targetPos = target.start + targetColumn;
                return Math.max(minPos, targetPos);
            }
        }

        return 0;
    }

    private int cursorDown() {
        if (cursorPosition == text.length())
            return cursorPosition;
        for (int i = 0; i < this.container.lines.size(); ++i) {
            LineData data = (LineData) this.container.lines.get(i);
            // For last line, use <= since end doesn't include +1 for newline
            // For other lines, use < since end includes the newline position
            boolean isLastLine = (i == this.container.lines.size() - 1);
            boolean isOnLine = isLastLine 
                    ? (this.cursorPosition >= data.start && this.cursorPosition <= data.end)
                    : (this.cursorPosition >= data.start && this.cursorPosition < data.end);
            if (isOnLine) {
                // If already on last line, stay at current position
                if (i >= this.container.lines.size() - 1) {
                    return cursorPosition;
                }

                int column = Math.min(this.cursorPosition - data.start, data.text.length());
                LineData target = this.container.lines.get(i + 1);
                // Calculate target position on the line below, maintaining column if possible
                int targetColumn = Math.min(column, target.text.length());
                int targetIndent = getLineIndent(target.text);
                int minPos = target.start + Math.min(targetIndent, target.text.length());
                int targetPos = target.start + targetColumn;
                return Math.max(minPos, targetPos);
            }
        }

        return this.text.length();
    }

    public String getSelectionBeforeText() {
        return this.startSelection == 0 ? "" : this.text.substring(0, this.startSelection);
    }

    public String getSelectionAfterText() {
        return this.text.substring(this.endSelection);
    }
    
    // ==================== MOUSE HANDLING ====================

    public void mouseClicked(int xMouse, int yMouse, int mouseButton) {
        this.active = xMouse >= this.x && xMouse < this.x + this.width && yMouse >= this.y && yMouse < this.y + this.height;
        if (this.active) {
            this.startSelection = this.endSelection = this.cursorPosition = this.getSelectionPos(xMouse, yMouse);
            this.lastInputTime = System.currentTimeMillis();
            this.clicked = mouseButton == 0;
            this.doubleClicked = false;
            this.tripleClicked = false;
            long time = System.currentTimeMillis();
            if (this.clicked && this.container.linesCount * this.container.lineHeight > this.height && xMouse > this.x + this.width - 8) {
                this.clicked = false;
                this.clickScrolling = true;
                double linesCountD = Math.max(1, (double) this.container.linesCount);
                int thumbTop = (int) (this.y + 1f * this.scrollPos / linesCountD * (this.height - 4)) + 1;
                this.scrollbarDragOffset = yMouse - thumbTop;
            } else {
                if (time - this.lastClicked < 300L) {
                    this.clickCount++;
                } else {
                    this.clickCount = 1;
                }

                if (this.clickCount == 2) {
                    // Double-click: select word under cursor (restore prior behavior)
                    this.doubleClicked = true;
                    Matcher m = this.container.regexWord.matcher(this.text);
                    while (m.find()) {
                        if (this.cursorPosition >= m.start() && this.cursorPosition <= m.end()) {     
                            this.startSelection = m.start();
                            this.endSelection = m.end();
                            break;
                        }
                    }
                } else if (this.clickCount >= 3) {
                    // Triple-click: select entire line
                    this.tripleClicked = true;
                    for (LineData line : container.lines) {
                        if (this.cursorPosition >= line.start && this.cursorPosition <= line.end) {
                            this.startSelection = line.start;
                            this.endSelection = line.end;
                            break;
                        }
                    }
                    this.clickCount = 0;
                }
            }

            this.lastClicked = time;
            activeTextfield = this;
        }
    }

    public void updateCursorCounter() {
        ++this.cursorCounter;
    }
    
    // ==================== TEXT MANAGEMENT ====================

    public void setText(String text) {
        if (text == null) {
            return;
        }

        text = text.replace("\r", "");
        text = text.replace("\t", "    ");
        if (this.text == null || !this.text.equals(text)) {
            if (this.listener != null) {
                this.listener.textUpdate(text);
            }

            if (!this.undoing) {
                this.undoList.add(new GuiScriptTextArea.UndoData(this.text, this.cursorPosition));
                this.redoList.clear();
            }

            this.text = text;
            //this.container = new TextContainer(text);
            this.container = new JavaTextContainer(text);
            this.container.init(this.width, this.height);
            if (this.enableCodeHighlighting) {
                this.container.formatCodeText();
            }

            // Ensure scroll state stays in bounds after text change
            int maxScroll = Math.max(0, this.container.linesCount - this.container.visibleLines);
            if (this.scrolledLine > maxScroll) {
                this.scrolledLine = maxScroll;
            }
            if (this.targetScroll > maxScroll) {
                this.targetScroll = maxScroll;
            }
            if (this.scrollPos > maxScroll) {
                this.scrollPos = maxScroll;
            }

            clampSelectionBounds();

            // Consider text changes user activity to pause caret blinking briefly
            this.lastInputTime = System.currentTimeMillis();

        }
    }

    public String getText() {
        return this.text;
    }

    public boolean isEnabled() {
        return this.enabled && this.visible;
    }

    public boolean hasVerticalScrollbar() {
        return this.container.visibleLines < this.container.linesCount;
    }

    public void enableCodeHighlighting() {
        this.enableCodeHighlighting = true;
        this.container.formatCodeText();
    }

    public void setListener(ITextChangeListener listener) {
        this.listener = listener;
    }

    private void clampSelectionBounds() {
        if (this.text == null || this.text.isEmpty()) {
            this.startSelection = this.endSelection = this.cursorPosition = 0;
            return;
        }

        int length = this.text.length();
        this.startSelection = Math.max(0, Math.min(this.startSelection, length));
        this.endSelection = Math.max(0, Math.min(this.endSelection, length));
        this.cursorPosition = Math.max(0, Math.min(this.cursorPosition, length));
    }
    
    // ==================== INNER CLASSES ====================

    class UndoData {
        public String text;
        public int cursorPosition;

        public UndoData(String text, int cursorPosition) {
            this.text = text;
            this.cursorPosition = cursorPosition;
        }
    }
}