<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace DynamicOOOS\Symfony\Component\Cache\Traits;

use DynamicOOOS\Doctrine\DBAL\Connection;
use DynamicOOOS\Doctrine\DBAL\DBALException;
use DynamicOOOS\Doctrine\DBAL\Driver\ServerInfoAwareConnection;
use DynamicOOOS\Doctrine\DBAL\DriverManager;
use DynamicOOOS\Doctrine\DBAL\Exception;
use DynamicOOOS\Doctrine\DBAL\Exception\TableNotFoundException;
use DynamicOOOS\Doctrine\DBAL\ParameterType;
use DynamicOOOS\Doctrine\DBAL\Schema\Schema;
use DynamicOOOS\Doctrine\DBAL\Statement;
use DynamicOOOS\Symfony\Component\Cache\Exception\InvalidArgumentException;
use DynamicOOOS\Symfony\Component\Cache\Marshaller\DefaultMarshaller;
use DynamicOOOS\Symfony\Component\Cache\Marshaller\MarshallerInterface;
/**
 * @internal
 */
trait PdoTrait
{
    private $marshaller;
    private $conn;
    private $dsn;
    private $driver;
    private $serverVersion;
    private $table = 'cache_items';
    private $idCol = 'item_id';
    private $dataCol = 'item_data';
    private $lifetimeCol = 'item_lifetime';
    private $timeCol = 'item_time';
    private $username = '';
    private $password = '';
    private $connectionOptions = [];
    private $namespace;
    private function init($connOrDsn, string $namespace, int $defaultLifetime, array $options, ?MarshallerInterface $marshaller)
    {
        if (isset($namespace[0]) && \preg_match('#[^-+.A-Za-z0-9]#', $namespace, $match)) {
            throw new InvalidArgumentException(\sprintf('Namespace contains "%s" but only characters in [-+.A-Za-z0-9] are allowed.', $match[0]));
        }
        if ($connOrDsn instanceof \PDO) {
            if (\PDO::ERRMODE_EXCEPTION !== $connOrDsn->getAttribute(\PDO::ATTR_ERRMODE)) {
                throw new InvalidArgumentException(\sprintf('"%s" requires PDO error mode attribute be set to throw Exceptions (i.e. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION)).', __CLASS__));
            }
            $this->conn = $connOrDsn;
        } elseif ($connOrDsn instanceof Connection) {
            $this->conn = $connOrDsn;
        } elseif (\is_string($connOrDsn)) {
            $this->dsn = $connOrDsn;
        } else {
            throw new InvalidArgumentException(\sprintf('"%s" requires PDO or Doctrine\\DBAL\\Connection instance or DSN string as first argument, "%s" given.', __CLASS__, \is_object($connOrDsn) ? \get_class($connOrDsn) : \gettype($connOrDsn)));
        }
        $this->table = $options['db_table'] ?? $this->table;
        $this->idCol = $options['db_id_col'] ?? $this->idCol;
        $this->dataCol = $options['db_data_col'] ?? $this->dataCol;
        $this->lifetimeCol = $options['db_lifetime_col'] ?? $this->lifetimeCol;
        $this->timeCol = $options['db_time_col'] ?? $this->timeCol;
        $this->username = $options['db_username'] ?? $this->username;
        $this->password = $options['db_password'] ?? $this->password;
        $this->connectionOptions = $options['db_connection_options'] ?? $this->connectionOptions;
        $this->namespace = $namespace;
        $this->marshaller = $marshaller ?? new DefaultMarshaller();
        parent::__construct($namespace, $defaultLifetime);
    }
    /**
     * Creates the table to store cache items which can be called once for setup.
     *
     * Cache ID are saved in a column of maximum length 255. Cache data is
     * saved in a BLOB.
     *
     * @throws \PDOException    When the table already exists
     * @throws DBALException    When the table already exists
     * @throws Exception        When the table already exists
     * @throws \DomainException When an unsupported PDO driver is used
     */
    public function createTable()
    {
        // connect if we are not yet
        $conn = $this->getConnection();
        if ($conn instanceof Connection) {
            $types = ['mysql' => 'binary', 'sqlite' => 'text', 'pgsql' => 'string', 'oci' => 'string', 'sqlsrv' => 'string'];
            if (!isset($types[$this->driver])) {
                throw new \DomainException(\sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver));
            }
            $schema = new Schema();
            $table = $schema->createTable($this->table);
            $table->addColumn($this->idCol, $types[$this->driver], ['length' => 255]);
            $table->addColumn($this->dataCol, 'blob', ['length' => 16777215]);
            $table->addColumn($this->lifetimeCol, 'integer', ['unsigned' => \true, 'notnull' => \false]);
            $table->addColumn($this->timeCol, 'integer', ['unsigned' => \true]);
            $table->setPrimaryKey([$this->idCol]);
            foreach ($schema->toSql($conn->getDatabasePlatform()) as $sql) {
                if (\method_exists($conn, 'executeStatement')) {
                    $conn->executeStatement($sql);
                } else {
                    $conn->exec($sql);
                }
            }
            return;
        }
        switch ($this->driver) {
            case 'mysql':
                // We use varbinary for the ID column because it prevents unwanted conversions:
                // - character set conversions between server and client
                // - trailing space removal
                // - case-insensitivity
                // - language processing like é == e
                $sql = "CREATE TABLE {$this->table} ({$this->idCol} VARBINARY(255) NOT NULL PRIMARY KEY, {$this->dataCol} MEDIUMBLOB NOT NULL, {$this->lifetimeCol} INTEGER UNSIGNED, {$this->timeCol} INTEGER UNSIGNED NOT NULL) COLLATE utf8_bin, ENGINE = InnoDB";
                break;
            case 'sqlite':
                $sql = "CREATE TABLE {$this->table} ({$this->idCol} TEXT NOT NULL PRIMARY KEY, {$this->dataCol} BLOB NOT NULL, {$this->lifetimeCol} INTEGER, {$this->timeCol} INTEGER NOT NULL)";
                break;
            case 'pgsql':
                $sql = "CREATE TABLE {$this->table} ({$this->idCol} VARCHAR(255) NOT NULL PRIMARY KEY, {$this->dataCol} BYTEA NOT NULL, {$this->lifetimeCol} INTEGER, {$this->timeCol} INTEGER NOT NULL)";
                break;
            case 'oci':
                $sql = "CREATE TABLE {$this->table} ({$this->idCol} VARCHAR2(255) NOT NULL PRIMARY KEY, {$this->dataCol} BLOB NOT NULL, {$this->lifetimeCol} INTEGER, {$this->timeCol} INTEGER NOT NULL)";
                break;
            case 'sqlsrv':
                $sql = "CREATE TABLE {$this->table} ({$this->idCol} VARCHAR(255) NOT NULL PRIMARY KEY, {$this->dataCol} VARBINARY(MAX) NOT NULL, {$this->lifetimeCol} INTEGER, {$this->timeCol} INTEGER NOT NULL)";
                break;
            default:
                throw new \DomainException(\sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver));
        }
        if ($conn instanceof Connection && \method_exists($conn, 'executeStatement')) {
            $conn->executeStatement($sql);
        } else {
            $conn->exec($sql);
        }
    }
    /**
     * {@inheritdoc}
     */
    public function prune()
    {
        $deleteSql = "DELETE FROM {$this->table} WHERE {$this->lifetimeCol} + {$this->timeCol} <= :time";
        if ('' !== $this->namespace) {
            $deleteSql .= " AND {$this->idCol} LIKE :namespace";
        }
        $connection = $this->getConnection();
        $useDbalConstants = $connection instanceof Connection;
        try {
            $delete = $connection->prepare($deleteSql);
        } catch (TableNotFoundException $e) {
            return \true;
        } catch (\PDOException $e) {
            return \true;
        }
        $delete->bindValue(':time', \time(), $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        if ('' !== $this->namespace) {
            $delete->bindValue(':namespace', \sprintf('%s%%', $this->namespace), $useDbalConstants ? ParameterType::STRING : \PDO::PARAM_STR);
        }
        try {
            // Doctrine DBAL ^2.13 || >= 3.1
            if ($delete instanceof Statement && \method_exists($delete, 'executeStatement')) {
                $delete->executeStatement();
                return \true;
            }
            return $delete->execute();
        } catch (TableNotFoundException $e) {
            return \true;
        } catch (\PDOException $e) {
            return \true;
        }
    }
    /**
     * {@inheritdoc}
     */
    protected function doFetch(array $ids)
    {
        $connection = $this->getConnection();
        $useDbalConstants = $connection instanceof Connection;
        $now = \time();
        $expired = [];
        $sql = \str_pad('', (\count($ids) << 1) - 1, '?,');
        $sql = "SELECT {$this->idCol}, CASE WHEN {$this->lifetimeCol} IS NULL OR {$this->lifetimeCol} + {$this->timeCol} > ? THEN {$this->dataCol} ELSE NULL END FROM {$this->table} WHERE {$this->idCol} IN ({$sql})";
        $stmt = $connection->prepare($sql);
        $stmt->bindValue($i = 1, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        foreach ($ids as $id) {
            $stmt->bindValue(++$i, $id);
        }
        $result = $stmt->execute();
        if (\is_object($result)) {
            $result = $result->iterateNumeric();
        } else {
            $stmt->setFetchMode(\PDO::FETCH_NUM);
            $result = $stmt;
        }
        foreach ($result as $row) {
            if (null === $row[1]) {
                $expired[] = $row[0];
            } else {
                (yield $row[0] => $this->marshaller->unmarshall(\is_resource($row[1]) ? \stream_get_contents($row[1]) : $row[1]));
            }
        }
        if ($expired) {
            $sql = \str_pad('', (\count($expired) << 1) - 1, '?,');
            $sql = "DELETE FROM {$this->table} WHERE {$this->lifetimeCol} + {$this->timeCol} <= ? AND {$this->idCol} IN ({$sql})";
            $stmt = $connection->prepare($sql);
            $stmt->bindValue($i = 1, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            foreach ($expired as $id) {
                $stmt->bindValue(++$i, $id);
            }
            $stmt->execute();
        }
    }
    /**
     * {@inheritdoc}
     */
    protected function doHave($id)
    {
        $connection = $this->getConnection();
        $useDbalConstants = $connection instanceof Connection;
        $sql = "SELECT 1 FROM {$this->table} WHERE {$this->idCol} = :id AND ({$this->lifetimeCol} IS NULL OR {$this->lifetimeCol} + {$this->timeCol} > :time)";
        $stmt = $connection->prepare($sql);
        $stmt->bindValue(':id', $id);
        $stmt->bindValue(':time', \time(), $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        $result = $stmt->execute();
        return (bool) (\is_object($result) ? $result->fetchOne() : $stmt->fetchColumn());
    }
    /**
     * {@inheritdoc}
     */
    protected function doClear($namespace)
    {
        $conn = $this->getConnection();
        if ('' === $namespace) {
            if ('sqlite' === $this->driver) {
                $sql = "DELETE FROM {$this->table}";
            } else {
                $sql = "TRUNCATE TABLE {$this->table}";
            }
        } else {
            $sql = "DELETE FROM {$this->table} WHERE {$this->idCol} LIKE '{$namespace}%'";
        }
        try {
            if ($conn instanceof Connection && \method_exists($conn, 'executeStatement')) {
                $conn->executeStatement($sql);
            } else {
                $conn->exec($sql);
            }
        } catch (TableNotFoundException $e) {
        } catch (\PDOException $e) {
        }
        return \true;
    }
    /**
     * {@inheritdoc}
     */
    protected function doDelete(array $ids)
    {
        $sql = \str_pad('', (\count($ids) << 1) - 1, '?,');
        $sql = "DELETE FROM {$this->table} WHERE {$this->idCol} IN ({$sql})";
        try {
            $stmt = $this->getConnection()->prepare($sql);
            $stmt->execute(\array_values($ids));
        } catch (TableNotFoundException $e) {
        } catch (\PDOException $e) {
        }
        return \true;
    }
    /**
     * {@inheritdoc}
     */
    protected function doSave(array $values, int $lifetime)
    {
        if (!($values = $this->marshaller->marshall($values, $failed))) {
            return $failed;
        }
        $conn = $this->getConnection();
        $useDbalConstants = $conn instanceof Connection;
        $driver = $this->driver;
        $insertSql = "INSERT INTO {$this->table} ({$this->idCol}, {$this->dataCol}, {$this->lifetimeCol}, {$this->timeCol}) VALUES (:id, :data, :lifetime, :time)";
        switch (\true) {
            case 'mysql' === $driver:
                $sql = $insertSql . " ON DUPLICATE KEY UPDATE {$this->dataCol} = VALUES({$this->dataCol}), {$this->lifetimeCol} = VALUES({$this->lifetimeCol}), {$this->timeCol} = VALUES({$this->timeCol})";
                break;
            case 'oci' === $driver:
                // DUAL is Oracle specific dummy table
                $sql = "MERGE INTO {$this->table} USING DUAL ON ({$this->idCol} = ?) " . "WHEN NOT MATCHED THEN INSERT ({$this->idCol}, {$this->dataCol}, {$this->lifetimeCol}, {$this->timeCol}) VALUES (?, ?, ?, ?) " . "WHEN MATCHED THEN UPDATE SET {$this->dataCol} = ?, {$this->lifetimeCol} = ?, {$this->timeCol} = ?";
                break;
            case 'sqlsrv' === $driver && \version_compare($this->getServerVersion(), '10', '>='):
                // MERGE is only available since SQL Server 2008 and must be terminated by semicolon
                // It also requires HOLDLOCK according to http://weblogs.sqlteam.com/dang/archive/2009/01/31/UPSERT-Race-Condition-With-MERGE.aspx
                $sql = "MERGE INTO {$this->table} WITH (HOLDLOCK) USING (SELECT 1 AS dummy) AS src ON ({$this->idCol} = ?) " . "WHEN NOT MATCHED THEN INSERT ({$this->idCol}, {$this->dataCol}, {$this->lifetimeCol}, {$this->timeCol}) VALUES (?, ?, ?, ?) " . "WHEN MATCHED THEN UPDATE SET {$this->dataCol} = ?, {$this->lifetimeCol} = ?, {$this->timeCol} = ?;";
                break;
            case 'sqlite' === $driver:
                $sql = 'INSERT OR REPLACE' . \substr($insertSql, 6);
                break;
            case 'pgsql' === $driver && \version_compare($this->getServerVersion(), '9.5', '>='):
                $sql = $insertSql . " ON CONFLICT ({$this->idCol}) DO UPDATE SET ({$this->dataCol}, {$this->lifetimeCol}, {$this->timeCol}) = (EXCLUDED.{$this->dataCol}, EXCLUDED.{$this->lifetimeCol}, EXCLUDED.{$this->timeCol})";
                break;
            default:
                $driver = null;
                $sql = "UPDATE {$this->table} SET {$this->dataCol} = :data, {$this->lifetimeCol} = :lifetime, {$this->timeCol} = :time WHERE {$this->idCol} = :id";
                break;
        }
        $now = \time();
        $lifetime = $lifetime ?: null;
        try {
            $stmt = $conn->prepare($sql);
        } catch (TableNotFoundException $e) {
            if (!$conn->isTransactionActive() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], \true)) {
                $this->createTable();
            }
            $stmt = $conn->prepare($sql);
        } catch (\PDOException $e) {
            if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], \true)) {
                $this->createTable();
            }
            $stmt = $conn->prepare($sql);
        }
        if ('sqlsrv' === $driver || 'oci' === $driver) {
            $stmt->bindParam(1, $id);
            $stmt->bindParam(2, $id);
            $stmt->bindParam(3, $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
            $stmt->bindValue(4, $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            $stmt->bindValue(5, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            $stmt->bindParam(6, $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
            $stmt->bindValue(7, $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            $stmt->bindValue(8, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        } else {
            $stmt->bindParam(':id', $id);
            $stmt->bindParam(':data', $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
            $stmt->bindValue(':lifetime', $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            $stmt->bindValue(':time', $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        }
        if (null === $driver) {
            $insertStmt = $conn->prepare($insertSql);
            $insertStmt->bindParam(':id', $id);
            $insertStmt->bindParam(':data', $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
            $insertStmt->bindValue(':lifetime', $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
            $insertStmt->bindValue(':time', $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
        }
        foreach ($values as $id => $data) {
            try {
                $result = $stmt->execute();
            } catch (TableNotFoundException $e) {
                if (!$conn->isTransactionActive() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], \true)) {
                    $this->createTable();
                }
                $result = $stmt->execute();
            } catch (\PDOException $e) {
                if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], \true)) {
                    $this->createTable();
                }
                $result = $stmt->execute();
            }
            if (null === $driver && !(\is_object($result) ? $result->rowCount() : $stmt->rowCount())) {
                try {
                    $insertStmt->execute();
                } catch (DBALException|Exception $e) {
                } catch (\PDOException $e) {
                    // A concurrent write won, let it be
                }
            }
        }
        return $failed;
    }
    /**
     * @return \PDO|Connection
     */
    private function getConnection()
    {
        if (null === $this->conn) {
            if (\strpos($this->dsn, '://')) {
                if (!\class_exists(DriverManager::class)) {
                    throw new InvalidArgumentException(\sprintf('Failed to parse the DSN "%s". Try running "composer require doctrine/dbal".', $this->dsn));
                }
                $this->conn = DriverManager::getConnection(['url' => $this->dsn]);
            } else {
                $this->conn = new \PDO($this->dsn, $this->username, $this->password, $this->connectionOptions);
                $this->conn->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
            }
        }
        if (null === $this->driver) {
            if ($this->conn instanceof \PDO) {
                $this->driver = $this->conn->getAttribute(\PDO::ATTR_DRIVER_NAME);
            } else {
                $driver = $this->conn->getDriver();
                switch (\true) {
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\Mysqli\Driver:
                        throw new \LogicException(\sprintf('The adapter "%s" does not support the mysqli driver, use pdo_mysql instead.', static::class));
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\AbstractMySQLDriver:
                        $this->driver = 'mysql';
                        break;
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDOSqlite\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDO\SQLite\Driver:
                        $this->driver = 'sqlite';
                        break;
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDOPgSql\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDO\PgSQL\Driver:
                        $this->driver = 'pgsql';
                        break;
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\OCI8\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDOOracle\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDO\OCI\Driver:
                        $this->driver = 'oci';
                        break;
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\SQLSrv\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDOSqlsrv\Driver:
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver\PDO\SQLSrv\Driver:
                        $this->driver = 'sqlsrv';
                        break;
                    case $driver instanceof \DynamicOOOS\Doctrine\DBAL\Driver:
                        $this->driver = ['mssql' => 'sqlsrv', 'oracle' => 'oci', 'postgresql' => 'pgsql', 'sqlite' => 'sqlite', 'mysql' => 'mysql'][$driver->getDatabasePlatform()->getName()] ?? \get_class($driver);
                        break;
                    default:
                        $this->driver = \get_class($driver);
                        break;
                }
            }
        }
        return $this->conn;
    }
    private function getServerVersion() : string
    {
        if (null === $this->serverVersion) {
            $conn = $this->conn instanceof \PDO ? $this->conn : $this->conn->getWrappedConnection();
            if ($conn instanceof \PDO) {
                $this->serverVersion = $conn->getAttribute(\PDO::ATTR_SERVER_VERSION);
            } elseif ($conn instanceof ServerInfoAwareConnection) {
                $this->serverVersion = $conn->getServerVersion();
            } else {
                $this->serverVersion = '0';
            }
        }
        return $this->serverVersion;
    }
}
