Java Interface

// The interface defines WHAT a class must do
public interface Drawable {
    void draw();       // Every Drawable must know how to draw itself
    double area();     // Every Drawable must know its area
}

// Circle implements the Drawable contract -- it defines HOW
public class Circle implements Drawable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// Rectangle also implements Drawable -- with its own HOW
public class Rectangle implements Drawable {
    private double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle " + width + "x" + height);
    }

    @Override
    public double area() {
        return width * height;
    }
}

// Usage -- code depends on the interface, not the implementation
public class Main {
    public static void main(String[] args) {
        Drawable shape1 = new Circle(5.0);
        Drawable shape2 = new Rectangle(4.0, 6.0);

        shape1.draw();  // Drawing a circle with radius 5.0
        shape2.draw();  // Drawing a rectangle 4.0x6.0

        System.out.println("Circle area: " + shape1.area());    // 78.539...
        System.out.println("Rectangle area: " + shape2.area()); // 24.0
    }
}

// BAD -- tightly coupled to a specific implementation
public class OrderService {
    private MySqlOrderRepository repository = new MySqlOrderRepository();

    public void placeOrder(Order order) {
        repository.save(order); // What if we switch to PostgreSQL? We must change this class.
    }
}

// GOOD -- depends on an interface (loose coupling)
public class OrderService {
    private OrderRepository repository; // interface type

    public OrderService(OrderRepository repository) {
        this.repository = repository; // injected -- could be MySQL, Postgres, or a mock
    }

    public void placeOrder(Order order) {
        repository.save(order); // Works with ANY implementation
    }
}

// Now we can easily swap implementations or test with a mock
OrderService prodService = new OrderService(new MySqlOrderRepository());
OrderService testService = new OrderService(new InMemoryOrderRepository());

// Declaring an interface
public interface Animal {

    // Constant -- automatically public, static, and final
    String KINGDOM = "Animalia";

    // Abstract method -- automatically public and abstract
    void eat();

    // Another abstract method
    String speak();

    // Method with a parameter and return type
    boolean canFly();
}

public class Dog implements Animal {

    @Override
    public void eat() {
        System.out.println("Dog eats kibble");
    }

    @Override
    public String speak() {
        return "Woof!";
    }

    @Override
    public boolean canFly() {
        return false;
    }
}

public class Eagle implements Animal {

    @Override
    public void eat() {
        System.out.println("Eagle eats fish");
    }

    @Override
    public String speak() {
        return "Screech!";
    }

    @Override
    public boolean canFly() {
        return true;
    }
}

// Using the interface type for polymorphism
public class Main {
    public static void main(String[] args) {
        Animal myPet = new Dog();
        Animal myBird = new Eagle();

        System.out.println(myPet.speak());    // Woof!
        System.out.println(myBird.speak());   // Screech!
        System.out.println(myBird.canFly());  // true

        // Accessing the constant through the interface
        System.out.println(Animal.KINGDOM);   // Animalia
    }
}

// Demonstrating interface rules

public interface Vehicle {

    // This field is automatically public, static, and final
    int MAX_SPEED_MPH = 200; // Must be initialized here

    // This method is automatically public and abstract
    void start();

    // You can write it explicitly, but it is redundant
    public abstract void stop();

    // INVALID -- cannot have instance variables
    // int currentSpeed; // Compilation error: must be initialized (and will be static final)

    // INVALID -- cannot have constructors
    // Vehicle() { } // Compilation error
}

// A class implementing multiple interfaces
public interface Insurable {
    double calculatePremium();
}

public interface Leasable {
    double monthlyPayment(int termMonths);
}

public class Car implements Vehicle, Insurable, Leasable {

    @Override
    public void start() {
        System.out.println("Car engine started");
    }

    @Override
    public void stop() {
        System.out.println("Car engine stopped");
    }

    @Override
    public double calculatePremium() {
        return 1200.00;
    }

    @Override
    public double monthlyPayment(int termMonths) {
        return 35000.0 / termMonths;
    }
}

public interface Logger {

    // Abstract method -- must be implemented
    void log(String message);

