Dependency Inversion Principle

// ❌ DIP VIOLATION: High-level directly depends on low-level

// Low-level module
class MySQLDatabase {
    public void save(Order order) {
        System.out.println("Saving order to MySQL: " + order.getId());
    }

    public Order findById(String id) {
        return new Order(id);
    }
}

// High-level module - DIRECTLY depends on MySQL
class OrderService {
    private MySQLDatabase database;  // ❌ Concrete dependency

    public OrderService() {
        this.database = new MySQLDatabase();  // ❌ Creates its own dependency
    }

    public void createOrder(Order order) {
        // Business logic
        order.validate();
        order.calculateTotal();

        // ❌ Tightly coupled to MySQL
        database.save(order);
    }
}

// Problems:
// 1. Cannot switch to MongoDB without modifying OrderService
// 2. Cannot unit test without real MySQL database
// 3. Changes to MySQL affect OrderService
// 4. High-level policy tied to low-level implementation

// ✅ DIP COMPLIANT: Both depend on abstraction

// Abstraction
interface OrderRepository {
    void save(Order order);
    Order findById(String id);
}

// Low-level implements abstraction
class MySQLOrderRepository implements OrderRepository {
    @Override
    public void save(Order order) {
        System.out.println("Saving to MySQL: " + order.getId());
    }

    @Override
    public Order findById(String id) {
        return new Order(id);
    }
}

class MongoOrderRepository implements OrderRepository {
    @Override
    public void save(Order order) {
        System.out.println("Saving to MongoDB: " + order.getId());
    }

    @Override
    public Order findById(String id) {
        return new Order(id);
    }
}

// High-level depends on abstraction
class OrderService {
    private OrderRepository repository;  // ✅ Depends on interface

    // ✅ Dependency injected from outside
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }

    public void createOrder(Order order) {
        order.validate();
        order.calculateTotal();
        repository.save(order);  // ✅ Works with any implementation
    }
}

// Usage - Dependency Injection
public class Main {
    public static void main(String[] args) {
        // Choose implementation at runtime
        OrderRepository repo = new MySQLOrderRepository();
        OrderService service = new OrderService(repo);
        service.createOrder(new Order("123"));

        // Switch to MongoDB - no changes to OrderService!
        repo = new MongoOrderRepository();
        service = new OrderService(repo);
        service.createOrder(new Order("456"));

        // For testing - use mock
        repo = new MockOrderRepository();
        service = new OrderService(repo);
    }
}