Generics & Type Safety — Classes, Methods & Wildcards (జెనరిక్స్ & టైప్ సేఫ్టీ ఆర్కిటెక్చర్)

import java.util.*;

public class GenericClassAndMethodShowcase {

    // 1. Generic API Response Wrapper Class (ఏ డేటా పేలోడ్‌నైనా మోయగలదు)
    public static class ApiResponse<T> {
        private final int statusCode;
        private final String message;
        private final T payload;

        public ApiResponse(int statusCode, String message, T payload) {
            this.statusCode = statusCode;
            this.message = message;
            this.payload = payload;
        }

        public int getStatusCode() { return statusCode; }
        public String getMessage() { return message; }
        public T getPayload() { return payload; }

        @Override
        public String toString() {
            return "ApiResponse [code=" + statusCode + ", msg=" + message + ", data=" + payload + "]";
        }
    }

    // 2. Generic Method: ఏ రకమైన లిస్ట్‌నైనా ఒకే విధంగా ప్రింట్ చేసే యుటిలిటీ
    public static <E> void printListDetails(String label, List<E> list) {
        System.out.println("🔹 " + label + " (Size: " + list.size() + "):");
        for (E item : list) {
            System.out.println("   -> Item: " + item + " [Type: " + item.getClass().getSimpleName() + "]");
        }
    }

    // 3. Generic Method: రెండు ఆబ్జెక్టులలో ఏది పెద్దదో పోల్చే మెథడ్ (Bounded to Comparable)
    public static <T extends Comparable<T>> T findMax(T a, T b) {
        return a.compareTo(b) >= 0 ? a : b;
    }

