ChatFilterService.java

package edu.ucsb.cs156.happiercows.services;

import edu.ucsb.cs156.happiercows.entities.BannedWord;
import edu.ucsb.cs156.happiercows.models.CensorResult;
import edu.ucsb.cs156.happiercows.repositories.BannedWordRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

/** Replaces banned words in chat messages with asterisks. */
@Service
public class ChatFilterService {

    // A match must not have a letter, combining mark, digit, or underscore directly
    // before or after it, so banning "cow" does not censor "cowboy".
    private static final String NOT_WORD_CHAR_BEFORE = "(?<![\\p{L}\\p{M}\\p{N}_])";
    private static final String NOT_WORD_CHAR_AFTER = "(?![\\p{L}\\p{M}\\p{N}_])";

    @Autowired
    private BannedWordRepository bannedWordRepository;

    /**
     * Lowercases each character on its own with Locale.ROOT. Used both when storing a
     * banned word and when matching a message, so the two always agree. Some characters
     * expand when lowercased (e.g. "İ" becomes "i" plus a combining dot).
     */
    public static String fold(String text) {
        StringBuilder sb = new StringBuilder();
        text.codePoints().forEach(cp -> sb.append(lowerCodePoint(cp)));
        return sb.toString();
    }

    /** How a banned word is stored: trimmed, then folded. */
    public static String normalize(String word) {
        return fold(word.trim());
    }

    private static String lowerCodePoint(int cp) {
        return new String(Character.toChars(cp)).toLowerCase(Locale.ROOT);
    }

    public CensorResult censor(String message) {
        // Longest first, so "c++" is matched before "c" when both are banned
        List<String> words = StreamSupport
                .stream(bannedWordRepository.findAll().spliterator(), false)
                .map(BannedWord::getWord)
                .map(ChatFilterService::normalize)
                .filter(w -> !w.isEmpty())
                .distinct()
                .sorted(Comparator.comparingInt(String::length).reversed())
                .collect(Collectors.toList());

        if (words.isEmpty()) {
            return new CensorResult(message, false);
        }

        // Fold the message, remembering which original characters each folded char came from
        StringBuilder folded = new StringBuilder();
        List<Integer> originalStart = new ArrayList<>();
        List<Integer> originalEnd = new ArrayList<>();
        int i = 0;
        while (i < message.length()) {
            int cp = message.codePointAt(i);
            int next = i + Character.charCount(cp);
            String lower = lowerCodePoint(cp);
            for (int k = 0; k < lower.length(); k++) {
                originalStart.add(i);
                originalEnd.add(next);
            }
            folded.append(lower);
            i = next;
        }

        String alternatives = words.stream()
                .map(Pattern::quote)
                .collect(Collectors.joining("|"));
        Pattern pattern = Pattern.compile(
                NOT_WORD_CHAR_BEFORE + "(?:" + alternatives + ")" + NOT_WORD_CHAR_AFTER);

        Matcher matcher = pattern.matcher(folded);
        StringBuilder result = new StringBuilder();
        int last = 0;
        boolean censored = false;
        while (matcher.find()) {
            int start = originalStart.get(matcher.start());
            int end = originalEnd.get(matcher.end() - 1);
            result.append(message, last, start)
                    .append("*".repeat(message.codePointCount(start, end)));
            last = end;
            censored = true;
        }

        if (!censored) {
            return new CensorResult(message, false);
        }
        result.append(message.substring(last));
        return new CensorResult(result.toString(), true);
    }
}