    // Default method -- provides a default implementation
    default void logInfo(String message) {
        log("[INFO] " + message);
    }

    default void logWarning(String message) {
        log("[WARNING] " + message);
    }

    default void logError(String message) {
        log("[ERROR] " + message);
    }
}

// ConsoleLogger only needs to implement log() -- it gets the others for free
public class ConsoleLogger implements Logger {

    @Override
    public void log(String message) {
        System.out.println(message);
    }

    // logInfo, logWarning, logError are inherited with default behavior
}

// FileLogger overrides logError to add special behavior
public class FileLogger implements Logger {

    @Override
    public void log(String message) {
        // In a real app, this would write to a file
        System.out.println("[FILE] " + message);
    }

    @Override
    public void logError(String message) {
        log("[ERROR] " + message);
        log("[ERROR] Stack trace saved to error.log");
        // Additional error-specific logic
    }
}

public class Main {
    public static void main(String[] args) {
        Logger console = new ConsoleLogger();
        console.logInfo("Application started");    // [INFO] Application started
        console.logError("Null pointer");           // [ERROR] Null pointer

        Logger file = new FileLogger();
        file.logInfo("Application started");        // [FILE] [INFO] Application started
        file.logError("Null pointer");              // [FILE] [ERROR] Null pointer
                                                    // [FILE] [ERROR] Stack trace saved to error.log
    }
}

public interface InterfaceA {
    default void greet() {
        System.out.println("Hello from A");
    }
}

public interface InterfaceB {
    default void greet() {
        System.out.println("Hello from B");
    }
}

// This will NOT compile without resolving the conflict
// public class MyClass implements InterfaceA, InterfaceB { }

// Solution: override the method and resolve the conflict
public class MyClass implements InterfaceA, InterfaceB {

    @Override
    public void greet() {
        // Option 1: Call one of the interface defaults
        InterfaceA.super.greet(); // Hello from A

        // Option 2: Call the other
        // InterfaceB.super.greet();

        // Option 3: Provide entirely new behavior
        // System.out.println("Hello from MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.greet(); // Hello from A
    }
}

public interface StringUtils {

    // Static utility method -- called via StringUtils.isNullOrEmpty()
    static boolean isNullOrEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    static String capitalize(String str) {
        if (isNullOrEmpty(str)) {
            return str;
        }
        return str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();
    }

    static String repeat(String str, int times) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < times; i++) {
            sb.append(str);
        }
        return sb.toString();
    }
}

// Static factory method pattern
public interface Shape {
    double area();
    String name();

    // Factory method -- creates shapes without exposing implementation classes
    static Shape circle(double radius) {
        return new Shape() {
            @Override
            public double area() {
                return Math.PI * radius * radius;
            }

            @Override
            public String name() {
                return "Circle(r=" + radius + ")";
            }
        };
    }

    static Shape square(double side) {
        return new Shape() {
            @Override
            public double area() {
                return side * side;
            }

            @Override
            public String name() {
                return "Square(s=" + side + ")";
            }
        };
    }
}

public class Main {
    public static void main(String[] args) {
        // Using static utility methods
        System.out.println(StringUtils.isNullOrEmpty(""));       // true
        System.out.println(StringUtils.isNullOrEmpty("hello"));  // false
        System.out.println(StringUtils.capitalize("jAVA"));      // Java
        System.out.println(StringUtils.repeat("ha", 3));         // hahaha

        // Using static factory methods
        Shape c = Shape.circle(5);
        Shape s = Shape.square(4);
        System.out.println(c.name() + " area: " + c.area()); // Circle(r=5.0) area: 78.539...
        System.out.println(s.name() + " area: " + s.area()); // Square(s=4.0) area: 16.0
    }
}

public interface Reportable {

    String getData();

    // Default methods with shared formatting logic
    default String generateHtmlReport() {
        return wrapInTag("html",
            wrapInTag("body",
                wrapInTag("h1", "Report") +
                wrapInTag("p", getData())
            )
        );
    }

    default String generateXmlReport() {
        return wrapInTag("report",
            wrapInTag("title", "Report") +
            wrapInTag("data", getData())
        );
    }

