Ejercicios de práctica

class OrderService
{
    public function getTotalForCustomer(Order $order): float
    {
        return $this->applyMemberDiscount($order);
    }

    public function getTotalForInvoice(Order $order): float
    {
        return $this->applyMemberDiscount($order);
    }

    private function applyMemberDiscount(Order $order): float
    {
        if ($order->customer->isMember()) {
            return $order->subtotal * 0.90;
        }
        return $order->subtotal;
    }
}

// Para lo que el proyecto necesita hoy:
function validateOrderForm(array $data): array
{
    $errors = [];
    if (empty($data['email']))   $errors['email']   = 'Email requerido';
    if (empty($data['address'])) $errors['address'] = 'Dirección requerida';
    return $errors;
}

class CheckoutService
{
    public function checkout(Cart $cart, array $paymentData): Order
    {
        $this->validateCart($cart);
        $total  = $this->calculateTotal($cart);
        $txId   = $this->charge($total, $paymentData['token']);
        return $this->createOrder($cart, $total, $txId);
    }

    private function validateCart(Cart $cart): void
    {
        if ($cart->items()->isEmpty()) {
            throw new \Exception('El carrito está vacío');
        }
        foreach ($cart->items() as $item) {
            if ($item->product->stock < $item->quantity) {
                throw new \Exception("Sin stock: {$item->product->name}");
            }
        }
    }

    private function calculateTotal(Cart $cart): float
    {
        $subtotal = $cart->items()->sum(fn($i) => $i->product->price * $i->quantity);
        $discount = $cart->customer->isMember() ? $subtotal * 0.10 : 0;
        return $subtotal - $discount;
    }

    private function charge(float $total, string $token): string
    {
        $result = (new WompiGateway())->charge($total, $token);
        if ($result['estado'] !== 'APROBADO') {
            throw new PaymentException('Pago rechazado');
        }
        return $result['id_transaccion'];
    }

    private function createOrder(Cart $cart, float $total, string $txId): Order
    {
        $order = Order::create([
            'customer_id' => $cart->customer_id,
            'total'       => $total,
            'tx_id'       => $txId,
        ]);
        foreach ($cart->items() as $item) {
            $order->items()->create([
                'product_id' => $item->product_id,
                'quantity'   => $item->quantity,
                'price'      => $item->product->price,
            ]);
        }
        return $order;
    }
}

// Solo existe PDF hoy. Cuando llegue otro formato, extraemos la interfaz.
class ReportService
{
    public function generatePdf(array $data): string
    {
        // lógica de PDF
    }
}

// User: solo datos del dominio
class User
{
    public function __construct(
        public readonly string $name,
        public readonly string $email,
        public readonly string $passwordHash,
    ) {}

    public function toArray(): array
    {
        return ['name' => $this->name, 'email' => $this->email];
    }
}

// Responsabilidad de persistencia
class UserRepository
{
    public function save(User $user): void
    {
        DB::table('users')->insert($user->toArray());
    }
}

// Responsabilidad de notificación
class UserMailer
{
    public function sendWelcome(User $user): void
    {
        mail($user->email, 'Bienvenido', "Hola {$user->name}");
    }
}

// Responsabilidad de autenticación
class PasswordHasher
{
    public function hash(string $plain): string
    {
        return password_hash($plain, PASSWORD_BCRYPT);
    }
}

interface ReportFormatter
{
    public function format(Report $report): string;
}

class CsvFormatter implements ReportFormatter
{
    public function format(Report $report): string
    {
        return implode("\n", array_map(fn($r) => implode(',', $r), $report->rows));
    }
}

class JsonFormatter implements ReportFormatter
{
    public function format(Report $report): string
    {
        return json_encode($report->rows);
    }
}

class HtmlFormatter implements ReportFormatter
{
    public function format(Report $report): string
    {
        $rows = array_map(
            fn($r) => '<tr><td>' . implode('</td><td>', $r) . '</td></tr>',
            $report->rows
        );
        return '<table>' . implode('', $rows) . '</table>';
    }
}

class ReportExporter
{
    public function export(Report $report, ReportFormatter $formatter): string
    {
        return $formatter->format($report);
    }
}

// Separar por capacidad, no por jerarquía de "tipo de archivo"
interface Readable
{
    public function read(): string;
}

