App\Gitter\Extensions\MiddlewareBuilder

Complexity

Total Complexity

14

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	registerMiddleware()	0	10	2
A	registerRoom()	0	9	1
A	getGroup()	0	6	2
B	build()	0	23	5
A	getExtensionByRoom()	0	13	3
A	fire()	0	9	1

<?php
/**
 * This file is part of GitterBot package.
 *
 * @author Serafim <nesk@xakep.ru>
 * @date 27.01.2016 16:54
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace App\Gitter\Extensions;


use App\Message;
use Gitter\Models\Room as GitterRoom;
use App\Gitter\Extensions\Middlewares\Container;

/**
 * Class MiddlewareBuilder
 * @package App\Gitter\Extensions
 */
class MiddlewareBuilder
{
    const COMMON_GROUP = 'common';

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

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

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

    /**
     * @var bool
     */
    protected $built = false;

    /**
     * @param string $middleware
     * @param string $group
     * @return $this
     */
    public function registerMiddleware(string $middleware, string $group = self::COMMON_GROUP)
    {
        if (!array_key_exists($group, $this->middlewares)) {
            $this->middlewares[$group] = [];
        }

        $this->middlewares[$group][] = $middleware;

        return $this;
    }

    /**
     * @TODO Improve container
     * @param GitterRoom $room
     * @param array $groups
     * @return $this
     */
    public function registerRoom(GitterRoom $room, array $groups = [])
    {
        $this->rooms[] = (object) [
            'room'      => $room,
            'groups'    => $groups
        ];

        return $this;
    }

    /**
     * @param $name
     * @return array
     */
    protected function getGroup($name)
    {
        return array_key_exists($name, $this->middlewares)
            ? $this->middlewares[$name]
            : [];
    }

    /**
     * @return $this
     */
    protected function build()
    {
        if (!$this->built) {
            foreach ($this->rooms as $data) {
                /** @var Container $extension */
                $extension = $this->getExtensionByRoom($data->room);

                foreach ($data->groups as $group) {
                    $middlewares = $this->getGroup($group);

                    foreach ($middlewares as $middleware) {
                        $extension->register($middleware);
                    }
                }

                $this->resolvedMiddlewares[$data->room->id] = $extension;
            }

            $this->built = true;
        }

        return $this;
    }

    /**
     * @param GitterRoom $room
     * @return mixed
     */
    protected function getExtensionByRoom(GitterRoom $room)
    {
        if (!array_key_exists($room->id, $this->resolvedMiddlewares)) {
            /** @var Container $extension */
            $extension = app(Container::class, ['room' => $room]);
            foreach ($this->getGroup(static::COMMON_GROUP) as $middleware) {
                $extension->register($middleware);
            }
            $this->resolvedMiddlewares[$room->id] = $extension;
        }

        return $this->resolvedMiddlewares[$room->id];
    }

    /**
     * @param GitterRoom $room
     * @param Message $message
     * @return $this
     */
    public function fire(GitterRoom $room, Message $message)
    {
        $this->build();

        $extension = $this->getExtensionByRoom($room);
        $extension->fire($message);

        return $this;
    }
}