    // Private method -- shared by both default methods above
    // Not visible to implementing classes
    private String wrapInTag(String tag, String content) {
        return "<" + tag + ">" + content + "";
    }
}

public class SalesReport implements Reportable {

    @Override
    public String getData() {
        return "Total sales: $50,000";
    }
}

public class Main {
    public static void main(String[] args) {
        Reportable report = new SalesReport();

        System.out.println(report.generateHtmlReport());
        // 
Report
Total sales: $50,000

        System.out.println(report.generateXmlReport());
        // Total sales: $50,000

        // report.wrapInTag("div", "text"); // Compilation error -- private method
    }
}

// Custom functional interface
@FunctionalInterface
public interface Transformer {
    T transform(T input);

    // Default methods are allowed -- they do not break the functional interface contract
    default Transformer andThen(Transformer after) {
        return input -> after.transform(this.transform(input));
    }
}

public class Main {
    public static void main(String[] args) {

        // Using a lambda expression (because Transformer is a functional interface)
        Transformer toUpperCase = s -> s.toUpperCase();
        Transformer addExclamation = s -> s + "!";
        Transformer trim = s -> s.trim();

        System.out.println(toUpperCase.transform("hello"));  // HELLO
        System.out.println(addExclamation.transform("wow"));  // wow!

        // Chaining transformations using the default method
        Transformer shout = trim.andThen(toUpperCase).andThen(addExclamation);
        System.out.println(shout.transform("  hello world  ")); // HELLO WORLD!
    }
}

import java.util.Arrays;
import java.util.List;
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;

public class FunctionalInterfaceDemo {
    public static void main(String[] args) {

        List names = Arrays.asList("Alice", "Bob", "Charlie", "Dave", "Eve");

        // Predicate -- test a condition
        Predicate longerThan3 = name -> name.length() > 3;
        List longNames = names.stream()
            .filter(longerThan3)
            .collect(Collectors.toList());
        System.out.println("Long names: " + longNames); // [Alice, Charlie, Dave]

        // Function -- transform data
        Function nameLength = String::length;
        List lengths = names.stream()
            .map(nameLength)
            .collect(Collectors.toList());
        System.out.println("Lengths: " + lengths); // [5, 3, 7, 4, 3]

        // Consumer -- perform an action
        Consumer printUpperCase = name -> System.out.println(name.toUpperCase());
        names.forEach(printUpperCase);
        // ALICE
        // BOB
        // CHARLIE
        // DAVE
        // EVE

        // Supplier -- provide a value (lazy initialization)
        Supplier> defaultNames = () -> Arrays.asList("Unknown");
        List result = names.isEmpty() ? defaultNames.get() : names;
        System.out.println("Result: " + result); // [Alice, Bob, Charlie, Dave, Eve]

        // Composing predicates
        Predicate startsWithA = name -> name.startsWith("A");
        Predicate longAndStartsWithA = longerThan3.and(startsWithA);
        names.stream()
            .filter(longAndStartsWithA)
            .forEach(System.out::println); // Alice

        // Chaining functions
        Function toUpper = String::toUpperCase;
        Function addGreeting = name -> "Hello, " + name;
        Function greetLoudly = toUpper.andThen(addGreeting);
        System.out.println(greetLoudly.apply("alice")); // Hello, ALICE
    }
}

// Interface -- defines a capability
public interface Flyable {
    void fly();
    double maxAltitude();
}

// Abstract class -- defines a base identity with shared state
public abstract class Bird {
    protected String species;
    protected double wingSpan;

    public Bird(String species, double wingSpan) {
        this.species = species;
        this.wingSpan = wingSpan;
    }

    // Concrete method -- shared behavior
    public void breathe() {
        System.out.println(species + " is breathing");
    }

    // Abstract method -- subclasses define their own
    public abstract String habitat();
}

// Penguin IS A Bird but CANNOT fly
public class Penguin extends Bird {
    public Penguin() {
        super("Penguin", 0.3);
    }

    @Override
    public String habitat() {
        return "Antarctic";
    }
}

// Eagle IS A Bird AND CAN fly
public class Eagle extends Bird implements Flyable {
    public Eagle() {
        super("Eagle", 2.0);
    }

