<?php

declare(strict_types=1);

namespace Drupal\Tests\Core\Config\Checkpoint;

use Drupal\Component\Datetime\Time;
use Drupal\Core\Cache\NullBackend;
use Drupal\Core\Config\Checkpoint\Checkpoint;
use Drupal\Core\Config\Checkpoint\CheckpointStorage;
use Drupal\Core\Config\Checkpoint\LinearHistory;
use Drupal\Core\Config\Config;
use Drupal\Core\Config\ConfigCrudEvent;
use Drupal\Core\Config\MemoryStorage;
use Drupal\Core\Config\StorageCopyTrait;
use Drupal\Core\Config\StorageInterface;
use Drupal\Core\KeyValueStore\KeyValueMemoryFactory;
use Drupal\Core\Lock\NullLockBackend;
use Drupal\Core\State\State;
use Drupal\Tests\UnitTestCase;
use Drupal\TestTools\Random;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;

/**
 * Tests Drupal\Core\Config\Checkpoint\CheckpointStorage.
 */
#[CoversClass(CheckpointStorage::class)]
#[Group('Config')]
class CheckpointStorageTest extends UnitTestCase {

  use StorageCopyTrait;

  /**
   * The memory storage containing the data.
   *
   * @var \Drupal\Core\Config\MemoryStorage
   */
  protected MemoryStorage $memory;

  /**
   * The checkpoint storage under test.
   *
   * @var \Drupal\Core\Config\Checkpoint\CheckpointStorage
   */
  protected CheckpointStorage $storage;

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();

