Chain of Responsibility va Iterator

function murojaatniYonaltir(string $tur, int $ogirlik): string
{
    if ($tur === 'parol' && $ogirlik <= 1) {
        return 'bot: parolni tiklash havolasi yuborildi';
    }
    if ($ogirlik <= 2) {
        return 'operator: javob berdi';
    }
    if ($ogirlik <= 4) {
        return 'muhandis: tekshirmoqda';
    }
    return 'rahbar: shaxsan qaraydi';
}

foreach ([['parol', 1], ['tolov', 2], ['xato', 4], ['buzilish', 5]] as $m) {
    printf('%-10s %d -> %s%s', $m[0], $m[1],
        murojaatniYonaltir(...$m), PHP_EOL);
}

final readonly class Murojaat
{
    public function __construct(
        public string $tur,
        public int $ogirlik,
        public string $matn,
    ) {}
}

abstract class Ishlovchi
{
    private ?Ishlovchi $keyingi = null;

    public function keyin(Ishlovchi $k): Ishlovchi
    {
        $this->keyingi = $k;
        return $k;   // zanjirni qurishni osonlashtiradi
    }

    final public function ishla(Murojaat $m): string
    {
        if ($this->menikimi($m)) {
            return $this->bajar($m);
        }

        echo "  [{$this->nomi()}] menga tegishli emas, uzatdim", PHP_EOL;

        return $this->keyingi?->ishla($m)
            ?? 'HECH KIM QARAMADI: murojaat navbatda qoldi';
    }

    abstract public function nomi(): string;
    abstract protected function menikimi(Murojaat $m): bool;
    abstract protected function bajar(Murojaat $m): string;
}

final class Bot extends Ishlovchi
{
    public function nomi(): string { return 'bot'; }

    protected function menikimi(Murojaat $m): bool
    {
        return $m->tur === 'parol' && $m->ogirlik <= 1;
    }

    protected function bajar(Murojaat $m): string
    {
        return 'bot: parolni tiklash havolasi yuborildi';
    }
}

final class Operator extends Ishlovchi
{
    public function nomi(): string { return 'operator'; }

    protected function menikimi(Murojaat $m): bool
    {
        return $m->ogirlik <= 2;
    }

    protected function bajar(Murojaat $m): string
    {
        return "operator: \"{$m->matn}\" boyicha javob berdi";
    }
}

final class Muhandis extends Ishlovchi
{
    public function nomi(): string { return 'muhandis'; }

    protected function menikimi(Murojaat $m): bool
    {
        return $m->ogirlik <= 4;
    }

    protected function bajar(Murojaat $m): string
    {
        return 'muhandis: jurnallar tekshirilmoqda';
    }
}

function zanjirQur(): Ishlovchi
{
    $bot = new Bot();
    $bot->keyin(new Operator())->keyin(new Muhandis());

    return $bot;
}

$zanjir = zanjirQur();

foreach ([
    new Murojaat('parol', 1, 'parolni unutdim'),
    new Murojaat('tolov', 2, 'pul yechildi, buyurtma yoq'),
    new Murojaat('xato', 4, 'sayt ochilmayapti'),
] as $m) {
    printf('--- %s (ogirlik %d)%s', $m->tur, $m->ogirlik, PHP_EOL);
    echo $zanjir->ishla($m), PHP_EOL;
}

$zanjir = zanjirQur();
echo $zanjir->ishla(new Murojaat('buzilish', 5, 'butun tizim ishlamayapti')),
    PHP_EOL;

$sozlama = ['operator', 'muhandis'];   // bot o'chirilgan

$xarita = [
    'bot' => static fn(): Ishlovchi => new Bot(),
    'operator' => static fn(): Ishlovchi => new Operator(),
    'muhandis' => static fn(): Ishlovchi => new Muhandis(),
];

$ishlovchilar = array_map(
    static fn(string $n): Ishlovchi => $xarita[$n](), $sozlama);

for ($i = 0; $i < count($ishlovchilar) - 1; $i++) {
    $ishlovchilar[$i]->keyin($ishlovchilar[$i + 1]);
}

echo 'zanjir: ', implode(' -> ', array_map(
    static fn(Ishlovchi $x): string => $x->nomi(), $ishlovchilar)), PHP_EOL;

echo $ishlovchilar[0]->ishla(new Murojaat('parol', 1, 'parol')), PHP_EOL;