    @Override
    public String habitat() {
        return "Mountains";
    }

    @Override
    public void fly() {
        System.out.println("Eagle soars through the sky");
    }

    @Override
    public double maxAltitude() {
        return 10000; // feet
    }
}

// An Airplane is NOT a Bird but CAN fly
public class Airplane implements Flyable {

    @Override
    public void fly() {
        System.out.println("Airplane flies with engines");
    }

    @Override
    public double maxAltitude() {
        return 40000; // feet
    }
}

// This shows why interfaces represent capabilities, not identity
// Both Eagle and Airplane can fly, but they are not related by inheritance

import java.io.Serializable;

// Serializable is a marker interface -- no methods to implement
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', email='" + email + "'}";
    }
}

// Creating a custom marker interface
public interface Auditable {
    // No methods -- just marks classes that should be audited
}

// Service that checks for the marker
public class AuditService {

    public void save(Object entity) {
        if (entity instanceof Auditable) {
            System.out.println("AUDIT LOG: Saving " + entity.getClass().getSimpleName());
        }
        // ... save logic
        System.out.println("Saved: " + entity);
    }
}

// A class that is auditable
public class Order implements Auditable {
    private String orderId;

    public Order(String orderId) {
        this.orderId = orderId;
    }

    @Override
    public String toString() {
        return "Order{id='" + orderId + "'}";
    }
}

// A class that is NOT auditable
public class TempData {
    private String value;

    public TempData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "TempData{value='" + value + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        AuditService auditService = new AuditService();

        auditService.save(new Order("ORD-001"));
        // AUDIT LOG: Saving Order
        // Saved: Order{id='ORD-001'}

        auditService.save(new TempData("temp"));
        // Saved: TempData{value='temp'}    (no audit log)
    }
}

// Small, focused interfaces (Interface Segregation Principle)
public interface Readable {
    String read();
}

public interface Writable {
    void write(String data);
}

public interface Closeable {
    void close();
}

// Composed interface -- extends multiple interfaces
public interface ReadWriteStream extends Readable, Writable, Closeable {
    // Inherits read(), write(), and close()
    // Can add its own methods too
    long size();
}

// A class implementing the composed interface must implement ALL methods
public class FileStream implements ReadWriteStream {

    private StringBuilder buffer = new StringBuilder();
    private boolean open = true;

    @Override
    public String read() {
        if (!open) throw new IllegalStateException("Stream is closed");
        return buffer.toString();
    }

    @Override
    public void write(String data) {
        if (!open) throw new IllegalStateException("Stream is closed");
        buffer.append(data);
    }

    @Override
    public void close() {
        open = false;
        System.out.println("Stream closed");
    }

    @Override
    public long size() {
        return buffer.length();
    }
}

// You can use any level of the interface hierarchy as a type
public class Main {
    public static void main(String[] args) {
        ReadWriteStream stream = new FileStream();
        stream.write("Hello, ");
        stream.write("World!");
        System.out.println(stream.read());  // Hello, World!
        System.out.println(stream.size());  // 13
        stream.close();                     // Stream closed

        // Use the narrowest type needed
        Readable reader = new FileStream();
        // reader.write("test"); // Compilation error -- Readable has no write()
    }
}

public interface Printable {
    default String format() {
        return "Plain text format";
    }
}

public interface Exportable {
    default String format() {
        return "Export format";
    }
}

// This interface extends both -- must resolve the conflict
public interface Document extends Printable, Exportable {

    @Override
    default String format() {
        // Choose one, combine both, or define new behavior
        return "Document: " + Printable.super.format();
    }
}

public class Report implements Document {
    // Inherits the resolved format() from Document
}

public class Main {
    public static void main(String[] args) {
        Report report = new Report();
        System.out.println(report.format()); // Document: Plain text format
    }
}

// Strategy interface
public interface SortStrategy> {
    void sort(List list);
    String name();
}

// Concrete strategy: Bubble Sort
public class BubbleSort> implements SortStrategy {

