Core Java - Lambda Expressions and Functional Interfaces - The Guardian's Gambit: Crafting a Modern Java Content Moderation Engine

[akash-coded]

Ms. Verity, the ever-vigilant Lead Compliance Officer at JPMC's new Global Community Platform, has a critical mission for you. The platform is about to go live, and she needs a sophisticated, yet incredibly flexible, Automated Content Moderation System. Old, clunky rule engines won't do; she needs something modern, adaptable, and easy to update as new community guidelines emerge.

This is your challenge: to build the core of this system, The Community Guardian, using the full potential of Java's functional capabilities. Your AI companion, Echo, will be by your side, providing insights and context as you navigate this new terrain.

---

The Guardian's Gambit: Crafting a Modern Java Content Moderation Engine

Your Mission:
Design and implement the CommunityGuardian.java system. This single file will contain all the interfaces, classes, and the main demonstration. You will leverage functional interfaces (both custom and standard java.util.function ones) and lambda expressions to create a modular, extensible, and readable moderation engine.

The Narrative:
The JPMC Global Community Platform is a hub for employees worldwide to connect, share ideas, and collaborate. To maintain a respectful and productive environment, user-generated content (posts, comments) must be moderated. Your system will analyze content against various rules, transform it if necessary, and take appropriate actions.

---

Prologue: Ms. Verity's Briefing

Ms. Verity: "Dev_Lambda, our community platform's success hinges on a positive user experience. We need an automated moderation system that's not only effective but also highly adaptable. New slang, new discussion topics, evolving company policies – our system must keep pace. I'm told these new 'lambda' thingamajigs and 'functional interfaces' are the way to go for this kind of dynamic logic. Show me what you can do."

Echo (Your AI Assistant): "Greetings, Dev_Lambda! Functional Interfaces are essentially interfaces with a single abstract method (SAM). This makes them perfect candidates for lambda expressions, which provide a compact way to implement that single method. This exercise will show you just how versatile they are!"

---

Chapter 1: The First Line of Defense - Custom Functional Interfaces & Basic Lambdas

First, let's define what we're moderating and create our very own specialized "rule" contract.

Your Tasks (Puzzle 1):

1. Create ContentItem.java (as an inner class or a separate class in your single file for this exercise):

   • A simple POJO (Plain Old Java Object) to hold the content.
   • Properties:
     • String contentId (final)
     • String authorId (final)
     • String textContent (can be modified by transformers)
     • LocalDateTime submissionTime (final)
   • Constructor to initialize these.
   • Getters for all, and a setter for textContent.
   • A toString() method for easy printing.
   • Echo: "This class represents the data your functional interfaces will operate on, Dev_Lambda."

2. Define Your Custom Functional Interface: ContentRule

   • Mark it with the @FunctionalInterface annotation.
     • Echo: "This annotation is a good practice! It tells the compiler to ensure your interface truly has only one abstract method."
   • It should have a single abstract method: boolean test(ContentItem item);
     • This method will return true if the content passes the rule, false otherwise.
   • Add Javadoc explaining its purpose.

3. Create Basic Rules using Lambda Expressions:

   • In your main class (which we'll call CommunityGuardian), declare and initialize two ContentRule variables using lambda expressions:
     • ContentRule lengthRule = (item) -> item.getTextContent() != null && item.getTextContent().length() <= 280; (e.g., max 280 chars)
     • ContentRule noAllCapsRule = (item) -> !item.getTextContent().matches("^[A-Z\\s\\p{Punct}]+$"); (crude check: not ALL CAPS, allowing spaces and punctuation)
       • Echo: "See how concise that is? (item) are the parameters, -> separates them from the body, and the expression after -> is the implementation of test()! These lambdas are instances of your ContentRule interface."

4. Create a Simple RuleEngine Class:

   • This class will have a static method to apply a single rule:
     • public static boolean applyRule(String ruleName, ContentItem item, ContentRule rule)
       • This method takes the rule itself (our functional interface instance) as a parameter! This is a higher-order function pattern.
       • It should print which rule is being applied (e.g., "Applying rule: [ruleName]...").
       • Call rule.test(item).
       • Print whether the item passed or failed the rule.
       • Return the result of rule.test(item).

// CommunityGuardian.java
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors; // For later, if needed

/**
 * Represents an item of content submitted by a user.
 */
class ContentItem {
    private final String contentId;
    private final String authorId;
    private String textContent; // Mutable
    private final LocalDateTime submissionTime;
    private static int idCounter = 0;

    public ContentItem(String authorId, String textContent) {
        this.contentId = "CID-" + String.format("%04d", ++idCounter);
        this.authorId = Objects.requireNonNull(authorId, "Author ID cannot be null");
        this.textContent = Objects.requireNonNull(textContent, "Text content cannot be null");
        this.submissionTime = LocalDateTime.now();
    }

    public String getContentId() { return contentId; }
    public String getAuthorId() { return authorId; }
    public String getTextContent() { return textContent; }
    public LocalDateTime getSubmissionTime() { return submissionTime; }
    public void setTextContent(String textContent) { this.textContent = textContent; }

    @Override
    public String toString() {
        return String.format("ContentItem[ID=%s, Author=%s, Time=%s, Content='%s']",
                contentId, authorId, submissionTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME), textContent);
    }
}