interface Writable
{
    public function write(string $content): void;
}

interface Deletable
{
    public function delete(): void;
}

class File implements Readable, Writable, Deletable
{
    public function read(): string  { /* ... */ }
    public function write(string $content): void { /* ... */ }
    public function delete(): void  { /* ... */ }
}

class ReadOnlyFile implements Readable
{
    public function read(): string { /* ... */ }
    // No implementa Writable ni Deletable — esas operaciones no existen
}

// El cliente ahora declara lo que necesita:
function appendLog(Readable&Writable $file, string $msg): void
{
    $file->write($file->read() . "\n" . $msg);
}

interface Workable
{
    public function work(): void;
}

interface Eatable
{
    public function eat(): void;
}

interface Sleepable
{
    public function sleep(): void;
}

class HumanWorker implements Workable, Eatable, Sleepable
{
    public function work(): void  { echo 'trabajando'; }
    public function eat(): void   { echo 'comiendo'; }
    public function sleep(): void { echo 'durmiendo'; }
}

class RobotWorker implements Workable
{
    public function work(): void { echo 'trabajando'; }
    // No implementa lo que no aplica — sin métodos vacíos ni excepciones
}

// Abstracción — define el contrato, no la implementación
interface MailerInterface
{
    public function send(string $to, string $subject, string $body): void;
}

// Implementación concreta
class SendGridMailer implements MailerInterface
{
    public function send(string $to, string $subject, string $body): void
    {
        // llama a SendGrid
    }
}

// Para tests
class FakeMailer implements MailerInterface
{
    public array $sent = [];
    public function send(string $to, string $subject, string $body): void
    {
        $this->sent[] = compact('to', 'subject', 'body');
    }
}

// La dependencia se inyecta, no se construye
class OrderService
{
    public function __construct(private MailerInterface $mailer) {}

    public function confirm(Order $order): void
    {
        $order->status = 'confirmed';
        $order->save();

        $this->mailer->send(
            to:      $order->customer->email,
            subject: 'Tu pedido fue confirmado',
            body:    "Pedido #{$order->id} confirmado."
        );
    }
}

interface ShippingStrategy
{
    public function calculateCost(Order $order): float;
}

class CorreosShipping implements ShippingStrategy
{
    public function calculateCost(Order $order): float
    {
        return $order->weight * 2.50;
    }
}

class FedExShipping implements ShippingStrategy
{
    public function calculateCost(Order $order): float
    {
        $base = 5.00;
        if ($order->weight > 5) $base += ($order->weight - 5) * 3.00;
        return $base;
    }
}

class PickupShipping implements ShippingStrategy
{
    public function calculateCost(Order $order): float
    {
        return 0.0;
    }
}

// La estrategia entra por el constructor. Agregar DHL = nueva clase; ShippingService nunca cambia.
class ShippingService
{
    public function __construct(private ShippingStrategy $strategy) {}

    public function calculateCost(Order $order): float
    {
        return $this->strategy->calculateCost($order);
    }
}

// Quien arma el servicio elige la estrategia:
$service = new ShippingService(new FedExShipping());

abstract class ProductImporter
{
    // Template Method: el esqueleto es final — las subclases no lo redefinen
    final public function import(string $path): void
    {
        $raw  = file_get_contents($path);
        $rows = $this->parse($raw);        // paso variable
        $this->validate($rows);
        $this->save($rows);
    }

    // Paso variable — cada subclase lo implementa
    abstract protected function parse(string $raw): array;

    // Pasos comunes — definidos una sola vez
    protected function validate(array $rows): void
    {
        foreach ($rows as $row) {
            if (!isset($row['name'], $row['price'], $row['stock'])) {
                throw new \Exception('Fila inválida');
            }
        }
    }

    protected function save(array $rows): void
    {
        foreach ($rows as $row) {
            Product::create($row);
        }
    }
}

class CsvImporter extends ProductImporter
{
    protected function parse(string $raw): array
    {
        // Solo separa en columnas — la validación de forma vive en validate()
        return array_map(
            function ($line) {
                $cols = str_getcsv($line);
                return ['name' => $cols[0] ?? null, 'price' => $cols[1] ?? null, 'stock' => $cols[2] ?? null];
            },
            explode("\n", trim($raw))
        );
    }
}

