OOP & SOLIDشرح عام.

class Car
{
    // properties (data)
    public string $color;
    public int $speed = 0;

    // method (behavior)
    public function accelerate(int $amount): void
    {
        $this->speed += $amount;
    }
}

// an object = an instance of the class
$myCar = new Car();
$myCar->color = 'red';
$myCar->accelerate(50);

class BankAccount
{
    // hidden — can't touch directly
    private float $balance = 0;

    public function deposit(float $amount): void
    {
        // validation protects the data
        if ($amount <= 0) {
            throw new \InvalidArgumentException();
        }
        $this->balance += $amount;
    }

    public function getBalance(): float
    {
        return $this->balance;
    }
}

// $account->balance = -999;  ❌ not allowed
$account->deposit(100); // ✓ only safe way

class Animal
{
    public function breathe(): string
    {
        return 'breathing...';
    }
}

// Dog inherits everything from Animal
class Dog extends Animal
{
    // adds its own behavior
    public function bark(): string
    {
        return 'Woof!';
    }
}

$dog = new Dog();
$dog->breathe(); // inherited
$dog->bark();    // its own

interface Animal
{
    public function makeSound(): string;
}

class Dog implements Animal {
    public function makeSound(): string { return 'Woof'; }
}
class Cat implements Animal {
    public function makeSound(): string { return 'Meow'; }
}

// same call, different behavior
function printSound(Animal $a) {
    echo $a->makeSound();
}
printSound(new Dog()); // Woof
printSound(new Cat()); // Meow

// the "what" — a clean contract
interface PaymentInterface
{
    public function pay(float $amount): bool;
}

// the "how" — hidden complexity
class StripePayment implements PaymentInterface
{
    public function pay(float $amount): bool
    {
        // complex Stripe API calls hidden here
        return true;
    }
}

// caller only knows "pay" exists
function checkout(PaymentInterface $p) {
    $p->pay(100);
}

class User
{
    public function save() { /* DB logic */ }
    public function sendEmail() { /* email logic */ }
    public function generateReport() { /* report */ }
    // 3 responsibilities in one class!
}

class User { /* just user data */ }
class UserRepository { public function save() {} }
class EmailService { public function send() {} }
class ReportGenerator { public function generate() {} }

interface Discount {
    public function apply(float $total): float;
}

// add new discounts WITHOUT touching old code
class SummerDiscount implements Discount {
    public function apply(float $total): float {
        return $total * 0.9;
    }
}
class VipDiscount implements Discount {
    public function apply(float $total): float {
        return $total * 0.8;
    }
}

class Bird {
    public function fly() { return 'flying'; }
}
class Penguin extends Bird {
    public function fly() {
        throw new \Exception("Can't fly!");
        // breaks code expecting a Bird to fly
    }
}

interface Worker {
    public function work();
    public function eat();
    public function sleep();
}

// A robot must implement eat() & sleep()?!
class Robot implements Worker {
    public function eat() { /* useless */ }
    public function sleep() { /* useless */ }
}

interface Workable { public function work(); }
interface Eatable   { public function eat(); }

// Robot only takes what it needs
class Robot implements Workable {
    public function work() {}
}

class OrderService
{
    private $mailer;
    public function __construct() {
        // locked to a specific class
        $this->mailer = new GmailMailer();
    }
}

class OrderService
{
    // depends on abstraction — any mailer works
    public function __construct(
        private readonly MailerInterface $mailer
    ) {}
}