<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);

namespace Magento\Framework\Indexer;

/**
* Multiply dimensions from provided DimensionProviderInterface
*/
class MultiDimensionProvider implements \IteratorAggregate
{
/**
* @var array
*/
private $dimensionsIterators = [];

/**
* @var array
*/
private $dimensionsDataProviders = [];

/**
* @var int
*/
private $dimensionsProvidersCount = 0;

/**
* @param DimensionProviderInterface[] $dimensionProviders
*/
public function __construct(array $dimensionProviders = [])
{
foreach ($dimensionProviders as $dimensionDataProvider) {
$this->addDimensionDataProvider($dimensionDataProvider);
}
}

/**
* Returns generator that will return multiplied dimensions on each iteration
*
* @return \Traversable|Dimension[][]
* @throws \LogicException
*/
public function getIterator(): \Traversable
{
// just return empty array if we have no dimension providers to iterate over
if ($this->dimensionsProvidersCount === 0) {
yield [];
return;
}

// this recreates iterators for dimension so we can iterate over them
$this->rewind();

// if at leas one dimension provider has no dimensions to return we can't multiple dimension at all
if (!$this->hasCurrentDimension()) {
throw new \LogicException('Can`t multiple dimensions because some of them are empty.');
}

// return dimensions until all iterators become invalid
while ($this->hasCurrentDimension()) {
yield $this->getCurrentDimension();
$this->setNextDimension();
}
}

/**
* Return all dimensions for current state of each dimension provider
*
* @return array
*/
private function getCurrentDimension(): array
{
$dimensions = [];

foreach ($this->dimensionsIterators as $dimensionIterator) {
/** @var Dimension $dimension */
$dimension = $dimensionIterator->current();
$dimensions[$dimension->getName()] = $dimension;
}

return $dimensions;
}

/**
* Iterates over dimension iterators one by one starting from right to left
* This approach emulates iterations over X nested foreach loops e.g.:
*
* @return void
*/
private function setNextDimension()
{
$this->dimensionsIterators[$this->dimensionsProvidersCount - 1]->next();

for ($i = ($this->dimensionsProvidersCount - 1); $i > 0; $i--) {
if (!$this->dimensionsIterators[$i]->valid()) {
$this->dimensionsIterators[$i] = $this->dimensionsDataProviders[$i]->getIterator();
$this->dimensionsIterators[$i-1]->next();
}
}
}

/**
* Recreates iterators so all MultiDimensionProvider can be iterated again
*
* @return void
*/
private function rewind()
{
$this->dimensionsIterators = [];

foreach ($this->dimensionsDataProviders as $dimensionDataProvider) {
$this->dimensionsIterators[] = $dimensionDataProvider->getIterator();
}
}

/**
* Check if all dimension iterators are in valid state
*
* If at least one of dimension iterators is invalid before very first iteration - we assume
* that dimension provider has no dimensions at all, which means we can't multiple all dimensions
*
* If all dimension iterators became invalid - we assume that multiplication is already done
*
* @return bool
*/
private function hasCurrentDimension(): bool
{
$valid = true;

foreach ($this->dimensionsIterators as $dimensionsIterator) {
// if at least one data provider is invalid at this stage - all generator is invalid
if (!$dimensionsIterator->valid()) {
return false;
}
}

// generator is valid only when all data providers are valid
return $valid;
}

/**
* Collects dimension data providers
* This was done via separate method to ensure that each provider has required interface
*
* @param DimensionProviderInterface $dimensionDataProvider
* @return void
*/
private function addDimensionDataProvider(DimensionProviderInterface $dimensionDataProvider)
{
$this->dimensionsDataProviders[] = $dimensionDataProvider;
$this->dimensionsProvidersCount++;
}
}