    public static void main(String[] args) {
        System.out.println("=== 1. GENERIC API RESPONSE TEST ===");
        
        // String పేలోడ్‌తో ApiResponse
        ApiResponse<String> authResponse = new ApiResponse<>(200, "Success", "JWT_TOKEN_ABC123");
        System.out.println(authResponse);
        String token = authResponse.getPayload(); // ఎటువంటి టైప్ క్యాస్టింగ్ అవసరం లేదు!
        System.out.println("Extracted Token: " + token);

        // List పేలోడ్‌తో ApiResponse
        List<Integer> portNumbers = List.of(8080, 8443, 9092);
        ApiResponse<List<Integer>> portsResponse = new ApiResponse<>(200, "Port List", portNumbers);
        System.out.println("Configured Ports: " + portsResponse.getPayload());

        System.out.println("
=== 2. GENERIC METHOD UTILITY ===");
        List<String> devTeams = List.of("Backend", "Frontend", "DevOps");
        List<Double> latencies = List.of(12.4, 45.1, 8.9);
        printListDetails("Engineering Teams", devTeams);
        printListDetails("Server Latencies (ms)", latencies);

        System.out.println("
=== 3. BOUNDED GENERIC METHOD (MAX FINDER) ===");
        System.out.println("Max of (150, 420): " + findMax(150, 420));
        System.out.println("Max of ('Zebra', 'Apple'): " + findMax("Zebra", "Apple"));
    }
}

import java.util.*;

public class PecsWildcardInventoryProcessor {

    // డొమైన్ మోడల్స్: హైరార్కీ
    static class Device {
        final String model;
        final double price;
        public Device(String model, double price) { this.model = model; this.price = price; }
        public double getPrice() { return price; }
        @Override public String toString() { return model + " (₹" + price + ")"; }
    }

    static class Smartphone extends Device {
        final String os;
        public Smartphone(String model, double price, String os) {
            super(model, price);
            this.os = os;
        }
    }

    static class Laptop extends Device {
        final int ramGb;
        public Laptop(String model, double price, int ramGb) {
            super(model, price);
            this.ramGb = ramGb;
        }
    }

    // 1. PRODUCER EXTENDS (? extends Device): కేవలం రీడ్ చేయడానికి మాత్రమే (Calculates total value)
    public static double calculateTotalInventoryValue(List<? extends Device> inventory) {
        double total = 0.0;
        for (Device d : inventory) {
            total += d.getPrice(); // సురక్షితంగా Device గా రీడ్ చేయవచ్చు!
        }
        // inventory.add(new Device("Watch", 5000)); // కంపైలర్ ఒప్పుకోదు! (Producer cannot add)
        return total;
    }

    // 2. CONSUMER SUPER (? super Smartphone): కొత్త స్మార్ట్‌ఫోన్లను లిస్ట్‌లోకి జోడించడానికి
    public static void restockSmartphones(List<? super Smartphone> stockList, List<Smartphone> newArrivals) {
        for (Smartphone phone : newArrivals) {
            stockList.add(phone); // సురక్షితంగా Smartphone ని జోడించవచ్చు!
            System.out.println("  + ఇన్వెంటరీలోకి చేర్చబడింది: " + phone);
        }
    }

    public static void main(String[] args) {
        System.out.println("=== 1. PRODUCER EXTENDS TEST (? extends Device) ===");
        List<Smartphone> phones = List.of(
            new Smartphone("Pixel 8 Pro", 85000, "Android"),
            new Smartphone("iPhone 15", 79000, "iOS")
        );
        List<Laptop> laptops = List.of(
            new Laptop("MacBook Pro M3", 195000, 36),
            new Laptop("Dell XPS 15", 145000, 32)
        );

        // List మరియు List రెండింటినీ ఒకే మెథడ్‌లోకి పంపగలిగాం!
        double phoneTotal = calculateTotalInventoryValue(phones);
        double laptopTotal = calculateTotalInventoryValue(laptops);
        System.out.println("స్మార్ట్‌ఫోన్ల మొత్తం విలువ: ₹" + phoneTotal);
        System.out.println("ల్యాప్‌టాప్‌ల మొత్తం విలువ: ₹" + laptopTotal);

        System.out.println("
=== 2. CONSUMER SUPER TEST (? super Smartphone) ===");
        // సూపర్ టైప్ అయిన List లోకి Smartphone లను రెస్పాన్సిబుల్‌గా యాడ్ చేస్తున్నాం
        List<Device> generalWarehouse = new ArrayList<>();
        generalWarehouse.add(new Laptop("ThinkPad T14", 95000, 16));

        System.out.println("ప్రారంభ వేర్‌హౌస్ నిల్వ: " + generalWarehouse);
        System.out.println("కొత్త స్మార్ట్‌ఫోన్ల స్టాక్ లోడింగ్...");
        restockSmartphones(generalWarehouse, phones);

        System.out.println("అప్‌డేట్ చేయబడిన వేర్‌హౌస్ మొత్తం నిల్వలు (Size: " + generalWarehouse.size() + "):");
        for (Device d : generalWarehouse) {
            System.out.println("  - " + d);
        }
    }
}

import java.util.*;
import java.util.function.Predicate;

public class EnterpriseGenericRepositoryEngine {

    // ప్రతి ఎంటిటీ తప్పనిసరిగా ఐడీని కలిగి ఉండాలని నిర్దేశించే ఇంటర్‌ఫేస్
    public interface Identifiable<ID> {
        ID getId();
    }

    // జెనరిక్ CRUD రిపోజిటరీ ఇంటర్‌ఫేస్
    public interface CrudRepository<T extends Identifiable<ID>, ID> {
        T save(T entity);
        Optional<T> findById(ID id);
        List<T> findAll();
        List<T> findByCriteria(Predicate<T> predicate);
        boolean deleteById(ID id);
        long count();
    }

    // జెనరిక్ ఇన్-మెమరీ ఇంప్లిమెంటేషన్ (ఏ ఎంటిటీకైనా సమానంగా పనిచేస్తుంది)
    public static class InMemoryRepository<T extends Identifiable<ID>, ID> implements CrudRepository<T, ID> {
        private final Map<ID, T> storage = new HashMap<>();

        @Override
        public T save(T entity) {
            Objects.requireNonNull(entity, "సేవ్ చేయాల్సిన ఎంటిటీ null కాకూడదు");
            storage.put(entity.getId(), entity);
            return entity;
        }

        @Override
        public Optional<T> findById(ID id) {
            return Optional.ofNullable(storage.get(id));
        }

        @Override
        public List<T> findAll() {
            return new ArrayList<>(storage.values());
        }

        @Override
        public List<T> findByCriteria(Predicate<T> predicate) {
            List<T> results = new ArrayList<>();
            for (T item : storage.values()) {
                if (predicate.test(item)) {
                    results.add(item);
                }
            }
            return results;
        }

        @Override
        public boolean deleteById(ID id) {
            return storage.remove(id) != null;
        }

        @Override
        public long count() {
            return storage.size();
        }
    }

    // డొమైన్ మోడల్ 1: Customer Record (Java 21)
    public record Customer(Long id, String name, String tier, double balance) implements Identifiable<Long> {
        @Override public Long getId() { return id; }
    }

    // డొమైన్ మోడల్ 2: Order Record (Java 21)
    public record Order(String orderNumber, double amount, String status) implements Identifiable<String> {
        @Override public String getId() { return orderNumber; }
    }

    public static void main(String[] args) {
        System.out.println("=== ENTERPRISE GENERIC REPOSITORY ENGINE ===");

        // 1. కస్టమర్ రిపోజిటరీ (ID టైప్: Long)
        CrudRepository<Customer, Long> customerRepo = new InMemoryRepository<>();
        customerRepo.save(new Customer(101L, "Balaji Tech", "PLATINUM", 85000.0));
        customerRepo.save(new Customer(102L, "Anand Kumar", "GOLD", 32000.0));
        customerRepo.save(new Customer(103L, "Kavitha Reddy", "PLATINUM", 120000.0));

        System.out.println("మొత్తం కస్టమర్ల సంఖ్య: " + customerRepo.count());
        
        // Predicate ఫిల్టర్ ద్వారా ప్లాటినమ్ కస్టమర్ల శోధన
        List<Customer> platinumMembers = customerRepo.findByCriteria(c -> "PLATINUM".equals(c.tier()));
        System.out.println("ప్లాటినమ్ కస్టమర్లు: " + platinumMembers);

        // 2. ఆర్డర్ రిపోజిటరీ (ID టైప్: String) - అదే ఇంజిన్ వేరొక టైప్‌కు క్లీన్‌గా పనిచేస్తుంది!
        CrudRepository<Order, String> orderRepo = new InMemoryRepository<>();
        orderRepo.save(new Order("ORD-2026-X1", 15400.0, "PAID"));
        orderRepo.save(new Order("ORD-2026-X2", 4500.0, "PENDING"));

        System.out.println("
ఆర్డర్ శోధన (ORD-2026-X1):");
        orderRepo.findById("ORD-2026-X1").ifPresent(o -> 
            System.out.println("  లభించిన ఆర్డర్ వివరాలు: " + o + " | మొత్తం: ₹" + o.amount())
        );

        // ఆర్డర్ డిలీషన్
        orderRepo.deleteById("ORD-2026-X2");
        System.out.println("ఆర్డర్ తొలగింపు తర్వాత మిగిలిన ఆర్డర్లు: " + orderRepo.count());
    }
}