public interface Drawable {
    void draw();
    
    default void prepare() {
        System.out.println("Preparing to draw");
    }
}

public interface Movable {
    void move(int x, int y);
    
    default void prepare() {
        System.out.println("Preparing to move");
    }
}

public interface Scalable {
    void scale(double factor);
}

// Implementing multiple interfaces
public class GameObject implements Drawable, Movable, Scalable {
    private int x, y;
    private double size = 1.0;
    private String name;
    
    public GameObject(String name) {
        this.name = name;
        this.x = 0;
        this.y = 0;
    }
    
    // Must resolve default method conflict
    @Override
    public void prepare() {
        System.out.println("Preparing " + name + " for operation");
        // Can call specific interface methods if needed
        // Drawable.super.prepare();
        // Movable.super.prepare();
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing " + name + " at (" + x + "," + y + 
                         ") with size " + size);
    }
    
    @Override
    public void move(int x, int y) {
        this.x = x;
        this.y = y;
        System.out.println(name + " moved to (" + x + "," + y + ")");
    }
    
    @Override
    public void scale(double factor) {
        if (factor > 0) {
            this.size *= factor;
            System.out.println(name + " scaled by factor " + factor);
        }
    }
}

public class GameDemo {
    public static void main(String[] args) {
        GameObject player = new GameObject("Player");
        
        // Can be referenced by any implemented interface
        Drawable drawable = player;
        Movable movable = player;
        Scalable scalable = player;
        
        // Using through different interface references
        drawable.prepare();
        drawable.draw();
        
        movable.prepare();  // Same object, different interface view
        movable.move(10, 20);
        
        scalable.scale(1.5);
        
        // Using as concrete class
        player.draw();  // Shows updated position and size
    }
}

public interface A {
    default void method() {
        System.out.println("A's implementation");
    }
    
    default String getInfo() {
        return "Interface A";
    }
}

public interface B {
    default void method() {
        System.out.println("B's implementation");
    }
    
    default String getDetails() {
        return "Interface B";
    }
}

public interface C extends A, B {
    // Must resolve the conflict
    @Override
    default void method() {
        System.out.println("C's resolution:");
        A.super.method();  // Call A's version
        B.super.method();  // Call B's version
        System.out.println("Combined in C");
    }
}

public class DiamondResolver implements A, B {
    @Override
    public void method() {
        // Strategy 1: Choose one interface
        A.super.method();
        
        // Strategy 2: Combine both
        // System.out.println("Combining A and B:");
        // A.super.method();
        // B.super.method();
        
        // Strategy 3: Completely new implementation
        // System.out.println("Custom implementation");
    }
    
    // Can use other default methods without conflict
    public void displayInfo() {
        System.out.println(getInfo());     // From A
        System.out.println(getDetails());  // From B
    }
}

public interface Vehicle {
    default void start() {
        System.out.println("Vehicle starting...");
    }
    
    default void stop() {
        System.out.println("Vehicle stopping...");
    }
}

public interface Electric {
    default void start() {
        System.out.println("Electric system starting...");
    }
    
    default void charge() {
        System.out.println("Charging battery...");
    }
}

public interface Autonomous {
    default void start() {
        System.out.println("Autonomous system starting...");
    }
    
    default void enableAutoPilot() {
        System.out.println("Auto-pilot enabled");
    }
}

public class ElectricAutonomousCar 
    implements Vehicle, Electric, Autonomous {
    
    @Override
    public void start() {
        System.out.println("Starting Electric Autonomous Car:");
        Vehicle.super.start();     // Base vehicle start
        Electric.super.start();    // Electric system start
        Autonomous.super.start();  // Autonomous system start
        System.out.println("All systems ready!");
    }
    
    // Other methods inherited without conflict
    public void performOperations() {
        charge();           // From Electric
        enableAutoPilot();  // From Autonomous
        stop();            // From Vehicle (no conflict)
    }
}

// Base interface
public interface Animal {
    void makeSound();
    
    default void breathe() {
        System.out.println("Breathing...");
    }
    
