/*
 * Problem Statement: Without Generics, collections store Objects.
 * This leads to manual casting and potential ClassCastExceptions at runtime.
 */
// Example 1: Without Generics (Raw Type) - Demonstrates runtime error
import java.util.ArrayList;
import java.util.List;

public class RawTypeExample {
    public static void main(String[] args) {
        List items = new ArrayList(); // Raw type - compiler warning
        items.add("Hello");
        items.add(123); // Adding an Integer to a list intended for Strings

        for (Object item : items) {
            try {
                String s = (String) item; // Potential ClassCastException
                System.out.println("Processed String: " + s);
            } catch (ClassCastException e) {
                System.err.println("Runtime Error: " + e.getMessage());
                // Output: Runtime Error: java.lang.Integer cannot be cast to java.lang.String
            }
        }
    }
}

/*
 * Solution: Introduce Generics for compile-time type safety.
 * Define a generic class (e.g., Box<T>) to hold objects of a specific type.
 */
// Example 2: With Generics - Eliminates runtime errors by enforcing type at compile time
// Define a simple generic class
class Box<T> {
    private T content;

    public Box(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }
}

public class GenericBoxExample {
    public static void main(String[] args) {
        // Create a Box specifically for Strings
        Box<String> stringBox = new Box<>("Java Generics");
        System.out.println("String Box Content: " + stringBox.getContent());
        // stringBox.setContent(123); // Compile-time error: Incompatible types

        // Create a Box specifically for Integers
        Box<Integer> integerBox = new Box<>(42);
        System.out.println("Integer Box Content: " + integerBox.getContent());

        // Demonstrate generic List
        List<String> stringList = new ArrayList<>();
        stringList.add("First");
        stringList.add("Second");
        // stringList.add(100); // Compile-time error: Incompatible types

        System.out.println("Generic String List:");
        for (String s : stringList) {
            System.out.println(s);
        }
    }
}

/*
 * Generic Classes: Define a class with one or more type parameters.
 * The type parameter acts as a placeholder for the actual type determined at instantiation.
 */
// Example 1: Bounded Generic Class - Restricting type parameters
// Only allows types that extend Number (e.g., Integer, Double, Float)
class NumericBox<N extends Number> {
    private N number;

    public NumericBox(N number) {
        this.number = number;
    }

    public double doubleValue() {
        return number.doubleValue();
    }

    // Generic method within a generic class - not strictly necessary here, but shows concept
    public <U extends Number> boolean isSameType(NumericBox<U> otherBox) {
        return this.number.getClass().equals(otherBox.number.getClass());
    }
}

/*
 * Generic Methods: Methods that introduce their own type parameters.
 * They can be static or non-static and belong to either generic or non-generic classes.
 */
// Example 2: Generic Utility Method - Operates on a List of any type T
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class GenericUtilityMethods {

    // A generic method to print elements of any List<T>
    public static <T> void printList(List<T> list) {
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
            if (i < list.size() - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }

    // A generic method to find the maximum element in a list of comparable items
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list == null || list.isEmpty()) {
            return null; // Or throw an IllegalArgumentException
        }
        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        // Demonstrate NumericBox
        NumericBox<Integer> intBox = new NumericBox<>(10);
        NumericBox<Double> doubleBox = new NumericBox<>(15.5);
        System.out.println("Integer Box doubleValue: " + intBox.doubleValue());
        System.out.println("Double Box doubleValue: " + doubleBox.doubleValue());
        System.out.println("Are intBox and doubleBox of the same type? " + intBox.isSameType(doubleBox)); // false

        // Demonstrate generic printList method
        List<String> words = List.of("apple", "banana", "cherry");
        System.out.print("Words: ");
        printList(words);

        List<Integer> numbers = List.of(5, 2, 8, 1);
        System.out.print("Numbers: ");
        printList(numbers);

        // Demonstrate findMax method
        System.out.println("Max number: " + findMax(numbers)); // 8
        List<String> fruits = List.of("mango", "grape", "kiwi");
        System.out.println("Max fruit (alphabetical): " + findMax(fruits)); // mango
    }
}

/*
 * Wildcards provide flexibility in type definitions, especially when dealing with collections.
 * Three types: Unbounded (?), Upper Bounded (? extends T), Lower Bounded (? super T).
 * The PECS principle (Producer Extends, Consumer Super) guides their effective use.
 */
import java.util.ArrayList;
import java.util.List;
import java.util.Collection;

public class WildcardExamples {

    // 1. Unbounded Wildcard: List<?> - Can hold a list of any type, but cannot add elements
    // Use when the specific type doesn't matter, or when reading elements as Object.
    public static void printElements(List<?> list) {
        for (Object elem : list) {
            System.out.println("Element: " + elem);
        }
        // list.add(new Object()); // Compile-time error: cannot add to List<?>
    }

    // 2. Upper Bounded Wildcard: List<? extends Number> - Producer Extends
    // Can read elements as Number or its subclasses. Can't add elements (except null).
    // Use when the list is a 'producer' of T or its subtypes.
    public static double sumOfList(List<? extends Number> list) {
        double sum = 0.0;
        for (Number n : list) { // We can safely read Numbers
            sum += n.doubleValue();
        }
        // list.add(new Integer(1)); // Compile-time error: cannot add to ? extends Number
        return sum;
    }

