<?php

declare(strict_types=1);

namespace App\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;
    }
}