<?php declare(strict_types=1);


namespace Komma\KMS\Menu;


class KmsMenu implements KmsMenuInterface
{
    /** @var Item[] */
    private static $items = [];

    /** @var \Closure */
    private static $activeCallback;

    public static function addItems(array $items)
    {
        foreach($items as $item) self::addItem($item);
    }

    public static function addItem(Item $item)
    {
        if($item->getSortOrder() == -1) $item->setSortOrder(self::getHighestSortOrder());
        self::$items[] = $item;
    }

    public static function getHighestSortOrder() {
        $highest = 0;
        foreach(self::$items as $item) {
            if($item->getSortOrder() > $highest) $highest = $item->getSortOrder();
        }
        return $highest;
    }

    /**
     * Returns the items, sorted
     *
     * @return array
     */
    public static function getItems()
    {
        self::activateMenuItems();
        self::sortItemsBySortOrder();

        return self::$items;
    }

    /**
     * Sort the items array according to the sort order that was given to each item.
     */
    private static function sortItemsBySortOrder()
    {
        usort(self::$items, function(Item $item_a, Item $item_b) {
            if($item_a->getSortOrder() === $item_b->getSortOrder()) return 0;
            return $item_a->getSortOrder() < $item_b->getSortOrder() ? -1 : 1;
        });
    }

    /**
 * @param string $name
 * @return Item|null
 */
    public static function findItemByName(string $name)
    {
        $name = strtolower($name);
        $items = array_filter(self::$items, function(Item $item) use($name) {
            return strtolower($item->getName()) === $name;
        });

        return (count($items) == 0) ? null : array_shift($items);
    }

    /**
     * @return void
     */
    private static function activateMenuItems() {
        if(!self::$activeCallback) return;
        self::activateMenuItemsIfNeeded(self::$items);
    }

    private static function activateMenuItemsIfNeeded(array $items) {
        foreach($items as $item) {
            /** @var Item $item */
            $result = self::$activeCallback->call($item, $item);
            $item->setIsActive($result);
            if($item->hasSubItems()) self::activateMenuItemsIfNeeded($item->getSubItems());
        }

        foreach($items as $item) {
            if($item->hasActiveSubItems()) $item->setIsActive(true);
        }
    }

    /**
     * Executes a higher order function for each item in the menu
     *
     * @param \Closure $closure A function that must accept 1 argument that must be of type Komma\KMS\Menu\Item
     */
    public static function forEach(\Closure $closure)
    {
        $reflection = new \ReflectionFunction($closure);
        if (count($reflection->getParameters()) !== 1) {
            throw new \InvalidArgumentException('The closure you pass to the foreach method must accept exactly 1 argument and that must be of type: ' . Item::class);
        }

        if ($reflection->getParameters()[0]->getClass() && $reflection->getParameters()[0]->getClass()->getName() !== Item::class) {
            throw new \InvalidArgumentException('The first argument of the closure you pass to the foreach method must be of type: ' . Item::class);
        }

        foreach (self::$items as $item) $closure($item);
    }

    public static function getSortOrderInformation() {
        self::sortItemsBySortOrder();

        $items = [];
        foreach (self::$items as $item) {
            $items[$item->isSeparator() ? '----' : $item->getName()] = $item->getSortOrder();
        }
        return $items;
    }

    /**
     * Registers a callback that must return true or false to make a menu item active or not.
     *
     * @param \Closure $closure
     */
    public static function itemActiveWhen(\Closure $closure)
    {
        self::$activeCallback = $closure;
    }
}