Factory Method

interface Formatlovchi
{
    public function kengaytma(): string;
    public function format(array $qatorlar): string;
}

final class CsvFormat implements Formatlovchi
{
    public function kengaytma(): string { return 'csv'; }

    public function format(array $qatorlar): string
    {
        $natija = [];
        foreach ($qatorlar as $q) {
            $natija[] = implode(',', $q);
        }
        return implode("\n", $natija);
    }
}

final class JsonFormat implements Formatlovchi
{
    public function kengaytma(): string { return 'json'; }

    public function format(array $qatorlar): string
    {
        return json_encode($qatorlar, JSON_UNESCAPED_UNICODE);
    }
}

final class MatnFormat implements Formatlovchi
{
    public function kengaytma(): string { return 'txt'; }

    public function format(array $qatorlar): string
    {
        $natija = [];
        foreach ($qatorlar as $q) {
            $natija[] = sprintf('%-12s %8s', $q[0], $q[1]);
        }
        return implode("\n", $natija);
    }
}

$malumot = [['Klaviatura', '250000'], ['Sichqoncha', '120000']];

function eskiEksport(string $tur, array $malumot): string
{
    if ($tur === 'csv') {
        $f = new CsvFormat();
    } elseif ($tur === 'json') {
        $f = new JsonFormat();
    } else {
        $f = new MatnFormat();
    }
    return "hisobot.{$f->kengaytma()}\n" . $f->format($malumot);
}

echo eskiEksport('csv', $malumot), PHP_EOL;
echo eskiEksport('json', $malumot), PHP_EOL;

final class FormatFabrikasi
{
    public static function yarat(string $tur): Formatlovchi
    {
        return match ($tur) {
            'csv'  => new CsvFormat(),
            'json' => new JsonFormat(),
            'txt'  => new MatnFormat(),
            default => throw new InvalidArgumentException(
                "Noma'lum format: {$tur}"
            ),
        };
    }
}

$malumot = [['Klaviatura', '250000'], ['Sichqoncha', '120000']];

foreach (['txt', 'csv'] as $tur) {
    $f = FormatFabrikasi::yarat($tur);
    echo "--- hisobot.{$f->kengaytma()}", PHP_EOL;
    echo $f->format($malumot), PHP_EOL;
}

try {
    FormatFabrikasi::yarat('pdf');
} catch (InvalidArgumentException $x) {
    echo 'Xato: ', $x->getMessage(), PHP_EOL;
}

abstract class HisobotChiqaruvchi
{
    // Factory Method: qaysi formatlovchi kerakligini voris hal qiladi
    abstract protected function formatlovchiYarat(): Formatlovchi;

    // Umumiy jarayon - vorislarda takrorlanmaydi
    public function chiqar(string $nom, array $malumot): string
    {
        $f = $this->formatlovchiYarat();
        $tana = $f->format($malumot);
        $qator = substr_count($tana, "\n") + 1;

        return sprintf(
            "%s.%s (%d qator)\n%s",
            $nom, $f->kengaytma(), $qator, $tana
        );
    }
}

final class CsvChiqaruvchi extends HisobotChiqaruvchi
{
    protected function formatlovchiYarat(): Formatlovchi
    {
        return new CsvFormat();
    }
}

final class JsonChiqaruvchi extends HisobotChiqaruvchi
{
    protected function formatlovchiYarat(): Formatlovchi
    {
        return new JsonFormat();
    }
}

$malumot = [['Klaviatura', '250000'], ['Sichqoncha', '120000']];

/** @var list<HisobotChiqaruvchi> $chiqaruvchilar */
$chiqaruvchilar = [new CsvChiqaruvchi(), new JsonChiqaruvchi()];

foreach ($chiqaruvchilar as $ch) {
    echo $ch->chiqar('oylik', $malumot), PHP_EOL;
}

final class XmlFormat implements Formatlovchi
{
    public function kengaytma(): string { return 'xml'; }

    public function format(array $qatorlar): string
    {
        $natija = ['<mahsulotlar>'];
        foreach ($qatorlar as $q) {
            $natija[] = "  <mahsulot nom=\"{$q[0]}\" narx=\"{$q[1]}\"/>";
        }
        $natija[] = '</mahsulotlar>';
        return implode("\n", $natija);
    }
}

final class XmlChiqaruvchi extends HisobotChiqaruvchi
{
    protected function formatlovchiYarat(): Formatlovchi
    {
        return new XmlFormat();
    }
}

$malumot = [['Klaviatura', '250000'], ['Sichqoncha', '120000']];
echo (new XmlChiqaruvchi())->chiqar('oylik', $malumot), PHP_EOL;

enum Format: string
{
    case Csv = 'csv';
    case Json = 'json';
    case Matn = 'txt';

    public function formatlovchi(): Formatlovchi
    {
        return match ($this) {
            Format::Csv  => new CsvFormat(),
            Format::Json => new JsonFormat(),
            Format::Matn => new MatnFormat(),
        };
    }
}

$malumot = [['Klaviatura', '250000']];

foreach (Format::cases() as $format) {
    $f = $format->formatlovchi();
    printf("%-5s -> %s%s", $format->value, $f->format($malumot), PHP_EOL);
}

// satrdan enum ga - noto'g'ri qiymat null qaytaradi
var_dump(Format::tryFrom('pdf'));
echo Format::from('json')->name, PHP_EOL;

final readonly class Nuqta
{
    public function __construct(public int $x, public int $y) {}

    public function __toString(): string
    {
        return "({$this->x}, {$this->y})";
    }
}

// Bitta tur, murakkab qaror yo'q - fabrika ortiqcha
echo new Nuqta(3, 4), PHP_EOL;

final readonly class Pul
{
    private function __construct(
        public int $tiyin,
        public string $valyuta,
    ) {}

    public static function somdan(float $som): self
    {
        return new self((int) round($som * 100), 'UZS');
    }

    public static function tiyindan(int $tiyin): self
    {
        return new self($tiyin, 'UZS');
    }

    public static function nol(): self
    {
        return new self(0, 'UZS');
    }

    public function qosh(self $boshqa): self
    {
        return new self($this->tiyin + $boshqa->tiyin, $this->valyuta);
    }

    public function __toString(): string
    {
        return number_format($this->tiyin / 100, 2, '.', ' ') . ' ' . $this->valyuta;
    }
}

echo Pul::somdan(12500.75), PHP_EOL;
echo Pul::tiyindan(990), PHP_EOL;
echo Pul::nol()->qosh(Pul::somdan(1500))->qosh(Pul::somdan(2.50)), PHP_EOL;