class JsonImporter extends ProductImporter
{
    protected function parse(string $raw): array
    {
        return json_decode($raw, true);
    }
}

interface OrderState
{
    // Cada método devuelve el estado siguiente. Ahí vive la transición.
    public function pay(): OrderState;
    public function ship(): OrderState;
}

class PendingState implements OrderState
{
    public function pay(): OrderState  { return new PaidState(); }
    public function ship(): OrderState { throw new \Exception('Debe pagarse primero'); }
}

class PaidState implements OrderState
{
    public function pay(): OrderState  { throw new \Exception('Ya está pagado'); }
    public function ship(): OrderState { return new ShippedState(); }
}

class ShippedState implements OrderState
{
    public function pay(): OrderState  { throw new \Exception('Ya fue enviado'); }
    public function ship(): OrderState { throw new \Exception('Ya fue enviado'); }
}

class CancelledState implements OrderState
{
    public function pay(): OrderState  { throw new \Exception('Está cancelado'); }
    public function ship(): OrderState { throw new \Exception('Está cancelado'); }
}

class Order
{
    private OrderState $state;

    public function __construct()
    {
        $this->state = new PendingState();
    }

    // El contexto reasigna su estado con lo que devuelve la transición.
    public function pay(): void  { $this->state = $this->state->pay(); }
    public function ship(): void { $this->state = $this->state->ship(); }
}

interface Command
{
    public function execute(): void;
    public function undo(): void;
}

class CancelOrderCommand implements Command
{
    private string $previousStatus;

    public function __construct(private Order $order) {}

    public function execute(): void
    {
        $this->previousStatus = $this->order->status;
        $this->order->status  = 'cancelled';
        $this->order->save();
        Log::info("Orden #{$this->order->id} cancelada");
    }

    public function undo(): void
    {
        $this->order->status = $this->previousStatus;
        $this->order->save();
    }
}

class RefundOrderCommand implements Command
{
    public function __construct(private Order $order) {}

    public function execute(): void
    {
        $this->order->status   = 'refunded';
        $this->order->refunded = true;
        $this->order->save();
        Log::info("Orden #{$this->order->id} reembolsada");
    }

    public function undo(): void { /* lógica de reversar el reembolso */ }
}

class PrioritizeOrderCommand implements Command
{
    private string $previousPriority;

    public function __construct(private Order $order) {}

    public function execute(): void
    {
        $this->previousPriority = $this->order->priority;
        $this->order->priority  = 'high';
        $this->order->save();
        Log::info("Orden #{$this->order->id} priorizada");
    }

    public function undo(): void
    {
        $this->order->priority = $this->previousPriority;
        $this->order->save();
    }
}

// El invoker mantiene historial — no sabe qué hace cada comando
class AdminPanel
{
    private array $history = [];

    public function execute(Command $command): void
    {
        $command->execute();
        $this->history[] = $command;
    }

    public function undoLast(): void
    {
        $command = array_pop($this->history);
        $command?->undo();
    }
}

interface Notifier
{
    public function send(string $recipient, string $message): void;
}

class EmailNotifier implements Notifier
{
    public function send(string $recipient, string $message): void { /* envía email */ }
}

class SmsNotifier implements Notifier
{
    public function send(string $recipient, string $message): void { /* envía SMS */ }
}

class PushNotifier implements Notifier
{
    public function send(string $recipient, string $message): void { /* envía push */ }
}

// El factory: un mapa canal → clase concreta. La decisión vive acá, en un solo lugar.
class NotifierFactory
{
    private array $map = [
        'email' => EmailNotifier::class,
        'sms'   => SmsNotifier::class,
        'push'  => PushNotifier::class,
    ];

    public function create(string $channel): Notifier
    {
        if (!isset($this->map[$channel])) {
            throw new \Exception("Canal desconocido: {$channel}");
        }
        return new $this->map[$channel]();
    }
}

// El consumidor recibe el factory y pide un notificador — no sabe qué clase concreta es.
class OrderService
{
    public function __construct(private NotifierFactory $factory) {}

    public function notifyCustomer(string $channel, string $customer): void
    {
        $notifier = $this->factory->create($channel);
        $notifier->send($customer, 'Tu pedido #42 fue confirmado.');
    }
}

// Agregar WhatsApp = una línea en el mapa. OrderService no cambia.