/*
 * Example 1: A simple lambda expression implementing a functional interface.
 * This code demonstrates the surface-level simplicity of lambdas.
 */

// 1. Define a functional interface
@FunctionalInterface
interface Greeter {
    String greet(String name);
}

public class LambdaExample {
    public static void main(String[] args) {
        // 2. Implement the functional interface using a lambda expression
        Greeter helloGreeter = name -> "Hello, " + name + "!";

        // 3. Execute the lambda
        System.out.println(helloGreeter.greet("World"));

        // 4. Another lambda example, demonstrating an implicit type (Runnable)
        Runnable task = () -> System.out.println("This is a runnable task.");
        new Thread(task).start();
    }
}

/*
 * Example 2: Conceptual understanding of 'invokedynamic' in bytecode.
 * This is a high-level representation, as actual bytecode is not directly written in Java.
 * When a lambda is compiled, the compiler inserts an 'invokedynamic' instruction.
 */

public class InvokedynamicConcept {
    public static void main(String[] args) {
        // The following lambda would compile to an invokedynamic instruction.
        // We cannot directly write 'invokedynamic' in Java source.
        // The compiler transforms 's -> System.out.println(s)' into a bytecode instruction.
        MyConsumer consumer = s -> System.out.println("Consumed: " + s);
        consumer.accept("data");
    }
}

@FunctionalInterface
interface MyConsumer {
    void accept(String s);
}

/*
 * Conceptual Bytecode Snippet (Illustrative of what the compiler generates):
 * -----------------------------------------------------------------------
 * ALOAD 0
 * LDC "data"
 * INVOKEDYNAMIC accept(Ljava/lang/String;)V [  // The invokedynamic instruction
 *     // Bootstrap method: LambdaMetafactory.metafactory(...)
 *     // Method type:      (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)
 *     //                   Ljava/lang/invoke/CallSite; // Return type of the bootstrap method
 *     // Arguments to bootstrap method: (Ljava/lang/invoke/MethodType; Ljava/lang/invoke/MethodHandle; Ljava/lang/invoke/MethodType;)
 *     //     SAM method type:    (Ljava/lang/Object;)V
 *     //     Lambda body method handle: MethodHandle to 'lambda$0'
 *     //     Runtime method type: (Ljava/lang/String;)V
 * ]
 * 
 * - The invokedynamic instruction does not directly invoke a method.
 * - It delegates to a 'bootstrap method' (specified in its operands) at runtime.
 * - For lambdas, this bootstrap method is typically 'LambdaMetafactory.metafactory'.
 * - The bootstrap method dynamically generates the lambda's functional interface implementation.
 * -----------------------------------------------------------------------
 */

/*
 * Example 3: Lambda with captured variables and its conceptual translation.
 * The compiler generates a synthetic method to hold the lambda's body
 * and handles the capture of 'final' or 'effectively final' variables.
 */

import java.util.function.IntConsumer;

public class LambdaCaptureExample {
    private static int staticCounter = 0; // A static variable

    public static void main(String[] args) {
        int localFactor = 10; // An effectively final local variable

        // Lambda capturing both a local variable and a static field
        IntConsumer multiplier = value -> {
            // Accessing effectively final localFactor
            int result = value * localFactor;

            // Accessing staticCounter
            staticCounter += result;

            System.out.println("Processed: " + value + ", Result: " + result + ", Static Counter: " + staticCounter);
        };

        multiplier.accept(5);
        multiplier.accept(7);

        // Demonstrate non-capturing lambda (can be translated to a static method)
        Runnable simpleRunnable = () -> System.out.println("Simple non-capturing runnable.");
        simpleRunnable.run();
    }

    /*
     * Conceptual Synthetic Methods generated by the compiler (not explicitly written):
     * ------------------------------------------------------------------------------
     * // For 'multiplier' lambda, if it captures 'localFactor'
     * private static void lambda$0(int localFactor, int value) {
     *     int result = value * localFactor;
     *     staticCounter += result;
     *     System.out.println("Processed: " + value + ", Result: " + result + ", Static Counter: " + staticCounter);
     * }
     *
     * // For 'simpleRunnable' lambda (non-capturing, can be static)
     * private static void lambda$1() {
     *     System.out.println("Simple non-capturing runnable.");
     * }
     * ------------------------------------------------------------------------------
     *
     * The LambdaMetafactory.metafactory bootstrap method receives information about:
     * 1. The functional interface (e.g., IntConsumer).
     * 2. The method signature of the lambda (e.g., (int)void).
     * 3. A MethodHandle pointing to the actual implementation method (e.g., lambda$0 or lambda$1).
     * 4. Any captured variables (like 'localFactor') are passed as arguments to the generated method
     *    or as constructor arguments to the dynamically created class.
     */
}

/*
 * Example 4: Demonstrating method references vs. lambdas for clarity and potential optimization.
 * Method references are often more concise and sometimes allow for further JVM optimizations.
 */

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaPerformanceExample {

    public static void printItem(String item) {
        System.out.println("Item: " + item);
    }

    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 1. Using a lambda expression for iteration
        System.out.println("\n--- Using Lambda for forEach ---");
        names.forEach(name -> System.out.println("Hello, " + name));

        // 2. Using a method reference for iteration (often preferred for clarity and optimization)
        System.out.println("\n--- Using Method Reference for forEach ---");
        names.forEach(LambdaPerformanceExample::printItem);

        // 3. Lambda for mapping, capturing a local variable
        String prefix = "USER_"; // Effectively final
        List<String> prefixedNames = names.stream()
                                          .map(name -> prefix + name.toUpperCase())
                                          .collect(Collectors.toList());
        System.out.println("\nPrefixed Names: " + prefixedNames);

        // Best Practice: Avoid capturing large objects if the lambda is long-lived
        // Bad practice example (conceptually):
        // List<byte[]> largeData = createVeryLargeDataList();
        // LongTermTask task = () -> processLargeData(largeData); // 'largeData' is captured and kept alive
        // new Thread(task).start();

        System.out.println("\n--- Performance Considerations ---");
        System.out.println("Non-capturing lambdas can be instantiated once and reused.");
        System.out.println("Method references often translate to static methods, reducing runtime overhead.");
        System.out.println("Avoid excessive capture of mutable objects, especially in long-lived lambdas, to prevent memory leaks.");
    }

    private static List<byte[]> createVeryLargeDataList() {
        // Dummy method to illustrate concept of large data capture
        return List.of(new byte[10 * 1024 * 1024]); // 10MB byte array
    }
}