# Violation du DIP — le module de haut niveau dépend du module de bas niveau

class OrderService:
    def __init__(self):
        self.db = PostgreSQLDatabase(host="localhost", port=5432)  # dépendance directe
        self.email = SendgridEmailClient(api_key="...")              # dépendance directe

    def create_order(self, order_data):
        order_id = self.db.save(order_data)
        self.email.send_confirmation(order_data["email"], order_id)
        return order_id

Sans DIP :
OrderService → PostgreSQLDatabase
OrderService → SendgridEmailClient

Avec DIP :
OrderService → OrderRepository (abstraction) ← PostgreSQLOrderRepository (implémentation)
OrderService → EmailNotifier (abstraction)   ← SendgridEmailNotifier (implémentation)

from abc import ABC, abstractmethod

class OrderRepository(ABC):
    @abstractmethod
    def save(self, order_data: dict) -> str:
        pass

class EmailNotifier(ABC):
    @abstractmethod
    def send_confirmation(self, email: str, order_id: str) -> None:
        pass

# Le module de haut niveau — dépend uniquement des abstractions
class OrderService:
    def __init__(self, repository: OrderRepository, notifier: EmailNotifier):
        self.repository = repository
        self.notifier = notifier

    def create_order(self, order_data: dict) -> str:
        order_id = self.repository.save(order_data)
        self.notifier.send_confirmation(order_data["email"], order_id)
        return order_id

# Les implémentations concrètes
class PostgreSQLOrderRepository(OrderRepository):
    def save(self, order_data: dict) -> str:
        return self.db.execute("INSERT INTO orders ...", order_data)

class SendgridEmailNotifier(EmailNotifier):
    def send_confirmation(self, email: str, order_id: str) -> None:
        self.client.send(to=email, template="order_confirmation", data={"order_id": order_id})

# Composition à la racine de l'application
def create_order_service():
    repository = PostgreSQLOrderRepository(db)
    notifier = SendgridEmailNotifier(api_key=os.getenv("SENDGRID_KEY"))
    return OrderService(repository, notifier)

# Test sans base de données ni Sendgrid — s'exécute en millisecondes
class InMemoryOrderRepository(OrderRepository):
    def __init__(self):
        self.orders = {}

    def save(self, order_data: dict) -> str:
        order_id = str(uuid.uuid4())
        self.orders[order_id] = order_data
        return order_id

def test_create_order():
    repository = InMemoryOrderRepository()
    notifier = MockEmailNotifier()
    service = OrderService(repository, notifier)

    order_id = service.create_order({"email": "user@example.com", "items": [...]})

    assert order_id in repository.orders
    assert len(notifier.sent_confirmations) == 1

// Les abstractions (interfaces TypeScript)
interface OrderRepository {
    save(orderData: OrderData): Promise<string>;
    findById(orderId: string): Promise<Order | null>;
}

interface PaymentGateway {
    charge(amount: number, currency: string, paymentMethod: string): Promise<PaymentResult>;
}

// Le module de haut niveau
class OrderService {
    constructor(
        private readonly repository: OrderRepository,
        private readonly payment: PaymentGateway
    ) {}

    async createPaidOrder(orderData: OrderData): Promise<Order> {
        const paymentResult = await this.payment.charge(
            orderData.total,
            orderData.currency,
            orderData.paymentMethodId
        );

        if (!paymentResult.success) {
            throw new PaymentFailedError(paymentResult.errorCode);
        }

        const orderId = await this.repository.save({
            ...orderData,
            paymentId: paymentResult.transactionId,
            status: 'paid'
        });

        return this.repository.findById(orderId);
    }
}

// Test — sans Stripe, sans base de données
describe('OrderService', () => {
    it('should create order with successful payment', async () => {
        const mockRepository: OrderRepository = {
            save: jest.fn().mockResolvedValue('order-123'),
            findById: jest.fn().mockResolvedValue({ id: 'order-123', status: 'paid' })
        };

        const mockPayment: PaymentGateway = {
            charge: jest.fn().mockResolvedValue({ success: true, transactionId: 'txn-456' })
        };

        const service = new OrderService(mockRepository, mockPayment);
        const order = await service.createPaidOrder({ total: 1000, currency: 'EUR' });

        expect(order.status).toBe('paid');
    });
});

// L'abstraction
public interface NotificationService {
    void sendOrderConfirmation(String userId, String orderId);
    void sendShippingUpdate(String userId, String orderId, String trackingCode);
}

// Le module de haut niveau (service métier)
@Service
public class OrderFulfillmentService {

    private final OrderRepository orderRepository;
    private final NotificationService notificationService;

    public OrderFulfillmentService(
            OrderRepository orderRepository,
            NotificationService notificationService) {
        this.orderRepository = orderRepository;
        this.notificationService = notificationService;
    }

    public void fulfillOrder(String orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));

        order.setStatus(OrderStatus.FULFILLING);
        orderRepository.save(order);

        notificationService.sendOrderConfirmation(order.getUserId(), orderId);
    }
}

// Implémentation de test
@Service
@Profile("test")
public class MockNotificationService implements NotificationService {

    private final List<String> sentNotifications = new ArrayList<>();

    @Override
    public void sendOrderConfirmation(String userId, String orderId) {
        sentNotifications.add("confirmation:" + userId + ":" + orderId);
    }
}