    default String getCategory() {
        return "Animal";
    }
}

// Extending interface
public interface Mammal extends Animal {
    void giveMilk();
    
    @Override
    default String getCategory() {
        return "Mammal";
    }
    
    default void regulateTemperature() {
        System.out.println("Regulating body temperature");
    }
}

// Further extending
public interface Carnivore extends Mammal {
    void hunt();
    
    @Override
    default String getCategory() {
        return "Carnivorous Mammal";
    }
    
    default void eatMeat() {
        System.out.println("Eating meat");
    }
}

// Multiple inheritance in interfaces
public interface Domesticated {
    void obeyCommands();
    
    default void showAffection() {
        System.out.println("Showing affection to humans");
    }
}

public class Dog implements Carnivore, Domesticated {
    private String name;
    private String breed;
    
    public Dog(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }
    
    // Implementing Animal methods
    @Override
    public void makeSound() {
        System.out.println(name + " says Woof!");
    }
    
    // Implementing Mammal methods
    @Override
    public void giveMilk() {
        System.out.println(name + " is nursing puppies");
    }
    
    // Implementing Carnivore methods
    @Override
    public void hunt() {
        System.out.println(name + " is hunting for prey");
    }
    
    // Implementing Domesticated methods
    @Override
    public void obeyCommands() {
        System.out.println(name + " is obeying commands");
    }
    
    // Override default methods if needed
    @Override
    public void showAffection() {
        System.out.println(name + " is wagging tail and being friendly");
    }
    
    // Can access all inherited default methods
    public void performAllBehaviors() {
        makeSound();              // Abstract method implementation
        breathe();               // From Animal (default)
        regulateTemperature();   // From Mammal (default)
        eatMeat();              // From Carnivore (default)
        showAffection();        // Overridden default
        System.out.println("Category: " + getCategory()); // From Carnivore
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", "Golden Retriever");
        
        // Can be referenced by any interface in hierarchy
        Animal animal = dog;
        Mammal mammal = dog;
        Carnivore carnivore = dog;
        Domesticated pet = dog;
        
        // Different interface views
        animal.makeSound();
        mammal.giveMilk();
        carnivore.hunt();
        pet.obeyCommands();
        
        dog.performAllBehaviors();
    }
}

// Service interfaces
public interface DatabaseService {
    void saveData(String data);
    String loadData(String key);
    
    default void backup() {
        System.out.println("Backing up database");
    }
}

public interface CacheService {
    void cache(String key, String value);
    String getFromCache(String key);
    void clearCache();
    
    default void warmup() {
        System.out.println("Warming up cache");
    }
}

public interface LoggingService {
    void log(String message);
    void logError(String error);
    
    default void logInfo(String info) {
        log("INFO: " + info);
    }
}

// Composite service using composition
public class DataManager implements DatabaseService, CacheService, LoggingService {
    // Composition - delegate to specialized implementations
    private final DatabaseService database;
    private final CacheService cache;
    private final LoggingService logger;
    
    public DataManager(DatabaseService database, 
                      CacheService cache, 
                      LoggingService logger) {
        this.database = database;
        this.cache = cache;
        this.logger = logger;
    }
    
    // DatabaseService implementation - delegation
    @Override
    public void saveData(String data) {
        logInfo("Saving data: " + data);
        database.saveData(data);
        cache.cache(data, data); // Also cache it
    }
    
    @Override
    public String loadData(String key) {
        logInfo("Loading data for key: " + key);
        
        // Try cache first
        String cachedData = cache.getFromCache(key);
        if (cachedData != null) {
            logInfo("Data found in cache");
            return cachedData;
        }
        
        // Load from database
        String data = database.loadData(key);
        if (data != null) {
            cache.cache(key, data); // Cache for next time
        }
        return data;
    }
    
    // CacheService implementation - delegation
    @Override
    public void cache(String key, String value) {
        cache.cache(key, value);
    }
    
    @Override
    public String getFromCache(String key) {
        return cache.getFromCache(key);
    }
    