    @Override
    public void sort(List list) {
        int n = list.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (list.get(j).compareTo(list.get(j + 1)) > 0) {
                    T temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }
    }

    @Override
    public String name() {
        return "Bubble Sort";
    }
}

// Concrete strategy: Java's built-in sort
public class BuiltInSort> implements SortStrategy {

    @Override
    public void sort(List list) {
        Collections.sort(list);
    }

    @Override
    public String name() {
        return "Built-in Sort (TimSort)";
    }
}

// Context class that uses the strategy
public class DataProcessor> {
    private SortStrategy strategy;

    public DataProcessor(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public List process(List data) {
        System.out.println("Sorting with: " + strategy.name());
        List copy = new ArrayList<>(data);
        strategy.sort(copy);
        return copy;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        List data = Arrays.asList(5, 2, 8, 1, 9, 3);

        DataProcessor processor = new DataProcessor<>(new BubbleSort<>());
        System.out.println(processor.process(data)); // [1, 2, 3, 5, 8, 9]

        // Switch strategy at runtime
        processor.setStrategy(new BuiltInSort<>());
        System.out.println(processor.process(data)); // [1, 2, 3, 5, 8, 9]
    }
}

// Domain entity
public class Product {
    private Long id;
    private String name;
    private double price;

    public Product(Long id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    // Getters
    public Long getId() { return id; }
    public String getName() { return name; }
    public double getPrice() { return price; }

    @Override
    public String toString() {
        return "Product{id=" + id + ", name='" + name + "', price=" + price + "}";
    }
}

// Repository interface -- the contract for data access
public interface ProductRepository {
    Product findById(Long id);
    List findAll();
    List findByPriceRange(double min, double max);
    Product save(Product product);
    void deleteById(Long id);
}

// Implementation for production -- talks to a real database
public class JpaProductRepository implements ProductRepository {

    @Override
    public Product findById(Long id) {
        // In a real app: entityManager.find(Product.class, id)
        System.out.println("JPA: Finding product with id " + id);
        return new Product(id, "Widget", 9.99);
    }

    @Override
    public List findAll() {
        System.out.println("JPA: Querying all products from database");
        return Arrays.asList(
            new Product(1L, "Widget", 9.99),
            new Product(2L, "Gadget", 24.99)
        );
    }

    @Override
    public List findByPriceRange(double min, double max) {
        System.out.println("JPA: Querying products between $" + min + " and $" + max);
        return findAll().stream()
            .filter(p -> p.getPrice() >= min && p.getPrice() <= max)
            .collect(Collectors.toList());
    }

    @Override
    public Product save(Product product) {
        System.out.println("JPA: Saving " + product);
        return product;
    }

    @Override
    public void deleteById(Long id) {
        System.out.println("JPA: Deleting product with id " + id);
    }
}

// Implementation for testing -- in-memory, no database needed
public class InMemoryProductRepository implements ProductRepository {
    private Map store = new HashMap<>();
    private long nextId = 1;

    @Override
    public Product findById(Long id) {
        return store.get(id);
    }

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

    @Override
    public List findByPriceRange(double min, double max) {
        return store.values().stream()
            .filter(p -> p.getPrice() >= min && p.getPrice() <= max)
            .collect(Collectors.toList());
    }

    @Override
    public Product save(Product product) {
        if (product.getId() == null) {
            product = new Product(nextId++, product.getName(), product.getPrice());
        }
        store.put(product.getId(), product);
        return product;
    }

    @Override
    public void deleteById(Long id) {
        store.remove(id);
    }
}

// Service interface
public interface ProductService {
    Product getProduct(Long id);
    List getAllProducts();
    List getAffordableProducts(double maxPrice);
    Product createProduct(String name, double price);
}

// Production implementation
public class ProductServiceImpl implements ProductService {
    private final ProductRepository repository;

    public ProductServiceImpl(ProductRepository repository) {
        this.repository = repository;
    }

    @Override
    public Product getProduct(Long id) {
        Product product = repository.findById(id);
        if (product == null) {
            throw new RuntimeException("Product not found: " + id);
        }
        return product;
    }

    @Override
    public List getAllProducts() {
        return repository.findAll();
    }

