<?php

namespace Drupal\Tests\ctools\Unit;

use Prophecy\PhpUnit\ProphecyTrait;
use Drupal\Component\Plugin\PluginManagerInterface;
use Drupal\Component\Uuid\UuidInterface;
use Drupal\Core\DependencyInjection\ContainerBuilder;
use Drupal\Core\Display\VariantInterface;
use Drupal\ctools\Plugin\VariantCollectionTrait;
use Drupal\ctools\Plugin\VariantPluginCollection;
use Drupal\Tests\UnitTestCase;

/**
 * Tests the methods of a variant-aware class.
 *
 * @coversDefaultClass \Drupal\ctools\Plugin\VariantCollectionTrait
 *
 * @group Ctools
 */
class VariantCollectionTraitTest extends UnitTestCase {

  use ProphecyTrait;
  /**
   * @var \Drupal\Component\Plugin\PluginManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $manager;

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();
    $container = new ContainerBuilder();
    $this->manager = $this->prophesize(PluginManagerInterface::class);
    $container->set('plugin.manager.display_variant', $this->manager->reveal());
    \Drupal::setContainer($container);
  }

  /**
   * @covers ::getVariants
   */
  public function testGetVariantsEmpty() {
    $trait_object = new TestVariantCollectionTrait();
    $this->manager->createInstance()->shouldNotBeCalled();

    $variants = $trait_object->getVariants();
    $this->assertInstanceOf(VariantPluginCollection::class, $variants);
    $this->assertSame(0, count($variants));
  }

  /**
   * @covers ::getVariants
   */
  public function testGetVariants() {
    $trait_object = new TestVariantCollectionTrait();
    $config = [
      'foo' => ['id' => 'foo_plugin'],
      'bar' => ['id' => 'bar_plugin'],
    ];
    foreach ($config as $value) {
      $plugin = $this->prophesize(VariantInterface::class);
      $this->manager->createInstance($value['id'], $value)->willReturn($plugin->reveal());
    }
    $trait_object->setVariantConfig($config);

    $variants = $trait_object->getVariants();
    $this->assertInstanceOf(VariantPluginCollection::class, $variants);
    $this->assertSame(2, count($variants));
    return $variants;
  }

  /**
   * @covers ::getVariants
   *
   * @depends testGetVariants
   */
  public function testGetVariantsSort(VariantPluginCollection $variants) {
    $this->assertEquals(['bar' => 'bar', 'foo' => 'foo'], $variants->getInstanceIds());
  }

  /**
   * @covers ::addVariant
   */
  public function testAddVariant() {
    $config = ['id' => 'foo'];
    $uuid = 'test-uuid';
    $expected_config = $config + ['uuid' => $uuid];

    $uuid_generator = $this->prophesize(UuidInterface::class);
    $uuid_generator->generate()
      ->willReturn($uuid)
      ->shouldBeCalledTimes(1);
    $trait_object = new TestVariantCollectionTrait();
    $trait_object->setUuidGenerator($uuid_generator->reveal());

    $plugin_prophecy = $this->prophesize(VariantInterface::class);
    $plugin_prophecy->getConfiguration()
      ->willReturn($expected_config)
      ->shouldBeCalled();
    $plugin_prophecy->setConfiguration($expected_config)
      ->willReturn($expected_config)
      ->shouldBeCalled();

    $this->manager->createInstance('foo', $expected_config)
      ->willReturn($plugin_prophecy->reveal());

    $resulting_uuid = $trait_object->addVariant($config);
    $this->assertSame($uuid, $resulting_uuid);

    $variants = $trait_object->getVariants();
    $this->assertSame([$uuid => $uuid], $variants->getInstanceIds());
    $this->assertSame([$uuid => $expected_config], $variants->getConfiguration());
    $this->assertSame($plugin_prophecy->reveal(), $variants->get($uuid));
    return [$trait_object, $uuid, $plugin_prophecy->reveal()];
  }

  /**
   * @covers ::getVariant
   *
   * @depends testAddVariant
   */
  public function testGetVariant($data) {
    [$trait_object, $uuid, $plugin] = $data;
    $this->manager->createInstance()->shouldNotBeCalled();

    $this->assertSame($plugin, $trait_object->getVariant($uuid));
    return [$trait_object, $uuid];
  }

  /**
   * @covers ::removeVariant
   *
   * @depends testGetVariant
   */
  public function testRemoveVariant($data) {
    [$trait_object, $uuid] = $data;

    $this->assertSame($trait_object, $trait_object->removeVariant($uuid));
    $this->assertFalse($trait_object->getVariants()->has($uuid));
    return [$trait_object, $uuid];
  }

  /**
   * @covers ::getVariant
   *
   * @depends testRemoveVariant
   */
  public function testGetVariantException($data) {
    [$trait_object, $uuid] = $data;
    // Attempt to retrieve a variant that has been removed.
    $this->expectException('\Drupal\Component\Plugin\Exception\PluginNotFoundException');
    $this->expectExceptionMessage("Plugin ID 'test-uuid' was not found.");
    $this->assertNull($trait_object->getVariant($uuid));
  }

}
/**
 *
 */
class TestVariantCollectionTrait {
  use VariantCollectionTrait;

  /**
   * @var array
   */
  protected $variantConfig = [];

  /**
   * @var \Drupal\Component\Uuid\UuidInterface
   */
  protected $uuidGenerator;

  /**
   * @param \Drupal\Component\Uuid\UuidInterface $uuid_generator
   *
   * @return $this
   */
  public function setUuidGenerator(UuidInterface $uuid_generator) {
    $this->uuidGenerator = $uuid_generator;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  protected function uuidGenerator() {
    return $this->uuidGenerator;
  }

  /**
   * Sets the variant configuration.
   *
   * @param array $config
   *   The variant configuration.
   *
   * @return $this
   */
  public function setVariantConfig(array $config) {
    $this->variantConfig = $config;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  protected function getVariantConfig() {
    return $this->variantConfig;
  }

}