    @Override
    public void clearCache() {
        logInfo("Clearing cache");
        cache.clearCache();
    }
    
    // LoggingService implementation - delegation
    @Override
    public void log(String message) {
        logger.log(message);
    }
    
    @Override
    public void logError(String error) {
        logger.logError(error);
    }
}

public interface Processor {
    void process(String data);
    String getProcessorType();
}

public class FastProcessor implements Processor {
    @Override
    public void process(String data) {
        System.out.println("Fast processing: " + data);
    }
    
    @Override
    public String getProcessorType() { return "Fast"; }
}

public class SecureProcessor implements Processor {
    @Override
    public void process(String data) {
        System.out.println("Secure processing: " + encrypt(data));
    }
    
    private String encrypt(String data) {
        return "encrypted(" + data + ")";
    }
    
    @Override
    public String getProcessorType() { return "Secure"; }
}

// Adaptive processor that delegates based on conditions
public class AdaptiveProcessor implements Processor {
    private Processor fastProcessor = new FastProcessor();
    private Processor secureProcessor = new SecureProcessor();
    private boolean securityMode = false;
    
    public void enableSecurity(boolean enabled) {
        this.securityMode = enabled;
    }
    
    @Override
    public void process(String data) {
        Processor delegate = securityMode ? secureProcessor : fastProcessor;
        System.out.println("Delegating to " + delegate.getProcessorType() + " processor");
        delegate.process(data);
    }
    
    @Override
    public String getProcessorType() {
        return "Adaptive(" + 
               (securityMode ? secureProcessor.getProcessorType() : 
                              fastProcessor.getProcessorType()) + ")";
    }
}

// Usage
public class ProcessorDemo {
    public static void main(String[] args) {
        AdaptiveProcessor processor = new AdaptiveProcessor();
        
        System.out.println("Normal mode:");
        processor.process("sensitive data");
        
        System.out.println("\nSecure mode:");
        processor.enableSecurity(true);
        processor.process("sensitive data");
        
        System.out.println("Type: " + processor.getProcessorType());
    }
}

// Base plugin interface
public interface Plugin {
    String getName();
    String getVersion();
    void initialize();
    void shutdown();
    
    default boolean isEnabled() {
        return true;
    }
    
    default String getDescription() {
        return "Plugin: " + getName() + " v" + getVersion();
    }
}

// Configurable plugin
public interface ConfigurablePlugin extends Plugin {
    void configure(Properties config);
    Properties getConfiguration();
    
    default void resetConfiguration() {
        configure(new Properties());
    }
}

// Service provider plugin
public interface ServicePlugin extends ConfigurablePlugin {
    void startService();
    void stopService();
    boolean isServiceRunning();
    
    default void restartService() {
        if (isServiceRunning()) {
            stopService();
        }
        startService();
    }
}

// UI plugin
public interface UIPlugin extends Plugin {
    void createUI();
    void destroyUI();
    void showUI(boolean visible);
    
    default void toggleUI() {
        showUI(!isUIVisible());
    }
    
    boolean isUIVisible();
}

// Event handling capability
public interface EventHandlerPlugin {
    void handleEvent(String eventType, Object eventData);
    String[] getSupportedEvents();
    
    default boolean canHandle(String eventType) {
        String[] supported = getSupportedEvents();
        for (String type : supported) {
            if (type.equals(eventType)) {
                return true;
            }
        }
        return false;
    }
}