final class Katalog
{
    /** @var array<string, list<string>> */
    private array $bolimlar = [
        'texnika' => ['Klaviatura', 'Sichqoncha'],
        'mebel' => ['Stol', 'Stul'],
    ];

    /** @return array<string, list<string>> */
    public function bolimlar(): array
    {
        return $this->bolimlar;
    }
}

// Mijoz ichki tuzilishni bilishga majbur - ikki qavat halqa
foreach ((new Katalog())->bolimlar() as $bolim => $mahsulotlar) {
    foreach ($mahsulotlar as $m) {
        echo "  {$bolim}: {$m}", PHP_EOL;
    }
}

final class Katalog2 implements IteratorAggregate, Countable
{
    /** @var array<string, array<string, list<string>>> */
    private array $malumot = [
        'texnika' => [
            'kirish' => ['Klaviatura', 'Sichqoncha'],
            'chiqish' => ['Monitor'],
        ],
        'mebel' => [
            'ish' => ['Stol', 'Stul'],
        ],
    ];

    // Uch qavatli tuzilma - lekin tashqaridan bir qavat ko'rinadi
    public function getIterator(): Generator
    {
        foreach ($this->malumot as $bolim => $guruhlar) {
            foreach ($guruhlar as $guruh => $mahsulotlar) {
                foreach ($mahsulotlar as $m) {
                    yield "{$bolim}/{$guruh}" => $m;
                }
            }
        }
    }

    public function count(): int
    {
        return iterator_count($this->getIterator());
    }
}

$katalog = new Katalog2();

echo 'jami: ', count($katalog), PHP_EOL;

// Mijoz tuzilmani bilmaydi - oddiy foreach
foreach ($katalog as $yol => $mahsulot) {
    printf('  %-16s %s%s', $yol, $mahsulot, PHP_EOL);
}

function sonlar(): Generator
{
    yield 1;
    yield 2;
    yield 3;
}

$g = sonlar();
echo 'birinchi: ', implode(', ', iterator_to_array($g)), PHP_EOL;

// o'sha generatorni qayta aylanishga urinamiz
try {
    foreach ($g as $s) {
        echo $s;
    }
} catch (Throwable $x) {
    echo 'ikkinchi: ', get_class($x), ' - ', $x->getMessage(), PHP_EOL;
}

// Yechim: har safar yangi generator
echo 'yangi:    ', implode(', ', iterator_to_array(sonlar())), PHP_EOL;

$katalog = new Katalog2();

echo 'birinchi aylanish: ', count(iterator_to_array($katalog)), ' ta', PHP_EOL;
echo 'ikkinchi aylanish: ', count(iterator_to_array($katalog)), ' ta', PHP_EOL;

$katalog = new Katalog2();

echo 'kalitlar bilan: ', count(iterator_to_array($katalog)), PHP_EOL;
echo 'kalitsiz:       ', count(iterator_to_array($katalog, false)), PHP_EOL;

foreach (iterator_to_array($katalog) as $kalit => $qiymat) {
    printf('  %-16s %s%s', $kalit, $qiymat, PHP_EOL);
}

// Massiv - hammasi xotirada
$boshlanish = memory_get_usage();
$massiv = range(1, 200000);
$massivXotira = memory_get_usage() - $boshlanish;
unset($massiv);

// Generator - bir vaqtda bitta element
function katta(int $n): Generator
{
    for ($i = 1; $i <= $n; $i++) {
        yield $i;
    }
}

$boshlanish = memory_get_usage();
$gen = katta(200000);
$jami = 0;
foreach ($gen as $s) {
    $jami += $s;
}
$genXotira = memory_get_usage() - $boshlanish;

printf('massiv:    %6d KB%s', intdiv($massivXotira, 1024), PHP_EOL);
printf('generator: %6d KB%s', intdiv($genXotira, 1024), PHP_EOL);
printf('yigindi bir xil: %s%s',
    $jami === array_sum(range(1, 200000)) ? 'ha' : 'yoq', PHP_EOL);

function texnika(): Generator
{
    yield 'Klaviatura';
    yield 'Sichqoncha';
}

function mebel(): Generator
{
    yield 'Stol';
    yield 'Stul';
}

function hammasi(): Generator
{
    yield from texnika();
    yield from mebel();
    yield 'Qalam';
}

foreach (hammasi() as $i => $m) {
    printf('  %d. %s%s', $i, $m, PHP_EOL);
}