/**
 * A functional interface representing a rule to be applied to content.
 * A rule tests a ContentItem and returns true if it passes, false otherwise.
 */
@FunctionalInterface
interface ContentRule {
    boolean test(ContentItem item);
}

/**
 * Simple engine to apply rules.
 */
class RuleEngine {
    /**
     * Applies a single content rule to a content item.
     * This method demonstrates taking a functional interface (ContentRule) as a parameter.
     * @param ruleName A descriptive name for the rule being applied.
     * @param item The ContentItem to test.
     * @param rule The ContentRule (implemented as a lambda or method reference) to apply.
     * @return true if the item passes the rule, false otherwise.
     */
    public static boolean applyRule(String ruleName, ContentItem item, ContentRule rule) {
        System.out.println("RULE ENGINE: Applying rule - '" + ruleName + "' on " + item.getContentId() + "...");
        boolean result = rule.test(item);
        System.out.println("RULE ENGINE: '" + ruleName + "' " + (result ? "PASSED." : "FAILED."));
        return result;
    }
}

// TODO: Chapters 2, 3, 4 and the main CommunityGuardian class will be added below.

Tutor's Tip (Echo): "Dev_Lambda, custom functional interfaces like ContentRule are great when you need a very specific method signature that isn't covered by the standard ones, or when you want a domain-specific name for clarity. You've just passed behavior (the rule logic) as data into the applyRule method!"

---

Chapter 2: The Standard Toolkit - java.util.function Powerhouses

Java provides a rich set of standard functional interfaces in the java.util.function package. Let's harness them!

Your Tasks (Puzzle 2):

1. Refining Rules with Predicate<T>:

   • A Predicate<T> is a functional interface with a method boolean test(T t). Perfect for our rules!
   • In your CommunityGuardian class (where main will be), create Predicate<ContentItem> instances for:
     • Predicate<ContentItem> nonNullOrEmptyText = item -> item.getTextContent() != null && !item.getTextContent().trim().isEmpty();
     • Predicate<ContentItem> containsNoForbiddenWords = item -> !Arrays.asList("spam", "phish", "exploit").stream().anyMatch(word -> item.getTextContent().toLowerCase().contains(word));
     • Echo: "Predicate is your go-to for any true/false test on an input. Notice how Arrays.asList().stream().anyMatch() itself uses a lambda for its condition!"
   • Modify RuleEngine.applyRule (or create an overloaded version) to accept Predicate<ContentItem> instead of your custom ContentRule. For this exercise, let's create an overload to see both:
     • public static boolean applyPredicateRule(String ruleName, ContentItem item, Predicate<ContentItem> rule) (similar logic to before).

2. Transforming Content with Function<T, R>:

   • A Function<T, R> takes an argument of type T and returns a result of type R (method: R apply(T t)).
   • Create a new class ContentTransformer.
   • Add a method: public static void transformContent(ContentItem item, Function<String, String> transformationLogic, String transformationName)
     • This method takes the current text, applies the transformation logic, and updates the item.setTextContent().
     • It should print what transformation is being applied and the content before and after.
   • In CommunityGuardian, define some Function<String, String> lambdas:
     • Function<String, String> toLowerCase = String::toLowerCase; (using a method reference!)
     • Function<String, String> removeExcessSpaces = text -> text.replaceAll("\\s+", " ").trim();
     • Echo: "Function is for when you need to convert or map an input to an output. And String::toLowerCase is a method reference – a shorthand for a lambda that just calls an existing method. Cool, huh?"