// Database backup plugin
public class DatabaseBackupPlugin 
    implements ServicePlugin, EventHandlerPlugin {
    
    private String name = "DB Backup";
    private String version = "1.0";
    private Properties config = new Properties();
    private boolean serviceRunning = false;
    private boolean initialized = false;
    
    @Override
    public String getName() { return name; }
    
    @Override
    public String getVersion() { return version; }
    
    @Override
    public void initialize() {
        System.out.println("Initializing " + getDescription());
        // Set default configuration
        config.setProperty("backup.interval", "3600"); // 1 hour
        config.setProperty("backup.location", "/backups");
        initialized = true;
    }
    
    @Override
    public void shutdown() {
        if (serviceRunning) {
            stopService();
        }
        System.out.println("Shutting down " + getName());
        initialized = false;
    }
    
    @Override
    public void configure(Properties config) {
        this.config.putAll(config);
        System.out.println("Plugin configured with " + config.size() + " properties");
    }
    
    @Override
    public Properties getConfiguration() {
        return new Properties(config); // Return copy
    }
    
    @Override
    public void startService() {
        if (!initialized) {
            throw new IllegalStateException("Plugin not initialized");
        }
        if (!serviceRunning) {
            serviceRunning = true;
            String interval = config.getProperty("backup.interval", "3600");
            System.out.println("Backup service started with interval: " + interval + "s");
        }
    }
    
    @Override
    public void stopService() {
        if (serviceRunning) {
            serviceRunning = false;
            System.out.println("Backup service stopped");
        }
    }
    
    @Override
    public boolean isServiceRunning() {
        return serviceRunning;
    }
    
    @Override
    public void handleEvent(String eventType, Object eventData) {
        if ("data.changed".equals(eventType)) {
            System.out.println("Data changed event received, triggering backup");
            performBackup();
        } else if ("system.shutdown".equals(eventType)) {
            System.out.println("System shutdown event, performing final backup");
            performBackup();
        }
    }
    
    @Override
    public String[] getSupportedEvents() {
        return new String[]{"data.changed", "system.shutdown"};
    }
    
    private void performBackup() {
        String location = config.getProperty("backup.location");
        System.out.println("Performing backup to: " + location);
    }
    
    @Override
    public boolean isEnabled() {
        return initialized && Boolean.parseBoolean(
            config.getProperty("enabled", "true"));
    }
}

// Base media interface
public interface Media {
    String getFileName();
    long getFileSize();
    String getFormat();
    
    default String getDisplayName() {
        return getFileName() + " (" + getFormat() + ")";
    }
}

// Playable media
public interface Playable extends Media {
    void play();
    void pause();
    void stop();
    boolean isPlaying();
    
    default void togglePlayback() {
        if (isPlaying()) {
            pause();
        } else {
            play();
        }
    }
}

// Editable media
public interface Editable {
    void cut(int startTime, int endTime);
    void copy(int startTime, int endTime);
    void paste(int position);
    void undo();
    
    default void trim(int startTime, int endTime) {
        cut(0, startTime);
        cut(endTime, getDuration());
    }
    
    int getDuration();
}

// Convertible media
public interface Convertible {
    boolean convertTo(String format);
    String[] getSupportedFormats();
    
    default boolean canConvertTo(String format) {
        String[] formats = getSupportedFormats();
        for (String f : formats) {
            if (f.equalsIgnoreCase(format)) {
                return true;
            }
        }
        return false;
    }
}

// Streamable media
public interface Streamable {
    void startStream(String url);
    void stopStream();
    boolean isStreaming();
    int getViewerCount();
    
    default String getStreamStatus() {
        return isStreaming() ? 
            "Streaming to " + getViewerCount() + " viewers" : 
            "Not streaming";
    }
}

// Video file implementation
public class VideoFile implements Playable, Editable, Convertible, Streamable {
    private String fileName;
    private long fileSize;
    private String format;
    private int duration;
    private boolean playing = false;
    private boolean streaming = false;
    private int viewerCount = 0;
    
    public VideoFile(String fileName, long fileSize, 
                    String format, int duration) {
        this.fileName = fileName;
        this.fileSize = fileSize;
        this.format = format;
        this.duration = duration;
    }
    
    // Media interface implementation
    @Override
    public String getFileName() { return fileName; }
    
    @Override
    public long getFileSize() { return fileSize; }
    
    @Override
    public String getFormat() { return format; }
    
    // Playable interface implementation
    @Override
    public void play() {
        if (!playing) {
            playing = true;
            System.out.println("Playing video: " + getDisplayName());
        }
    }
    
