Author: F. Sanches

<?php
// interface defines a contract — all notification classes must have a send() method.
interface Notification
{
    public function send(string $to, string $message): void;
}

// Concrete implementations of different notification types

class EmailNotification implements Notification
{
    public function send(string $to, string $message): void
    {
        echo "Sending EMAIL to {$to}: {$message}" . PHP_EOL;
    }
}

class SmsNotification implements Notification
{
    public function send(string $to, string $message): void
    {
        echo "Sending SMS to {$to}: {$message}" . PHP_EOL;
    }
}

class PushNotification implements Notification
{
    public function send(string $to, string $message): void
    {
        echo "Sending PUSH notification to {$to}: {$message}" . PHP_EOL;
    }
}

// The Factory class — decides which notification to create
class NotificationFactory
{
    public static function create(string $type): Notification
    {
        return match (strtolower($type)) {
            'email' => new EmailNotification(),
            'sms'   => new SmsNotification(),
            'push'  => new PushNotification(),
            default => throw new InvalidArgumentException("Unknown notification type: {$type}")
        };
    }
}

// Usage exemple
try {
    $notification = NotificationFactory::create('email');
    $notification->send('user@example.com', 'Your order has been shipped.');

    $notification = NotificationFactory::create('sms');
    $notification->send('+5547999999999', 'Your code is 123456.');

    $notification = NotificationFactory::create('push');
    $notification->send('User123', 'You have a new message.');
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

<?php

class Logger
{
    private static ?Logger $uniqueInstance = null;
    private array $logs = [];

    // prevents direct instantiation
    private function __construct() {}

    // no one outside the class can duplicate the instance.
    private function __clone() {}

    /* __wakeup must be public (by PHP’s design), 
    since it’s automatically called during unserialize().*/
    public function __wakeup()
    {
        throw new \Exception("Cannot unserialize a singleton.");
    }

    /* Lazy construction / initialization - returns the single instance 
    of this class*/
    public static function getInstance(): Logger
    {
        if (self::$uniqueInstance === null) {
            self::$uniqueInstance = new Logger();
        }
        return self::$uniqueInstance;
    }

    // Methods
    public function addLog(string $message): void
    {
        $this->logs[] = $message;
    }

    public function showLogs(): void
    {
        foreach ($this->logs as $log) {
            echo $log . PHP_EOL;
        }
    }
}

// Usage exemple
$logger1 = Logger::getInstance();
$logger2 = Logger::getInstance();

$logger1->addLog("First log entry.");
$logger2->addLog("Second log entry.");

$logger1->showLogs();

//Checking the solid proof...

if ($logger1 === $logger2) {
    echo "Same instance" . PHP_EOL;
} else {
    echo "Different instances" . PHP_EOL;
}

echo "Logger1 ID: " . spl_object_id($logger1) . PHP_EOL;
echo "Logger2 ID: " . spl_object_id($logger2) . PHP_EOL;

/*
Output:

First log entry.
Second log entry.
Same instance
Logger1 ID: 1
Logger2 ID: 1
*/

class FileLogger extends Logger {}
FileLogger::getInstance(); //still returns the instance of Logger, not a instance of FileLogger

public static function getInstance(): Logger 
{
    $className = static::class;
    if (!isset(self::$uniqueInstance[$className])) {
        self::$uniqueInstance[$className] = new static();
    }
    return self::$uniqueInstance[$className];
}

<?php

class Vehicle
{
    public function move()
    {
        echo "The vehicle is moving\n";
    }
}

class Car extends Vehicle   // Car *is-a* Vehicle
{
}

$car = new Car();
$car->move(); // inherited

<?php

class Engine
{
    public function start()
    {
        echo "Engine started\n";
    }
}

class Car
{
    private Engine $engine; // Car *has-a* Engine

    public function __construct()
    {
        $this->engine = new Engine();
    }

    public function turnOn()
    {
        $this->engine->start();
    }
}

$car = new Car();
$car->turnOn();

//Interface
<?php

interface EngineInterface
{
    public function start(): void;
}

//Different engines
class DieselEngine implements EngineInterface
{
    public function start(): void
    {
        echo "Diesel engine roaring...\n";
    }
}

class GasEngine implements EngineInterface
{
    public function start(): void
    {
        echo "Gas engine starting...\n";
    }
}

class AlcoholEngine implements EngineInterface
{
    public function start(): void
    {
        echo "Alcohol engine warming up...\n";
    }
}

//Car uses composition + dependency injection
class Car
{
    private EngineInterface $engine; // Car *has-a* Engine

    public function __construct(EngineInterface $engine)
    {
        $this->engine = $engine;
    }

    public function turnOn(): void
    {
        $this->engine->start();
    }
}

//Using it...
$RangeRover = new Car(new DieselEngine());
$RangeRover->turnOn();

$Civic = new Car(new GasEngine());
$Civic->turnOn();

$Fiat147 = new Car(new AlcoholEngine());
$Fiat147->turnOn();

/*
Output:

Diesel engine roaring...
Gas engine starting...
Alcohol engine warming up...
*/