// S: Cada classe tem uma responsabilidade
class Product {
  constructor(
    public id: string,
    public name: string,
    public price: number
  ) {}
}

class Order {
  constructor(
    public id: string,
    public customerId: string,
    public items: OrderItem[] = []
  ) {}
  
  getTotal(): number {
    return this.items.reduce((sum, item) => sum + item.getSubtotal(), 0);
  }
}

class OrderItem {
  constructor(
    public product: Product,
    public quantity: number
  ) {}
  
  getSubtotal(): number {
    return this.product.price * this.quantity;
  }
}

// I: Interfaces específicas
interface OrderRepository {
  save(order: Order): Promise<void>;
  findById(id: string): Promise<Order | null>;
}

interface PaymentProcessor {
  process(amount: number, method: string): Promise<boolean>;
}

interface NotificationSender {
  send(message: string, recipient: string): Promise<void>;
}

// O: Aberto para extensão, fechado para modificação
abstract class DiscountCalculator {
  abstract calculate(order: Order): number;
}

// L: Substituição de Liskov - todas funcionam igual
class NoDiscount extends DiscountCalculator {
  calculate(order: Order): number {
    return 0;
  }
}

class PercentageDiscount extends DiscountCalculator {
  constructor(private percentage: number) {
    super();
  }
  
  calculate(order: Order): number {
    return order.getTotal() * (this.percentage / 100);
  }
}

class FixedAmountDiscount extends DiscountCalculator {
  constructor(private amount: number) {
    super();
  }
  
  calculate(order: Order): number {
    return Math.min(this.amount, order.getTotal());
  }
}

class BuyTwoGetOneDiscount extends DiscountCalculator {
  calculate(order: Order): number {
    let discount = 0;
    order.items.forEach(item => {
      const freeItems = Math.floor(item.quantity / 3);
      discount += freeItems * item.product.price;
    });
    return discount;
  }
}

// D: Dependency Inversion - depende de abstrações
class OrderService {
  constructor(
    private orderRepository: OrderRepository,
    private paymentProcessor: PaymentProcessor,
    private notificationSender: NotificationSender,
    private discountCalculator: DiscountCalculator
  ) {}
  
  async processOrder(order: Order, paymentMethod: string): Promise<boolean> {
    try {
      // Calcula desconto
      const discount = this.discountCalculator.calculate(order);
      const finalAmount = order.getTotal() - discount;
      
      // Processa pagamento
      const paymentSuccess = await this.paymentProcessor.process(
        finalAmount, 
        paymentMethod
      );
      
      if (!paymentSuccess) {
        throw new Error('Falha no pagamento');
      }
      
      // Salva pedido
      await this.orderRepository.save(order);
      
      // Envia notificação
      await this.notificationSender.send(
        `Pedido ${order.id} confirmado! Total: R$ ${finalAmount}`,
        order.customerId
      );
      
      return true;
    } catch (error) {
      console.error('Erro ao processar pedido:', error);
      return false;
    }
  }
}

// Implementações específicas
class DatabaseOrderRepository implements OrderRepository {
  async save(order: Order): Promise<void> {
    console.log(`Salvando pedido ${order.id} no banco`);
  }
  
  async findById(id: string): Promise<Order | null> {
    console.log(`Buscando pedido ${id}`);
    return null; // Simulação
  }
}

class StripePaymentProcessor implements PaymentProcessor {
  async process(amount: number, method: string): Promise<boolean> {
    console.log(`Processando R$ ${amount} via ${method}`);
    return true; // Simulação
  }
}

class EmailNotificationSender implements NotificationSender {
  async send(message: string, recipient: string): Promise<void> {
    console.log(`Email para ${recipient}: ${message}`);
  }
}

// Uso do sistema
const orderService = new OrderService(
  new DatabaseOrderRepository(),
  new StripePaymentProcessor(),
  new EmailNotificationSender(),
  new PercentageDiscount(10) // 10% de desconto
);

const order = new Order('001', 'customer123', [
  new OrderItem(new Product('p1', 'Notebook', 2000), 1),
  new OrderItem(new Product('p2', 'Mouse', 50), 2)
]);

await orderService.processOrder(order, 'credit_card');