    @Override
    public List getAffordableProducts(double maxPrice) {
        return repository.findByPriceRange(0, maxPrice);
    }

    @Override
    public Product createProduct(String name, double price) {
        if (price < 0) throw new IllegalArgumentException("Price cannot be negative");
        return repository.save(new Product(null, name, price));
    }
}

// Usage -- everything wired through interfaces
public class Main {
    public static void main(String[] args) {
        // Production setup
        ProductRepository prodRepo = new JpaProductRepository();
        ProductService prodService = new ProductServiceImpl(prodRepo);

        // Test setup -- swap to in-memory, no database needed
        ProductRepository testRepo = new InMemoryProductRepository();
        ProductService testService = new ProductServiceImpl(testRepo);

        // Same code works with both
        testService.createProduct("Widget", 9.99);
        testService.createProduct("Gadget", 24.99);
        System.out.println(testService.getAllProducts());
        // [Product{id=1, name='Widget', price=9.99}, Product{id=2, name='Gadget', price=24.99}]
    }
}

// BAD -- fat interface forces all implementors to deal with methods they do not need
public interface SmartDevice {
    void turnOn();
    void turnOff();
    void setTemperature(double temp);    // Not all devices have thermostats
    void playMusic(String song);          // Not all devices play music
    void takePhoto();                     // Not all devices have cameras
    void makeCall(String number);         // Not all devices can call
}

// GOOD -- small, focused interfaces
public interface Switchable {
    void turnOn();
    void turnOff();
}

public interface Thermostat {
    void setTemperature(double temp);
    double getTemperature();
}

public interface MusicPlayer {
    void playMusic(String song);
    void stop();
}

// Each class implements only what it needs
public class SmartLight implements Switchable {
    @Override
    public void turnOn() { System.out.println("Light on"); }

    @Override
    public void turnOff() { System.out.println("Light off"); }
}

public class SmartSpeaker implements Switchable, MusicPlayer {
    @Override
    public void turnOn() { System.out.println("Speaker on"); }

    @Override
    public void turnOff() { System.out.println("Speaker off"); }

    @Override
    public void playMusic(String song) { System.out.println("Playing: " + song); }

    @Override
    public void stop() { System.out.println("Music stopped"); }
}

public class SmartThermostat implements Switchable, Thermostat {
    private double temp = 72.0;

    @Override
    public void turnOn() { System.out.println("Thermostat on"); }

    @Override
    public void turnOff() { System.out.println("Thermostat off"); }

    @Override
    public void setTemperature(double temp) { this.temp = temp; }

    @Override
    public double getTemperature() { return temp; }
}

// BAD -- locked to a specific implementation
ArrayList names = new ArrayList<>();
HashMap scores = new HashMap<>();

// GOOD -- programmed to the interface
List names = new ArrayList<>();
Map scores = new HashMap<>();

// Now you can switch to LinkedList, TreeMap, etc. without changing any other code
List names = new LinkedList<>();    // No other code needs to change
Map scores = new TreeMap<>(); // Automatically sorted

// BAD method signature -- locked to ArrayList
public ArrayList getActiveUsers() { ... }

// GOOD method signature -- returns the interface type
public List getActiveUsers() { ... }

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;

// ============================================================
// 1. Core interface with abstract, default, static, and private methods
// ============================================================
public interface PaymentProcessor {

    // Abstract methods -- every processor must implement these
    boolean processPayment(double amount, String currency);
    boolean refund(String transactionId, double amount);
    String getProcessorName();

    // Default method -- shared behavior with a sensible default
    default String generateTransactionId() {
        return getProcessorName().substring(0, 3).toUpperCase()
            + "-" + System.currentTimeMillis();
    }

    // Default method -- logging with a common format
    default void logTransaction(String transactionId, double amount, String status) {
        String timestamp = LocalDateTime.now()
            .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println(formatLog(timestamp, transactionId, amount, status));
    }

    // Private method (Java 9+) -- shared formatting logic
    private String formatLog(String timestamp, String txnId, double amount, String status) {
        return String.format("[%s] [%s] Transaction %s: $%.2f - %s",
            timestamp, getProcessorName(), txnId, amount, status);
    }

