Rayne\wz2008\Graph\WzItem

Complexity

Total Complexity

25

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	getId()	0	4	1
A	getLabel()	0	13	2
A	getLabels()	0	4	1
A	getLevel()	0	4	1
A	getParent()	0	4	1
A	getParentByLevel()	0	18	4
A	addChild()	0	13	3
A	getChildren()	0	4	1
B	getChildrenByLevel()	0	31	6
A	buildLevelOutOfBounds()	0	4	1
A	isInLevelBounds()	0	4	2

<?php

/**
 * (c) Dennis Meckel
 *
 * For the full copyright and license information,
 * please view the LICENSE file that was distributed with this source code.
 */

namespace Rayne\wz2008\Graph;

use InvalidArgumentException;
use OutOfBoundsException;
use Rayne\wz2008\Graph\Exception\InvalidParentException;
use SplQueue;

class WzItem implements WzItemInterface
{
    /**
     * @var WzItemInterface[]
     */
    private $children = [];

    /**
     * @var string
     */
    private $id;

    /**
     * @var string[]
     */
    private $labels;

    /**
     * @var int
     */
    private $level;

    /**
     * @var WzItemInterface|null
     */
    private $parent;

    /**
     * @param string $id
     * @param string[] $labels `Language Code => Translated Label` map.
     * @param int $level
     * @param WzItemInterface|null $parent
     */
    public function __construct($id, array $labels, $level, WzItemInterface $parent = null)
    {
        $this->id = $id;
        $this->labels = $labels;
        $this->level = (int) $level;
        $this->parent = $parent;

        if ($parent) {
            $parent->addChild($this);
        }
    }

    /**
     * @inheritdoc
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @inheritdoc
     */
    public function getLabel($langCode)
    {
        $code = strtolower($langCode);

        if (isset($this->labels[$code])) {
            return $this->labels[$code];
        }

        throw new InvalidArgumentException(sprintf(
            'Unsupported language code `%s`. Supported codes: `%s`.',
            $langCode,
            implode(',', array_keys($this->labels))));
    }

    /**
     * @inheritdoc
     */
    public function getLabels()
    {
        return $this->labels;
    }

    /**
     * @inheritdoc
     */
    public function getLevel()
    {
        return $this->level;
    }

    /**
     * @inheritdoc
     */
    public function getParent()
    {
        return $this->parent;
    }

    /**
     * @inheritdoc
     */
    public function getParentByLevel($level)
    {
        if (!$this->isInLevelBounds($level)) {
            throw $this->buildLevelOutOfBounds($level);
        }

        if ($level >= $this->getLevel()) {
            return null;
        }

        $parent = $this;

        for ($i = $this->getLevel(); $i > $level; $i--) {
            $parent = $parent->getParent();
        }

        return $parent;
    }

    /**
     * @inheritdoc
     */
    public function addChild(WzItemInterface $child)
    {
        if ($child->getParent() !== $this) {
            throw new InvalidParentException(sprintf(
                "The parent of `%s` is invalid. Expected `%s` but got `%s`.",
                $child->getId(),
                $this->getId(),
                $child->getParent() ? $child->getParent()->getId() : ''));
        }

        $this->children[] = $child;
        return $this;
    }

    /**
     * @inheritdoc
     */
    public function getChildren()
    {
        return $this->children;
    }

    /**
     * @inheritdoc
     */
    public function getChildrenByLevel($level)
    {
        if (!$this->isInLevelBounds($level)) {
            throw $this->buildLevelOutOfBounds($level);
        }

        if ($this->getLevel() >= $level) {
            return [];
        }

        $result = [];

        $queue = new SplQueue();
        $queue->enqueue($this);

        while (!$queue->isEmpty()) {
            /* @var WzItemInterface $item */
            $item = $queue->dequeue();

            if ($item->getLevel() == $level) {
                $result[] = $item;
                continue;
            }

            foreach ($item->getChildren() as $child) {
                $queue->enqueue($child);
            }
        }

        return $result;
    }

    /**
     * @param int $level
     * @return OutOfBoundsException
     */
    private function buildLevelOutOfBounds($level)
    {
        return new OutOfBoundsException(sprintf('Unknown level `%s`.', $level));
    }

    /**
     * @param int $level
     * @return bool
     */
    private function isInLevelBounds($level)
    {
        return self::LEVEL_SECTION <= $level && $level <= self::LEVEL_SUBCLASS;
    }
}