canalhandia/src/main/java/dev/marcospaulo/canalhandia/ChatLog.java

package dev.marcospaulo.canalhandia;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

/**
 * A tiny rolling window of what was just said in public chat, so the AI can
 * follow along instead of answering every question in a vacuum. "Quem tá
 * falando merda aí?" only makes sense with the last few lines in hand.
 *
 * <p>Deliberately small and forgetful, like {@link Conversations}: this is
 * ambient context for one answer, not a transcript. Nothing is written to disk,
 * and a restart starts it empty.
 *
 * <p><b>Thread-safe.</b> Writes come from the chat event, which Paper fires off
 * the main thread, while reads come from {@link Ai}'s snapshot on the main
 * thread. Both go through {@link #lines}'s own monitor; nothing slow happens
 * under the lock.
 *
 * <p>Messages are stored <em>after</em> any {@code zoacao} replacement, so the
 * AI sees what the room saw rather than what was typed.
 */
final class ChatLog {

    /**
     * A hard ceiling on retained lines regardless of what the config asks for.
     * The window handed to the model is capped separately and is normally much
     * smaller; this only bounds memory if someone sets an absurd value.
     */
    static final int MAX_RETAINED = 50;

    /** Longest single message kept. Longer ones are cut, so one paste cannot
     * dominate the whole context window. */
    static final int MAX_MESSAGE_CHARS = 200;

    record Line(String player, String message) {
    }

    private final Deque<Line> lines = new ArrayDeque<>();

    /**
     * Records one public chat message. Blank messages and blank names are
     * ignored rather than stored as empty lines the model would have to parse.
     */
    void add(String player, String message) {
        if (player == null || player.isBlank() || message == null || message.isBlank()) {
            return;
        }
        String text = message.strip();
        if (text.length() > MAX_MESSAGE_CHARS) {
            text = text.substring(0, MAX_MESSAGE_CHARS) + "…";
        }
        synchronized (lines) {
            lines.addLast(new Line(player.strip(), text));
            while (lines.size() > MAX_RETAINED) {
                lines.removeFirst();
            }
        }
    }

    /**
     * The most recent {@code max} lines, oldest first — reading order, which is
     * how the model should see a conversation.
     *
     * <p>A non-positive {@code max} returns an empty list, so turning the
     * feature off in config costs nothing here.
     */
    List<Line> recent(int max) {
        if (max <= 0) {
            return List.of();
        }
        synchronized (lines) {
            int skip = Math.max(0, lines.size() - max);
            List<Line> out = new ArrayList<>(Math.min(max, lines.size()));
            int i = 0;
            for (Line line : lines) {
                if (i++ >= skip) {
                    out.add(line);
                }
            }
            return out;
        }
    }

    /**
     * The recent window as one pt-BR block for a system message, or {@code null}
     * when there is nothing to say. Pure formatting given the lines, so the
     * shape of what reaches the model is testable without a server.
     */
    static String format(List<Line> recent) {
        if (recent == null || recent.isEmpty()) {
            return null;
        }
        StringBuilder out = new StringBuilder();
        for (Line line : recent) {
            out.append(line.player()).append(": ").append(line.message()).append('\n');
        }
        return out.toString().strip();
    }

    /** Convenience: {@link #format} over {@link #recent}. */
    String formatRecent(int max) {
        return format(recent(max));
    }

    /** How many lines are currently held. For tests and {@code /canalhandia status}. */
    int size() {
        synchronized (lines) {
            return lines.size();
        }
    }

    void clear() {
        synchronized (lines) {
            lines.clear();
        }
    }
}