    // Static factory method -- creates processors without exposing implementation details
    static PaymentProcessor createProcessor(String type) {
        switch (type.toLowerCase()) {
            case "credit_card": return new CreditCardProcessor();
            case "paypal":      return new PayPalProcessor();
            case "crypto":      return new CryptoProcessor();
            default: throw new IllegalArgumentException("Unknown processor: " + type);
        }
    }

    // Static utility method
    static boolean isValidAmount(double amount) {
        return amount > 0 && amount <= 1_000_000;
    }
}

// ============================================================
// 2. Supplementary interface -- for processors that support subscriptions
// ============================================================
public interface SubscriptionCapable {
    boolean createSubscription(String plan, double monthlyAmount);
    boolean cancelSubscription(String subscriptionId);
}

// ============================================================
// 3. Functional interface -- for payment validation
// ============================================================
@FunctionalInterface
public interface PaymentValidator {
    boolean validate(double amount, String currency);

    // Default method to compose validators
    default PaymentValidator and(PaymentValidator other) {
        return (amount, currency) -> this.validate(amount, currency)
                                  && other.validate(amount, currency);
    }
}

// ============================================================
// 4. Concrete implementations
// ============================================================
public class CreditCardProcessor implements PaymentProcessor, SubscriptionCapable {

    @Override
    public boolean processPayment(double amount, String currency) {
        if (!PaymentProcessor.isValidAmount(amount)) {
            logTransaction("INVALID", amount, "REJECTED");
            return false;
        }
        String txnId = generateTransactionId();
        // Simulate credit card processing
        System.out.println("Processing credit card payment...");
        System.out.println("Contacting bank for authorization...");
        logTransaction(txnId, amount, "APPROVED");
        return true;
    }

    @Override
    public boolean refund(String transactionId, double amount) {
        logTransaction(transactionId, amount, "REFUNDED");
        return true;
    }

    @Override
    public String getProcessorName() {
        return "CreditCard";
    }

    @Override
    public boolean createSubscription(String plan, double monthlyAmount) {
        System.out.println("Credit card subscription created: " + plan
            + " at $" + monthlyAmount + "/month");
        return true;
    }

    @Override
    public boolean cancelSubscription(String subscriptionId) {
        System.out.println("Subscription " + subscriptionId + " cancelled");
        return true;
    }
}

public class PayPalProcessor implements PaymentProcessor, SubscriptionCapable {

    @Override
    public boolean processPayment(double amount, String currency) {
        if (!PaymentProcessor.isValidAmount(amount)) {
            logTransaction("INVALID", amount, "REJECTED");
            return false;
        }
        String txnId = generateTransactionId();
        System.out.println("Redirecting to PayPal...");
        System.out.println("PayPal payment confirmed.");
        logTransaction(txnId, amount, "APPROVED");
        return true;
    }

    @Override
    public boolean refund(String transactionId, double amount) {
        System.out.println("PayPal refund initiated (3-5 business days)");
        logTransaction(transactionId, amount, "REFUNDED");
        return true;
    }

    @Override
    public String getProcessorName() {
        return "PayPal";
    }

    @Override
    public boolean createSubscription(String plan, double monthlyAmount) {
        System.out.println("PayPal subscription created: " + plan);
        return true;
    }

    @Override
    public boolean cancelSubscription(String subscriptionId) {
        System.out.println("PayPal subscription " + subscriptionId + " cancelled");
        return true;
    }
}

public class CryptoProcessor implements PaymentProcessor {
    // Does NOT implement SubscriptionCapable -- crypto does not support subscriptions

    @Override
    public boolean processPayment(double amount, String currency) {
        if (!PaymentProcessor.isValidAmount(amount)) {
            logTransaction("INVALID", amount, "REJECTED");
            return false;
        }
        String txnId = generateTransactionId();
        System.out.println("Waiting for blockchain confirmation...");
        logTransaction(txnId, amount, "CONFIRMED");
        return true;
    }

    @Override
    public boolean refund(String transactionId, double amount) {
        System.out.println("Crypto refunds require manual wallet transfer");
        logTransaction(transactionId, amount, "REFUND_PENDING");
        return false;
    }