    // Set up a memory storage we can manipulate to set fixtures.
    $this->memory = new MemoryStorage();
    $keyValueMemoryFactory = new KeyValueMemoryFactory();
    $state = new State($keyValueMemoryFactory, new NullBackend('test'), new NullLockBackend());
    $time = new Time();
    $checkpoints = new LinearHistory($state, $time);
    $this->storage = new CheckpointStorage($this->memory, $checkpoints, $keyValueMemoryFactory);
  }

  /**
   * Tests checkpoint creation.
   *
   * @legacy-covers ::checkpoint
   * @legacy-covers \Drupal\Core\Config\Checkpoint\Checkpoint
   */
  public function testCheckpointCreation(): void {
    $checkpoint = $this->storage->checkpoint('Test');
    $this->assertInstanceOf(Checkpoint::class, $checkpoint);
    $this->assertSame('Test', $checkpoint->label);

    $checkpoint2 = $this->storage->checkpoint('This will not make a checkpoint because nothing has changed');
    $this->assertSame($checkpoint2, $checkpoint);
    $config = $this->prophesize(Config::class);
    $config->getName()->willReturn('test.config');
    $config->getOriginal('', FALSE)->willReturn([]);
    $config->getRawData()->willReturn(['foo' => 'bar']);
    $config->getStorage()->willReturn($this->storage);
    $event = new ConfigCrudEvent($config->reveal());
    $this->storage->onConfigSaveAndDelete($event);

    $checkpoint3 = $this->storage->checkpoint('Created test.config');
    $this->assertNotSame($checkpoint3, $checkpoint);
    $this->assertSame('Created test.config', $checkpoint3->label);

    $checkpoint4 = $this->storage->checkpoint('This will not create a checkpoint either');
    $this->assertSame($checkpoint4, $checkpoint3);

    // Simulate a save with no change.
    $config = $this->prophesize(Config::class);
    $config->getName()->willReturn('test.config');
    $config->getOriginal('', FALSE)->willReturn(['foo' => 'bar']);
    $config->getRawData()->willReturn(['foo' => 'bar']);
    $config->getStorage()->willReturn($this->storage);
    $event = new ConfigCrudEvent($config->reveal());
    $this->storage->onConfigSaveAndDelete($event);

    $checkpoint5 = $this->storage->checkpoint('Save with no change');
    $this->assertSame($checkpoint5, $checkpoint3);

    // Create collection and ensure that checkpoints are kept in sync.
    $collection = $this->storage->createCollection('test');
    $config = $this->prophesize(Config::class);
    $config->getName()->willReturn('test.config');
    $config->getOriginal('', FALSE)->willReturn(['foo' => 'bar']);
    $config->getRawData()->willReturn(['foo' => 'collection_bar']);
    $config->getStorage()->willReturn($collection);
    $event = new ConfigCrudEvent($config->reveal());
    $collection->onConfigSaveAndDelete($event);

    $checkpoint6 = $this->storage->checkpoint('Save in collection');
    $this->assertNotSame($checkpoint6, $checkpoint3);
    $this->assertSame($collection->checkpoint('Calling checkpoint on collection'), $checkpoint6);
  }

  /**
   * Tests read operations.
   *
   * @legacy-covers ::exists
   * @legacy-covers ::read
   * @legacy-covers ::readMultiple
   * @legacy-covers ::listAll
   */
  #[DataProvider('readMethodsProvider')]
  public function testReadOperations(string $method, array $arguments, array $fixture): void {
    // Create a checkpoint so the checkpoint storage can be read from.
    $this->storage->checkpoint('');
    $this->setRandomFixtureConfig($fixture);

    $expected = call_user_func_array([$this->memory, $method], $arguments);
    $actual = call_user_func_array([$this->storage, $method], $arguments);
    $this->assertEquals($expected, $actual);
  }

  /**
   * Provide the methods that work transparently.
   *
   * @return array
   *   The data.
   */
  public static function readMethodsProvider(): array {
    $fixture = [
      StorageInterface::DEFAULT_COLLECTION => ['config.a', 'config.b', 'other.a'],
    ];

    $data = [];
    $data[] = ['exists', ['config.a'], $fixture];
    $data[] = ['exists', ['not.existing'], $fixture];
    $data[] = ['read', ['config.a'], $fixture];
    $data[] = ['read', ['not.existing'], $fixture];
    $data[] = ['readMultiple', [['config.a', 'config.b', 'not']], $fixture];
    $data[] = ['listAll', [''], $fixture];
    $data[] = ['listAll', ['config'], $fixture];
    $data[] = ['listAll', ['none'], $fixture];

    return $data;
  }

  /**
   * Tests write operations.
   *
   * @legacy-covers ::write
   * @legacy-covers ::delete
   * @legacy-covers ::rename
   * @legacy-covers ::deleteAll
   */
  #[DataProvider('writeMethodsProvider')]
  public function testWriteOperations(string $method, array $arguments, array $fixture): void {
    $this->setRandomFixtureConfig($fixture);

    // Create an independent memory storage as a backup.
    $backup = new MemoryStorage();
    static::replaceStorageContents($this->memory, $backup);

    try {
      call_user_func_array([$this->storage, $method], $arguments);
      $this->fail("exception not thrown");
    }
    catch (\BadMethodCallException $exception) {
      $this->assertEquals(CheckpointStorage::class . '::' . $method . ' is not allowed on a CheckpointStorage', $exception->getMessage());
    }

    // Assert that the memory storage has not been altered.
    $this->assertEquals($backup, $this->memory);
  }

  /**
   * Provide the methods that throw an exception.
   *
   * @return array
   *   The data
   */
  public static function writeMethodsProvider(): array {
    $fixture = [
      StorageInterface::DEFAULT_COLLECTION => ['config.a', 'config.b'],
    ];

    $data = [];
    $data[] = ['write', ['config.a', (array) Random::getGenerator()->object()], $fixture];
    $data[] = ['write', [Random::machineName(), (array) Random::getGenerator()->object()], $fixture];
    $data[] = ['delete', ['config.a'], $fixture];
    $data[] = ['delete', [Random::machineName()], $fixture];
    $data[] = ['rename', ['config.a', 'config.b'], $fixture];
    $data[] = ['rename', ['config.a', Random::machineName()], $fixture];
    $data[] = ['rename', [Random::machineName(), Random::machineName()], $fixture];
    $data[] = ['deleteAll', [''], $fixture];
    $data[] = ['deleteAll', ['config'], $fixture];
    $data[] = ['deleteAll', ['other'], $fixture];

    return $data;
  }

  /**
   * Tests collections.
   *
   * @legacy-covers ::getAllCollectionNames
   * @legacy-covers ::getCollectionName
   * @legacy-covers ::createCollection
   */
  public function testCollections(): void {
    $ref_readFromCheckpoint = new \ReflectionProperty($this->storage, 'readFromCheckpoint');

    // Create some checkpoints so the checkpoint storage can be read from.
    $checkpoint1 = $this->storage->checkpoint('1');
    $config = $this->prophesize(Config::class);
    $config->getName()->willReturn('test.config');
    $config->getOriginal('', FALSE)->willReturn([]);
    $config->getRawData()->willReturn(['foo' => 'bar']);
    $config->getStorage()->willReturn($this->storage);
    $event = new ConfigCrudEvent($config->reveal());
    $this->storage->onConfigSaveAndDelete($event);
    $checkpoint2 = $this->storage->checkpoint('2');

    $fixture = [
      StorageInterface::DEFAULT_COLLECTION => [$this->randomMachineName()],
      'A' => [$this->randomMachineName()],
      'B' => [$this->randomMachineName()],
      'C' => [$this->randomMachineName()],
    ];
    $this->setRandomFixtureConfig($fixture);

    $this->assertEquals(['A', 'B', 'C'], $this->storage->getAllCollectionNames());
    foreach (array_keys($fixture) as $collection) {
      $storage = $this->storage->createCollection($collection);
      // Assert that the collection storage is still a checkpoint storage.
      $this->assertInstanceOf(CheckpointStorage::class, $storage);
      $this->assertEquals($collection, $storage->getCollectionName());

      // Ensure that the
      // \Drupal\Core\Config\Checkpoint\CheckpointStorage::$readFromCheckpoint
      // property is kept in sync.
      $this->storage->setCheckpointToReadFrom($checkpoint2);
      $this->assertSame($checkpoint2->id, $ref_readFromCheckpoint->getValue($storage->createCollection($collection))?->id);
      if (isset($previous_collection)) {
        $previous_collection->setCheckpointToReadFrom($checkpoint1);
        $this->assertSame($checkpoint1->id, $ref_readFromCheckpoint->getValue($storage->createCollection($collection))?->id);
        $this->assertSame($checkpoint1->id, $ref_readFromCheckpoint->getValue($this->storage->createCollection($collection))?->id);
      }

      // Save the storage in a variable so we can test use
      // setCheckpointToReadFrom() on it.
      $previous_collection = $storage;
    }
  }

  /**
   * Tests encode decode.
   *
   * @legacy-covers ::encode
   * @legacy-covers ::decode
   */
  public function testEncodeDecode(): void {
    $array = (array) $this->getRandomGenerator()->object();
    $string = $this->getRandomGenerator()->string();

    // Assert reversibility of encoding and decoding.
    $this->assertEquals($array, $this->storage->decode($this->storage->encode($array)));
    $this->assertEquals($string, $this->storage->encode($this->storage->decode($string)));
    // Assert same results as the decorated storage.
    $this->assertEquals($this->memory->encode($array), $this->storage->encode($array));
    $this->assertEquals($this->memory->decode($string), $this->storage->decode($string));
  }

  /**
   * Generate random config in the memory storage.
   *
   * @param array $config
   *   The config keys, keyed by the collection.
   */
  protected function setRandomFixtureConfig(array $config): void {
    // Erase previous fixture.
    foreach (array_merge([StorageInterface::DEFAULT_COLLECTION], $this->memory->getAllCollectionNames()) as $collection) {
      $this->memory->createCollection($collection)->deleteAll();
    }

    foreach ($config as $collection => $keys) {
      $storage = $this->memory->createCollection($collection);
      foreach ($keys as $key) {
        // Create some random config.
        $storage->write($key, (array) $this->getRandomGenerator()->object());
      }
    }
  }

}
