/*
 * File: LambdaModificationAttempt.java
 * Description: Demonstrates the compile-time error when a lambda tries to modify a local variable.
 */
public class LambdaModificationAttempt {

    public static void main(String[] args) {
        int counter = 0; // A local variable

        // Attempting to modify 'counter' inside a lambda will result in a compile-time error.
        // Uncomment the following lines to see the error:
        /*
        Runnable incrementer = () -> {
            // Compile-time Error: Local variable counter defined in an enclosing scope
            // must be final or effectively final
            counter++;
            System.out.println("Inside lambda: " + counter);
        };
        incrementer.run();
        */

        System.out.println("Outside lambda: " + counter);

        // For comparison, a final or effectively final variable can be captured:
        final int finalCounter = 10; // Explicitly final
        Runnable printer1 = () -> {
            System.out.println("Lambda capturing finalCounter: " + finalCounter);
        };
        printer1.run();

        int effectivelyFinalCounter = 20; // Effectively final (not modified after initialization)
        Runnable printer2 = () -> {
            System.out.println("Lambda capturing effectivelyFinalCounter: " + effectivelyFinalCounter);
        };
        printer2.run();

        System.out.println("Program finished.");
    }
}

/*
 * File: EffectivelyFinalDemo.java
 * Description: Illustrates valid and invalid uses of effectively final variables within lambdas.
 */
public class EffectivelyFinalDemo {

    public static void main(String[] args) {

        // Case 1: Explicitly final variable (always allowed)
        final String message = "Hello, Java!";
        Runnable task1 = () -> {
            System.out.println("Task 1: " + message); // Captures 'message'
        };
        task1.run();

        // Case 2: Effectively final variable (not explicitly final, but not modified after initialization)
        int count = 100;
        // 'count' is effectively final because it's initialized once and never assigned a new value.
        Runnable task2 = () -> {
            System.out.println("Task 2: Count is " + count); // Captures 'count'
        };
        task2.run();

        // Case 3: Variable that is NOT effectively final (modified after initialization)
        String status = "Pending";
        // If we try to define a lambda here that captures 'status' and then modify 'status',
        // it would be fine IF the lambda was used BEFORE modification.
        // However, if the lambda definition is after the modification, or if we try to modify AFTER the lambda, it breaks 'effectively final'.

        // Example of breaking effectively final:
        //Runnable badTask = () -> {
        //    System.out.println("Bad Task: " + status); // This line is fine on its own if status is not modified later in this scope.
        //};
        status = "Completed"; // This line makes 'status' NOT effectively final from this point onwards for any *new* lambda definition.

        // If we try to define a lambda *after* 'status' is modified, and use it, it still relies on the 'effectively final' rule for its scope of definition.
        // The rule applies to the variable at the point of its capture.
        // Let's demonstrate the compiler error:
        int value = 5;
        Runnable goodTask = () -> {
            System.out.println("Good Task: Value = " + value);
        };
        // value = 6; // Uncommenting this line would make 'value' NOT effectively final and 'goodTask' would fail to compile.
        goodTask.run();


        // Case 4: Effectively final with object reference (the reference is final, but the object's state can be changed)
        StringBuilder builder = new StringBuilder("Initial");
        Runnable task3 = () -> {
            // The 'builder' reference is effectively final, but the object it points to can be mutated.
            builder.append(" Appended");
            System.out.println("Task 3: " + builder.toString());
        };
        task3.run();
        System.out.println("After Task 3: " + builder.toString()); // Shows the change made by the lambda

        System.out.println("Program finished.");
    }
}

/*
 * File: LambdaScopeLifetime.java
 * Description: Illustrates how lambdas capture values, ensuring consistency even when original scope ends.
 */
public class LambdaScopeLifetime {

    // Method to demonstrate lambda capturing a local variable from an outer scope
    public static Runnable createGreeter(String name) {
        int greetingCount = 1; // Effectively final local variable

        // The lambda captures the 'name' and 'greetingCount' at the point of its definition.
        // Even after createGreeter() returns, the lambda holds these captured values.
        Runnable greeter = () -> {
            System.out.println("Hello, " + name + "! (Count: " + greetingCount + ")");
            // greetingCount++; // This would be a compile-time error as 'greetingCount' must be effectively final
        };

        System.out.println("createGreeter() is about to return. greetingCount is " + greetingCount);
        return greeter; // The lambda instance is returned, outliving its defining method's stack frame.
    }

    public static void main(String[] args) {
        System.out.println("Main method started.");

        // Call createGreeter to get a Runnable instance.
        // The 'name' and 'greetingCount' variables from createGreeter's scope are now 'captured' by the returned lambda.
        Runnable myGreeter = createGreeter("Developer");

        System.out.println("Back in main method. Executing the greeter.");
        myGreeter.run(); // Execute the lambda. It still has access to the captured values.

        // Demonstrate multiple calls to createGreeter produce lambdas with independent captures
        Runnable anotherGreeter = createGreeter("Explorer");
        anotherGreeter.run();

        System.out.println("Program finished.");
    }
}

/*
 * File: MutableStateStrategies.java
 * Description: Demonstrates various safe ways to handle mutable state within or alongside lambdas.
 */
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.IntStream;

public class MutableStateStrategies {

    // Custom mutable object for demonstration
    static class MutableCounter {
        private int value = 0;

        public void increment() {
            value++;
        }

        public int getValue() {
            return value;
        }
    }

    public static void main(String[] args) {
        System.out.println("--- Using AtomicInteger for shared mutable state ---");
        AtomicInteger atomicCount = new AtomicInteger(0);
        IntStream.range(0, 5).forEach(i -> {
            // Lambda modifies the *state* of the AtomicInteger object, not the 'atomicCount' reference itself.
            atomicCount.incrementAndGet();
            System.out.println("Lambda " + i + ": Atomic Count = " + atomicCount.get());
        });
        System.out.println("Final Atomic Count: " + atomicCount.get());

        System.out.println("\n--- Using AtomicReference for a mutable object ---");
        AtomicReference<String> sharedString = new AtomicReference<>("Initial");
        Runnable stringModifier = () -> {
            String current = sharedString.get();
            String updated = current + "_Modified";
            sharedString.set(updated);
            System.out.println("Lambda modified string: " + sharedString.get());
        };
        stringModifier.run();
        System.out.println("Final Shared String: " + sharedString.get());

        System.out.println("\n--- Modifying fields of a custom mutable object ---");
        MutableCounter counter = new MutableCounter(); // 'counter' reference is effectively final
        Runnable counterIncrementer = () -> {
            counter.increment(); // Modifies the object's internal state
            System.out.println("Lambda incremented custom counter: " + counter.getValue());
        };
        counterIncrementer.run();
        counterIncrementer.run(); // Run again to show further modification
        System.out.println("Final Custom Counter: " + counter.getValue());

        System.out.println("\n--- Using instance/static variables (with caution) ---");
        // For simple, non-concurrent scenarios, instance/static variables can be modified.
        // However, this approach often breaks functional purity and can lead to thread-safety issues in concurrent contexts.
        // Not recommended for general functional programming unless specifically designed for stateful processing.
        // (Example not provided as it's often an anti-pattern for pure functional style within lambdas)

        System.out.println("Program finished.");
    }
}