    @Override
    public String getProcessorName() {
        return "Crypto";
    }
}

// ============================================================
// 5. Payment service -- ties everything together
// ============================================================
public class PaymentService {

    private final List processors = new ArrayList<>();

    public void registerProcessor(PaymentProcessor processor) {
        processors.add(processor);
    }

    public boolean pay(String processorType, double amount, String currency,
                       PaymentValidator validator) {
        // Validate first using the functional interface
        if (!validator.validate(amount, currency)) {
            System.out.println("Payment validation failed!");
            return false;
        }

        // Find the right processor (programming to interface)
        PaymentProcessor processor = processors.stream()
            .filter(p -> p.getProcessorName().equalsIgnoreCase(processorType))
            .findFirst()
            .orElseThrow(() -> new RuntimeException("No processor: " + processorType));

        return processor.processPayment(amount, currency);
    }

    // Check if a processor supports subscriptions using instanceof
    public boolean subscribe(String processorType, String plan, double monthly) {
        PaymentProcessor processor = processors.stream()
            .filter(p -> p.getProcessorName().equalsIgnoreCase(processorType))
            .findFirst()
            .orElseThrow(() -> new RuntimeException("No processor: " + processorType));

        if (processor instanceof SubscriptionCapable) {
            return ((SubscriptionCapable) processor).createSubscription(plan, monthly);
        } else {
            System.out.println(processorType + " does not support subscriptions");
            return false;
        }
    }
}

// ============================================================
// 6. Main -- running the complete example
// ============================================================
public class Main {
    public static void main(String[] args) {

        // --- Setup ---
        PaymentService service = new PaymentService();

        // Using static factory method to create processors
        service.registerProcessor(PaymentProcessor.createProcessor("credit_card"));
        service.registerProcessor(PaymentProcessor.createProcessor("paypal"));
        service.registerProcessor(PaymentProcessor.createProcessor("crypto"));

        // --- Validators using functional interfaces and lambdas ---
        PaymentValidator amountCheck = (amount, currency) -> amount > 0 && amount < 10000;
        PaymentValidator currencyCheck = (amount, currency) ->
            Set.of("USD", "EUR", "GBP").contains(currency);

        // Compose validators using the default 'and' method
        PaymentValidator fullValidation = amountCheck.and(currencyCheck);

        // --- Process payments ---
        System.out.println("=== Credit Card Payment ===");
        service.pay("CreditCard", 99.99, "USD", fullValidation);

        System.out.println("\n=== PayPal Payment ===");
        service.pay("PayPal", 49.50, "EUR", fullValidation);

        System.out.println("\n=== Crypto Payment ===");
        service.pay("Crypto", 250.00, "USD", fullValidation);

        System.out.println("\n=== Invalid Payment (bad currency) ===");
        service.pay("CreditCard", 50.00, "XYZ", fullValidation);
        // Payment validation failed!

        System.out.println("\n=== Subscriptions ===");
        service.subscribe("CreditCard", "Premium", 19.99);
        // Credit card subscription created: Premium at $19.99/month

        service.subscribe("Crypto", "Premium", 19.99);
        // Crypto does not support subscriptions
    }
}

// === Sample Output ===
// === Credit Card Payment ===
// Processing credit card payment...
// Contacting bank for authorization...
// [2026-02-28 10:30:15] [CreditCard] Transaction CRE-1709125815000: $99.99 - APPROVED
//
// === PayPal Payment ===
// Redirecting to PayPal...
// PayPal payment confirmed.
// [2026-02-28 10:30:15] [PayPal] Transaction PAY-1709125815001: $49.50 - APPROVED
//
// === Crypto Payment ===
// Waiting for blockchain confirmation...
// [2026-02-28 10:30:15] [Crypto] Transaction CRY-1709125815002: $250.00 - CONFIRMED
//
// === Invalid Payment (bad currency) ===
// Payment validation failed!
//
// === Subscriptions ===
// Credit card subscription created: Premium at $19.99/month
// Crypto does not support subscriptions

---