3. Taking Action with Consumer<T>:

   • A Consumer<T> accepts an argument of type T and performs an operation, returning no result (method: void accept(T t)).
   • Create a new class ActionDispatcher.
   • Add a method: public static void performAction(ContentItem item, Consumer<ContentItem> action, String actionName)
     • This method will execute the given action on the item.
   • In CommunityGuardian, define Consumer<ContentItem> lambdas:
     • Consumer<ContentItem> logFlaggedContent = item -> System.out.println("FLAGGED: Content ID " + item.getContentId() + " by author " + item.getAuthorId() + " requires manual review. Reason: [You'll add reason later]");
     • Consumer<ContentItem> sendAlertToAdmin = item -> System.out.println("ALERT: Admin notified about problematic content " + item.getContentId());
     • Consumer<ContentItem> printContentSummary = item -> System.out.println("SUMMARY: " + item.getContentId() + " - " + item.getTextContent().substring(0, Math.min(item.getTextContent().length(), 30)) + "..."); (using a method reference for System.out::println within a more complex lambda is also possible but let's keep it simple here).
     • Echo: "Consumer is perfect for operations where you just want to do something with an object, like logging or notifying, without needing a return value. You can even use method references like System.out::println if the signature matches!"

4. Generating Data with Supplier<T>:

   • A Supplier<T> takes no arguments but returns a value of type T (method: T get()).
   • In CommunityGuardian, define a Supplier<String>:
     • Supplier<String> defaultViolationMessage = () -> "Content violates one or more community guidelines. Action taken.";
     • Echo: "Supplier is handy when you need to generate or provide a value, especially if its creation is non-trivial or needs to be deferred."

// ... (Continuing in CommunityGuardian.java, after ContentItem, ContentRule, RuleEngine)

// Overload in RuleEngine for Predicate
// (Add this method to the existing RuleEngine class)
/*
    public static boolean applyPredicateRule(String ruleName, ContentItem item, Predicate<ContentItem> rule) {
        System.out.println("RULE ENGINE (Predicate): Applying rule - '" + ruleName + "' on " + item.getContentId() + "...");
        boolean result = rule.test(item);
        System.out.println("RULE ENGINE (Predicate): '" + ruleName + "' " + (result ? "PASSED." : "FAILED."));
        return result;
    }
*/
// For simplicity of this exercise, we might just have the main class call predicates directly or use a list.
// Let's adjust: the main ModerationService will use predicates directly.

/**
 * Transforms content based on provided logic.
 */
class ContentTransformer {
    /**
     * Applies a transformation function to the text content of a ContentItem.
     * @param item The ContentItem whose text content will be transformed.
     * @param transformationLogic A Function that takes the current text and returns the transformed text.
     * @param transformationName A descriptive name for the transformation.
     */
    public static void transformContent(ContentItem item, Function<String, String> transformationLogic, String transformationName) {
        System.out.println("TRANSFORMER: Applying '" + transformationName + "' to " + item.getContentId() + "...");
        String originalContent = item.getTextContent();
        String transformedContent = transformationLogic.apply(originalContent);
        item.setTextContent(transformedContent);
        System.out.println("TRANSFORMER: Content transformed. Before: '" + originalContent.substring(0, Math.min(originalContent.length(),30)) + "...', After: '" + transformedContent.substring(0, Math.min(transformedContent.length(),30)) + "...'");
    }
}

/**
 * Dispatches actions to be performed on content items.
 */
class ActionDispatcher {
    /**
     * Performs a specified action on a ContentItem.
     * @param item The ContentItem to act upon.
     * @param action A Consumer that defines the action to be performed.
     * @param actionName A descriptive name for the action.
     */
    public static void performAction(ContentItem item, Consumer<ContentItem> action, String actionName) {
        System.out.println("ACTION DISPATCHER: Performing '" + actionName + "' for " + item.getContentId() + "...");
        action.accept(item);
        System.out.println("ACTION DISPATCHER: '" + actionName + "' completed.");
    }
}

// TODO: Chapters 3, 4 and the main CommunityGuardian class body will be added below.

Tutor's Tip (Echo): "Dev_Lambda, the java.util.function package is your best friend for common functional patterns. Using these standard interfaces makes your code more interoperable and understandable to other Java developers who are familiar with them."

---

Chapter 3: The Strategist's Mind - Storing, Combining, and Returning Logic

Functional interfaces aren't just for passing into methods. You can store their implementations (lambdas) in variables, collect them, and even have methods that create and return them!

Your Tasks (Puzzle 3):

1. Storing Lambdas in Variables: You've already been doing this (e.g., Predicate<ContentItem> nonNullOrEmptyText = ...). This is fundamental.

2. Collecting Rules - List<Predicate<ContentItem>>:

   • In your CommunityGuardian class, create a List<Predicate<ContentItem>> validationRules.
   • Add your nonNullOrEmptyText and containsNoForbiddenWords predicates to this list.
   • Echo: "Storing functions in collections like this is super powerful! Imagine loading rules from a config file and adding them to this list dynamically."

3. Advanced Rule Application (Method taking a List of Predicates):

   • Add a static method to RuleEngine (or a new class AdvancedRuleEngine):
     • public static boolean checkAllRules(ContentItem item, List<Predicate<ContentItem>> rules, String overallCheckName)
       • This method iterates through the rules list.
       • For each rule, it calls rule.test(item).
       • If any rule fails, it should immediately print which rule failed and return false (fail-fast).
       • If all rules pass, it should print that overallCheckName passed and return true.
       • Optional Challenge: Can you use Predicate.and() to chain these rules together if you wanted to evaluate all of them? For this exercise, a loop is fine to show individual failure points.
       • Echo: "Processing a list of functions is common. The Stream API in Java also makes heavy use of this pattern with methods like filter(Predicate), map(Function), etc."

4. Rule Factory - A Method that Returns a Functional Interface:

   • Create a class RuleFactory.
   • Add a static method: public static Predicate<ContentItem> createKeywordBlockRule(String keywordToBlock)
     • This method takes a keywordToBlock string.
     • It returns a Predicate<ContentItem> lambda.
     • The returned lambda should check if item.getTextContent().toLowerCase().contains(keywordToBlock.toLowerCase()). If it contains the keyword, the rule fails (so the predicate should return false).
   • In CommunityGuardian, use this factory:
     • Predicate<ContentItem> noPoliticsRule = RuleFactory.createKeywordBlockRule("politics");
     • Predicate<ContentItem> noGossipRule = RuleFactory.createKeywordBlockRule("gossip");
     • Add these to your validationRules list.
     • Echo: "This is a higher-order function too – a function that creates and returns another function! This is fantastic for creating configurable, reusable pieces of logic."

// ... (Continuing in CommunityGuardian.java, after ActionDispatcher)

// We can add checkAllRules to RuleEngine or make a more specific class
// Let's refine RuleEngine for this
/*
    (Inside RuleEngine class)
    public static boolean checkAllRules(ContentItem item, List<Predicate<ContentItem>> rules, String overallCheckName) {
        System.out.println("RULE ENGINE: Starting overall check - '" + overallCheckName + "' for " + item.getContentId());
        for (int i = 0; i < rules.size(); i++) {
            Predicate<ContentItem> rule = rules.get(i);
            // To give predicates names, we'd need a List of pairs or a Map, or wrap them.
            // For now, let's assume rule names are handled externally or are less critical for this method.
            System.out.println("RULE ENGINE: Applying sub-rule #" + (i+1) + " of '" + overallCheckName + "'...");
            if (!rule.test(item)) {
                System.out.println("RULE ENGINE: Sub-rule #" + (i+1) + " FAILED. Overall check '" + overallCheckName + "' FAILED for " + item.getContentId());
                return false;
            }
            System.out.println("RULE ENGINE: Sub-rule #" + (i+1) + " PASSED.");
        }
        System.out.println("RULE ENGINE: All sub-rules PASSED. Overall check '" + overallCheckName + "' PASSED for " + item.getContentId());
        return true;
    }
*/
// This RuleEngine.checkAllRules is good but for the main service, we'll iterate to apply actions based on WHICH rule fails.
// So, the main service will manage its own loop for more granular control.

/**
 * Factory for creating common ContentItem validation rules (Predicates).
 */
class RuleFactory {
    /**
     * Creates a Predicate that tests if a ContentItem's text contains a specific forbidden keyword.
     * The rule fails (predicate returns false) if the keyword is found.
     * @param keywordToBlock The keyword that should not be present. Case-insensitive.
     * @return A Predicate<ContentItem> representing the keyword blocking rule.
     */
    public static Predicate<ContentItem> createKeywordBlockRule(String keywordToBlock) {
        Objects.requireNonNull(keywordToBlock, "Keyword to block cannot be null");
        String lowerCaseKeyword = keywordToBlock.toLowerCase();
        // This predicate returns TRUE if the content is VALID (i.e., does NOT contain the keyword)
        return item -> {
            boolean containsKeyword = item.getTextContent().toLowerCase().contains(lowerCaseKeyword);
            if(containsKeyword) {
                System.out.println("   DETAIL: Keyword '" + keywordToBlock + "' FOUND in " + item.getContentId());
            }
            return !containsKeyword; // Rule passes if keyword is NOT found
        };
    }

    /**
     * Creates a Predicate that tests if a ContentItem's text is within a certain length.
     * @param maxLength The maximum allowed length.
     * @return A Predicate<ContentItem> for length validation.
     */
    public static Predicate<ContentItem> createMaxLengthRule(int maxLength) {
        if (maxLength <= 0) throw new IllegalArgumentException("Max length must be positive.");
        // This predicate returns TRUE if the content is VALID (i.e., within length)
        return item -> {
            boolean withinLength = item.getTextContent() != null && item.getTextContent().length() <= maxLength;
            if(!withinLength) {
                 System.out.println("   DETAIL: Content length " + (item.getTextContent() == null ? "N/A" : item.getTextContent().length()) + " EXCEEDS max " + maxLength + " for " + item.getContentId());
            }
            return withinLength;
        };
    }
}

// TODO: Chapter 4 and the main CommunityGuardian class body will be added below.

Tutor's Tip (Echo): "Dev_Lambda, thinking of functions/lambdas as first-class citizens – things you can create, store, pass around, and return – is key to functional programming. The RuleFactory is a prime example; it doesn't just return data, it returns behavior!"

---

Chapter 4: The Full Assembly - ContentModerationService and CommunityGuardian Main

Now, let's bring it all together in a service that orchestrates the moderation process.

Your Tasks (Puzzle 4):

1. Create the ContentModerationService Class:

   • Data Members:
     • private List<Predicate<ContentItem>> validationRules;
     • private List<Function<String, String>> textTransformers;
     • private List<Consumer<ContentItem>> postViolationActions;
     • private Consumer<ContentItem> defaultSuccessAction;
   • Constructor:
     • Initialize these lists (e.g., as empty ArrayLists).
   • Configuration Methods:
     • public void addValidationRule(Predicate<ContentItem> rule)
     • public void addTransformer(Function<String, String> transformer)
     • public void addPostViolationAction(Consumer<ContentItem> action)
     • public void setDefaultSuccessAction(Consumer<ContentItem> action)
   • Core Method: public boolean moderateContent(ContentItem item)
     • Print that moderation is starting for the item.
     • Validation: Iterate through validationRules. If any rule (predicate) returns false:
       • Print which rule failed.
       • Execute all postViolationActions on the item.
       • Return false (moderation failed).
     • If all validation rules pass, print "All validation rules passed."
     • Transformation: Iterate through textTransformers. Apply each transformation to item.setTextContent().
     • Success Action: If defaultSuccessAction is set, execute it on the (potentially transformed) item.
     • Print that moderation completed successfully.
     • Return true.

2. Create the public class CommunityGuardian with the main method:

   • Setup:
     • Create an instance of ContentModerationService.
     • Define various rules, transformers, and actions as lambdas/method references (you've done some already, reuse and add more).
       • Rules (Predicates):
         • nonNullOrEmptyText
         • maxLengthRule = RuleFactory.createMaxLengthRule(100);
         • noPoliticsRule = RuleFactory.createKeywordBlockRule("election");
         • noSpamRule = RuleFactory.createKeywordBlockRule("buy now");
       • Transformers (Functions):
         • toLowerCase = String::toLowerCase;
         • trimWhitespace = String::trim;
         • censorProfanity = text -> text.replaceAll("(?i)darn|shoot|fudge", "****"); (case-insensitive regex)
       • Actions (Consumers):
         • logFlaggedItem = item -> System.out.println("MOD_LOG: [VIOLATION] Item " + item.getContentId() + " by " + item.getAuthorId() + " flagged. Content: '" + item.getTextContent() + "'");
         • escalateToHumanModerator = item -> System.out.println("MOD_ALERT: [ESCALATION] Item " + item.getContentId() + " requires human review!");
         • logApprovedItem = item -> System.out.println("MOD_LOG: [APPROVED] Item " + item.getContentId() + " by " + item.getAuthorId() + " approved. Final Content: '" + item.getTextContent() + "'");
     • Configure the Service: Add your created rules, transformers, and actions to the ContentModerationService instance.
       • service.addValidationRule(nonNullOrEmptyText);
       • service.addValidationRule(maxLengthRule);
       • service.addValidationRule(noPoliticsRule);
       • service.addValidationRule(noSpamRule);
       • service.addTransformer(trimWhitespace);
       • service.addTransformer(censorProfanity);
       • service.addTransformer(toLowerCase);
       • service.addPostViolationAction(logFlaggedItem);
       • service.addPostViolationAction(escalateToHumanModerator);
       • service.setDefaultSuccessAction(logApprovedItem);
   • Test Cases:
     • Create a few ContentItem instances:
       • One that should pass all rules.
       • One that is too long.
       • One that contains a forbidden keyword like "election results".
       • One that contains "buy now".
       • One with profanity that needs censoring.
     • For each ContentItem, call service.moderateContent(item) and print a separator.
   • Demonstrate using a Supplier:
     • Supplier<String> urgentReportHeader = () -> "URGENT MODERATION REPORT - " + LocalDateTime.now().format(DateTimeFormatter.ISO_DATE);
     • Call and print urgentReportHeader.get() if any moderation failed.

// ... (Continuing in CommunityGuardian.java, after RuleFactory)

class ContentModerationService {
    private final List<Predicate<ContentItem>> validationRules;
    private final List<Function<String, String>> textTransformers; // Apply to textContent
    private final List<Consumer<ContentItem>> postViolationActions;
    private Consumer<ContentItem> defaultSuccessAction;

    public ContentModerationService() {
        this.validationRules = new ArrayList<>();
        this.textTransformers = new ArrayList<>();
        this.postViolationActions = new ArrayList<>();
        this.defaultSuccessAction = item -> System.out.println("MOD_LOG: Item " + item.getContentId() + " processed successfully (default action)."); // Default success action
    }

    public void addValidationRule(String ruleName, Predicate<ContentItem> rule) {
        // Wrap the predicate to include its name in printouts for clarity
        this.validationRules.add(item -> {
            boolean result = rule.test(item);
            System.out.println("SERVICE_VALIDATION: Rule '" + ruleName + "' on " + item.getContentId() + (result ? " PASSED." : " FAILED."));
            return result;
        });
    }

    public void addTransformer(String transformerName, Function<String, String> transformer) {
         this.textTransformers.add(currentText -> {
            String transformed = transformer.apply(currentText);
            System.out.println("SERVICE_TRANSFORM: Applied '" + transformerName + "'. Output snippet: '" + transformed.substring(0, Math.min(transformed.length(), 30)) + "...'");
            return transformed;
        });
    }

    public void addPostViolationAction(String actionName, Consumer<ContentItem> action) {
        this.postViolationActions.add(item -> {
            System.out.println("SERVICE_ACTION: Executing violation action '" + actionName + "' for " + item.getContentId());
            action.accept(item);
        });
    }

    public void setDefaultSuccessAction(String actionName, Consumer<ContentItem> action) {
        this.defaultSuccessAction = item -> {
            System.out.println("SERVICE_ACTION: Executing success action '" + actionName + "' for " + item.getContentId());
            action.accept(item);
        };
    }

    public boolean moderateContent(ContentItem item) {
        System.out.println("\n--- Moderating Content: " + item.getContentId() + " ---");
        System.out.println("Original Content: '" + item.getTextContent() + "'");

        // 1. Validation
        for (Predicate<ContentItem> rule : validationRules) {
            if (!rule.test(item)) { // The wrapped predicate already prints its name and status
                // Execute violation actions
                System.out.println("MODERATION_RESULT: Validation failed for " + item.getContentId() + ". Executing violation actions...");
                for (Consumer<ContentItem> action : postViolationActions) {
                    action.accept(item); // The wrapped consumer will print its name
                }
                return false; // Moderation failed
            }
        }
        System.out.println("MODERATION_INFO: All validation rules passed for " + item.getContentId() + ".");

        // 2. Transformation
        String currentText = item.getTextContent();
        for (Function<String, String> transformer : textTransformers) {
            currentText = transformer.apply(currentText); // The wrapped function will print its name
        }
        item.setTextContent(currentText); // Update item with fully transformed text
        System.out.println("MODERATION_INFO: All transformations applied to " + item.getContentId() + ".");

        // 3. Success Action
        if (defaultSuccessAction != null) {
            defaultSuccessAction.accept(item); // The wrapped consumer will print its name
        }

        System.out.println("--- Moderation Complete for: " + item.getContentId() + " ---");
        return true; // Moderation successful
    }
}


public class CommunityGuardian {
    public static void main(String[] args) {
        System.out.println("### JPMC Community Guardian System Initializing ###");
        Echo.greet(); // AI Assistant greeting

        // --- Setup Service ---
        ContentModerationService moderationService = new ContentModerationService();

        // --- Define Rules (Predicates) ---
        System.out.println("\n--- Defining Moderation Logic Modules ---");
        Predicate<ContentItem> nonNullOrEmptyText = item ->
            item.getTextContent() != null && !item.getTextContent().trim().isEmpty();

        Predicate<ContentItem> maxLengthRule = RuleFactory.createMaxLengthRule(100);
        Predicate<ContentItem> noElectionTalkRule = RuleFactory.createKeywordBlockRule("election");
        Predicate<ContentItem> noUrgentSaleRule = RuleFactory.createKeywordBlockRule("buy now fast");
        Predicate<ContentItem> noSpamLinksRule = item ->
            !item.getTextContent().toLowerCase().matches(".*http(s)?://(spammy-link|bad-site)\\.com.*");


        // --- Define Transformers (Functions) ---
        Function<String, String> trimWhitespace = String::trim;
        Function<String, String> censorBadWords = text ->
            text.replaceAll("(?i)darn|heck|dangit", "****"); // case-insensitive
        Function<String, String> convertToSentenceCase = text -> {
            if (text == null || text.isEmpty()) return text;
            // Simple sentence case: uppercase first letter, rest lowercase.
            // More complex logic would be needed for proper nouns etc.
            return text.substring(0, 1).toUpperCase() + text.substring(1).toLowerCase();
        };

        // --- Define Actions (Consumers) ---
        Consumer<ContentItem> logFlaggedItem = item ->
            System.out.println("  ACTION_LOG: [VIOLATION] Item " + item.getContentId() + " by " + item.getAuthorId() + " flagged. Content: '" + item.getTextContent().substring(0, Math.min(item.getTextContent().length(), 50)) + "...'");
        Consumer<ContentItem> escalateToHuman = item ->
            System.out.println("  ACTION_ESCALATE: [HUMAN_REVIEW] Item " + item.getContentId() + " for author " + item.getAuthorId() + " needs manual check!");
        Consumer<ContentItem> logApprovedItem = item ->
            System.out.println("  ACTION_LOG: [APPROVED] Item " + item.getContentId() + ". Final Text: '" + item.getTextContent().substring(0, Math.min(item.getTextContent().length(), 50)) + "...'");


        // --- Configure the Service ---
        System.out.println("\n--- Configuring Content Moderation Service ---");
        moderationService.addValidationRule("Non-Empty Content Check", nonNullOrEmptyText);
        moderationService.addValidationRule("Max Length (100 chars)", maxLengthRule);
        moderationService.addValidationRule("No Election Discussion", noElectionTalkRule);
        moderationService.addValidationRule("No Urgent Sales Pitch", noUrgentSaleRule);
        moderationService.addValidationRule("No Spammy Links", noSpamLinksRule);

        moderationService.addTransformer("Trim Whitespace", trimWhitespace);
        moderationService.addTransformer("Censor Mild Profanity", censorBadWords);
        moderationService.addTransformer("Convert to Sentence Case", convertToSentenceCase);

        moderationService.addPostViolationAction("Log Violation", logFlaggedItem);
        moderationService.addPostViolationAction("Escalate to Human", escalateToHuman);
        moderationService.setDefaultSuccessAction("Log Approval", logApprovedItem);
        System.out.println("--- Service Configuration Complete ---");


        // --- Test Cases ---
        System.out.println("\n--- Running Test Cases Through Moderation Service ---");
        List<ContentItem> testItems = new ArrayList<>();
        testItems.add(new ContentItem("user001", "This is a perfectly fine post about our JPMC community."));
        testItems.add(new ContentItem("user002", "URGENT!! BUY NOW FAST only today special offer for limited time, do not miss this great opportunity for fantastic savings!"));
        testItems.add(new ContentItem("user003", "I think the upcoming company ELECTION results will be interesting. What are your thoughts on the candidates? This is a very long post that will surely exceed the maximum character limit that has been set by the administrators of this platform hoping to keep discussions concise and to the point for everyone's benefit and readability."));
        testItems.add(new ContentItem("user004", "  what a DARN heck of a day!  ")); // Needs trimming and censoring
        testItems.add(new ContentItem("user005", "Check out this cool site: http://spammy-link.com/giveaway"));
        testItems.add(new ContentItem("user006", "")); // Empty content
        testItems.add(new ContentItem("user007", "ANOTHER POST ALL IN CAPS. IS THIS OKAY?")); // Will be sentence cased

        boolean anyModerationFailed = false;
        for (ContentItem item : testItems) {
            boolean result = moderationService.moderateContent(item);
            if (!result) {
                anyModerationFailed = true;
            }
        }

        // --- Demonstrate Supplier ---
        Supplier<String> reportTimestamp = () -> "Moderation Cycle Report generated on: " +
                                               LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("\n--- Moderation Cycle Summary ---");
        if (anyModerationFailed) {
            Supplier<String> urgentHeader = () -> "URGENT ATTENTION REQUIRED: Some content failed moderation.";
            System.out.println(urgentHeader.get()); // Using supplier
        } else {
            System.out.println("All processed items passed moderation or were handled accordingly.");
        }
        System.out.println(reportTimestamp.get()); // Using supplier

        System.out.println("\n### JPMC Community Guardian System Operations Concluded. ###");
        Echo.signOff();
    }
}

/**
 * AI Assistant to provide context and tips.
 */
class Echo {
    public static void greet() {
        System.out.println("\nECHO: Greetings, Dev_Lambda! I am Echo, your AI assistant for this journey into functional Java. Let's make some elegant code!");
    }
    public static void signOff() {
        System.out.println("\nECHO: Excellent work, Dev_Lambda! You've skillfully wielded functional interfaces and lambdas. This modular approach is highly valued in enterprise development. Keep practicing!");
    }
    // You can add more Echo.explain("topic") methods and call them throughout the main logic if you want more inline guidance.
}

Self-Correction/Refinement for ContentModerationService:
To make the output clearer about which rule/transformer/action is being applied from the service, I've modified the addValidationRule, addTransformer, and action methods in ContentModerationService to take a name parameter. Then, the lambda that's actually stored in the list becomes a wrapper lambda that first prints this name and then executes the original logic. This makes the logs much more informative.

---

Epilogue: Ms. Verity's Review

Ms. Verity: "Dev_Lambda, I've reviewed the prototype. The flexibility is remarkable! Being able to define new rules, transformations, and actions as simple lambda expressions and plug them into the service is exactly the kind of modern, agile system we need. The way you've used these functional interfaces as parameters and in collections is a testament to their power for creating decoupled and extensible components. This CommunityGuardian sets a new standard."

Echo's Final Tip: "Remember, Dev_Lambda: use custom functional interfaces when you need domain-specific naming or a very unique method signature. For common patterns like tests (Predicates), transformations (Functions), actions (Consumers), or value generation (Suppliers), the standard java.util.function interfaces are generally preferred for better interoperability and familiarity. You've used both effectively here!"

---

Your Deliverable:
The fully implemented CommunityGuardian.java file. When run, it should demonstrate the entire moderation flow for the various test cases, showing rules being applied, content being transformed, and actions being taken, with clear console output indicating each step.