    @Override
    public void pause() {
        if (playing) {
            playing = false;
            System.out.println("Paused video: " + fileName);
        }
    }
    
    @Override
    public void stop() {
        playing = false;
        System.out.println("Stopped video: " + fileName);
    }
    
    @Override
    public boolean isPlaying() { return playing; }
    
    // Editable interface implementation
    @Override
    public void cut(int startTime, int endTime) {
        System.out.println("Cutting video from " + startTime + "s to " + endTime + "s");
        duration = duration - (endTime - startTime);
    }
    
    @Override
    public void copy(int startTime, int endTime) {
        System.out.println("Copying video segment from " + startTime + "s to " + endTime + "s");
    }
    
    @Override
    public void paste(int position) {
        System.out.println("Pasting video segment at " + position + "s");
    }
    
    @Override
    public void undo() {
        System.out.println("Undoing last edit operation");
    }
    
    @Override
    public int getDuration() { return duration; }
    
    // Convertible interface implementation
    @Override
    public boolean convertTo(String targetFormat) {
        if (canConvertTo(targetFormat)) {
            System.out.println("Converting " + fileName + " from " + 
                             format + " to " + targetFormat);
            this.format = targetFormat;
            return true;
        }
        return false;
    }
    
    @Override
    public String[] getSupportedFormats() {
        return new String[]{"mp4", "avi", "mov", "mkv"};
    }
    
    // Streamable interface implementation
    @Override
    public void startStream(String url) {
        if (!streaming) {
            streaming = true;
            viewerCount = 0;
            System.out.println("Started streaming " + fileName + " to " + url);
        }
    }
    
    @Override
    public void stopStream() {
        if (streaming) {
            streaming = false;
            System.out.println("Stopped streaming " + fileName);
            viewerCount = 0;
        }
    }
    
    @Override
    public boolean isStreaming() { return streaming; }
    
    @Override
    public int getViewerCount() { return viewerCount; }
    
    public void simulateViewers(int count) {
        if (streaming) {
            viewerCount = count;
        }
    }
}

// Base device interface
public interface SmartDevice {
    String getDeviceId();
    String getDeviceName();
    boolean isOnline();
    void connect();
    void disconnect();
    
    default String getStatus() {
        return getDeviceName() + " (" + getDeviceId() + "): " + 
               (isOnline() ? "Online" : "Offline");
    }
}

// Controllable device
public interface Controllable extends SmartDevice {
    void turnOn();
    void turnOff();
    boolean isOn();
    
    default void toggle() {
        if (isOn()) {
            turnOff();
        } else {
            turnOn();
        }
    }
}

// Dimmable device
public interface Dimmable extends Controllable {
    void setBrightness(int level); // 0-100
    int getBrightness();
    
    default void dim() {
        setBrightness(Math.max(0, getBrightness() - 20));
    }
    
    default void brighten() {
        setBrightness(Math.min(100, getBrightness() + 20));
    }
}

// Thermostat control
public interface TemperatureControllable extends Controllable {
    void setTemperature(double temperature);
    double getCurrentTemperature();
    double getTargetTemperature();
    
    default void increaseTemperature(double delta) {
        setTemperature(getTargetTemperature() + delta);
    }
    
    default void decreaseTemperature(double delta) {
        setTemperature(getTargetTemperature() - delta);
    }
}

// Security device
public interface SecurityDevice extends SmartDevice {
    void arm();
    void disarm();
    boolean isArmed();
    void triggerAlarm();
    
    default void handleSecurityEvent(String eventType) {
        if (isArmed() && ("motion".equals(eventType) || 
                         "breach".equals(eventType))) {
            triggerAlarm();
        }
    }
}

// Monitoring capability
public interface Monitorable {
    String[] getAvailableMetrics();
    double getMetricValue(String metricName);
    void startMonitoring();
    void stopMonitoring();
    
    default void displayMetrics() {
        System.out.println("Device Metrics:");
        for (String metric : getAvailableMetrics()) {
            System.out.println("  " + metric + ": " + getMetricValue(metric));
        }
    }
}