<?php

namespace App\Infrastructure;

use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Connection as DriverConnection;
use Doctrine\DBAL\Driver\Middleware;
use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
use Doctrine\DBAL\Driver\Result;
use Doctrine\DBAL\Driver\Statement as DriverStatement;

/**
 * Counts the database queries of one request.
 *
 * Not a profiler and not a log: one number, so "how many queries does this page need" can be
 * measured instead of guessed. It is the difference between a page with ten linked sections that
 * asks once and one that asks ten times - and without counting, nobody notices the second kind
 * until the site is slow on a real host.
 *
 * The number is attached as a header outside the production environment (see
 * QueryHeaderSubscriber) and read by the browser checks.
 */
final class QueryCounter implements Middleware
{
    private int $count = 0;

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

    public function reset(): void
    {
        $this->count = 0;
    }

    public function record(): void
    {
        ++$this->count;
    }

    public function wrap(Driver $driver): Driver
    {
        return new class($driver, $this) extends AbstractDriverMiddleware {
            public function __construct(Driver $driver, private QueryCounter $counter)
            {
                parent::__construct($driver);
            }

            public function connect(array $params): DriverConnection
            {
                return new class(parent::connect($params), $this->counter) extends AbstractConnectionMiddleware {
                    public function __construct(DriverConnection $connection, private QueryCounter $counter)
                    {
                        parent::__construct($connection);
                    }

                    public function prepare(string $sql): DriverStatement
                    {
                        return new class(parent::prepare($sql), $this->counter) extends AbstractStatementMiddleware {
                            public function __construct(DriverStatement $statement, private QueryCounter $counter)
                            {
                                parent::__construct($statement);
                            }

                            public function execute(): Result
                            {
                                $this->counter->record();

                                return parent::execute();
                            }
                        };
                    }

                    public function query(string $sql): Result
                    {
                        $this->counter->record();

                        return parent::query($sql);
                    }

                    public function exec(string $sql): int|string
                    {
                        $this->counter->record();

                        return parent::exec($sql);
                    }
                };
            }
        };
    }
}