    // 3. Lower Bounded Wildcard: List<? super Integer> - Consumer Super
    // Can add Integer or its supertypes (Number, Object). Can only read elements as Object.
    // Use when the list is a 'consumer' of T or its supertypes.
    public static void addIntegers(List<? super Integer> list) {
        list.add(10); // OK: Integer is a subtype of Integer
        list.add(20); // OK
        // Integer i = list.get(0); // Compile-time error: Cannot cast Object to Integer directly
        Object o = list.get(0); // Only safe to read as Object
        System.out.println("First element (as Object): " + o);
    }

    // 4. PECS Principle in Action: Copying from producer to consumer
    // Source is a producer of T (or subtypes), Destination is a consumer of T (or supertypes)
    public static <T> void copy(List<? extends T> src, List<? super T> dest) {
        for (T element : src) {
            dest.add(element);
        }
    }

    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(1); intList.add(2); intList.add(3);
        System.out.println("--- printElements with Integer List ---");
        printElements(intList);

        List<Double> doubleList = new ArrayList<>();
        doubleList.add(10.5); doubleList.add(20.5);
        System.out.println("--- printElements with Double List ---");
        printElements(doubleList);

        System.out.println("--- sumOfList with Integer List ---");
        System.out.println("Sum of integers: " + sumOfList(intList));
        System.out.println("--- sumOfList with Double List ---");
        System.out.println("Sum of doubles: " + sumOfList(doubleList));

        System.out.println("--- addIntegers with List<Number> ---");
        List<Number> numberList = new ArrayList<>();
        addIntegers(numberList);
        System.out.println("Number list after adding integers: ");
        printElements(numberList); // Output: [10, 20]

        System.out.println("--- PECS Copy Example ---");
        List<Number> sourceNumbers = new ArrayList<>();
        sourceNumbers.add(5); sourceNumbers.add(3.14); sourceNumbers.add(Long.valueOf(100));
        List<Object> destinationObjects = new ArrayList<>();

        copy(sourceNumbers, destinationObjects);
        System.out.print("Copied numbers to objects: ");
        printElements(destinationObjects);

        List<Integer> producerInts = new ArrayList<>();
        producerInts.add(100); producerInts.add(200);
        List<Number> consumerNumbers = new ArrayList<>();
        copy(producerInts, consumerNumbers);
        System.out.print("Copied integers to numbers: ");
        printElements(consumerNumbers);
    }
}

/*
 * Type Erasure is a core concept in Java Generics.
 * Generics information is removed during compilation, meaning runtime has no knowledge of actual type parameters.
 * This impacts operations like instanceof and array creation.
 */
import java.util.ArrayList;
import java.util.List;

public class TypeErasureAndBestPractices {

    // Demonstrates Type Erasure: Cannot use instanceof with generic types
    public static void demonstrateErasure() {
        List<String> stringList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();

        // The following will not compile: "Cannot perform instanceof check against parameterized type List<String>.
        // Use its raw form List instead since generic type information is erased at runtime."
        // if (stringList instanceof List<String>) {
        //    System.out.println("stringList is a List<String>");
        // }

        // We can only check against the raw type:
        if (stringList instanceof List) {
            System.out.println("stringList is a raw List (due to type erasure).");
        }

        // Similarly, cannot create arrays of generic types directly
        // T[] arr = new T[10]; // Compile-time error
        // List<String>[] arrayOfLists = new ArrayList<String>[10]; // Compile-time error

        System.out.println("stringList.getClass() == integerList.getClass() is: " + (stringList.getClass() == integerList.getClass()));
        // This prints true because both are java.util.ArrayList at runtime.
    }

    // Best Practice: Avoid Raw Types
    public static void processListSafely(List<String> list) {
        // list.add(123); // Compile-time error, good!
        for (String s : list) {
            System.out.println("Safe element: " + s);
        }
    }

    // Best Practice: Use Diamond Operator for conciseness and safety (Java 7+)
    public static void useDiamondOperator() {
        List<String> names = new ArrayList<>(); // No need to repeat <String>
        names.add("Alice");
        names.add("Bob");
        System.out.println("Names using diamond operator: " + names);
    }

    // Common Error: Returning generic array (not possible directly)
    // public static <T> T[] createGenericArray(int size) {
    //    return new T[size]; // Compile-time error
    // }

    public static void main(String[] args) {
        System.out.println("--- Demonstrating Type Erasure ---");
        demonstrateErasure();

        System.out.println("\n--- Best Practice: Avoiding Raw Types ---");
        List<String> safeList = new ArrayList<>();
        safeList.add("Item A");
        safeList.add("Item B");
        processListSafely(safeList);

        // processListSafely(new ArrayList()); // Compiler warning for raw type, potential runtime error

        System.out.println("\n--- Best Practice: Using Diamond Operator ---");
        useDiamondOperator();

        System.out.println("\n--- Other Best Practices ---");
        System.out.println("Favor Generic Methods for single-method utilities.");
        System.out.println("Design generic types for immutability where applicable for thread safety.");
    }
}