Karma\System\Gitter\GitterSystem

Complexity

Total Complexity

16

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	renderMessage()	0	4	1
A	parseMessage()	0	4	1
A	onRegister()	0	7	1
A	getClient()	0	4	1
A	auth()	0	12	2
A	channel()	0	8	1
A	has()	0	9	2
A	channels()	0	14	3
A	__debugInfo()	0	6	1
A	getName()	0	4	1

<?php
/**
 * This file is part of Platform package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Karma\System\Gitter;

use Gitter\Client;
use Karma\Platform\Io\AbstractSystem;
use Karma\Platform\Io\ChannelInterface;
use Karma\Platform\Io\SystemInterface;
use Karma\Platform\Io\UserInterface;
use Karma\Platform\Support\IdentityMap;
use Karma\Platform\Support\Loggable;
use Karma\Platform\Support\LoggableInterface;
use Karma\System\Gitter\Message\Parser;
use Karma\System\Gitter\Message\Renderer;
use Psr\Log\LoggerInterface;
use React\EventLoop\LoopInterface;

/**
 * Class GitterSystem
 * @package Karma\System\Gitter
 */
class GitterSystem extends AbstractSystem
{
    /**
     * System name
     */
    private const SYSTEM_NAME = 'gitter';

    /**
     * @var Client
     */
    private $client;

    /**
     * @var UserInterface|null
     */
    private $auth;

    /**
     * @var Renderer
     */
    private $renderer;

    /**
     * @var Parser
     */
    private $parser;

    /**
     * GitterSystem constructor.
     * @param string $token
     * @throws \DomainException
     */
    public function __construct(string $token)
    {
        if (!class_exists(Client::class)) {
            throw new \DomainException('"serafim/gitter-api": "~4.0" required');
        }

        $this->client = new Client($token);

        $this->renderer = new Renderer();
        $this->parser = new Parser();
    }

    /**
     * @param string $html
     * @return string
     */
    public function renderMessage(string $html): string
    {
        return $this->renderer->render($html);
    }

    /**
     * @param string $html
     * @return string
     */
    public function parseMessage(string $html): string
    {
        return $this->parser->parse($html);
    }

    /**
     * @param LoopInterface $loop
     * @param null|LoggerInterface $logger
     */
    public function onRegister(LoopInterface $loop, ?LoggerInterface $logger): void
    {
        $this->client->loop($loop);
        $this->client->logger($logger);

        parent::onRegister($loop, $logger);
    }

    /**
     * @return Client
     */
    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * @return UserInterface
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Throwable
     */
    public function auth(): UserInterface
    {
        if ($this->auth === null) {
            $data = $this->client->authUser();

            $this->auth = $this->getUser($data['id'], function() use ($data) {
                return new GitterUser($this, $data);
            });
        }

        return $this->auth;
    }

    /**
     * @param string $channelId
     * @return ChannelInterface
     * @throws \Throwable
     * @throws \RuntimeException
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \Exception
     * @throws \InvalidArgumentException
     */
    public function channel(string $channelId): ChannelInterface
    {
        return $this->getChannel($channelId, function () use ($channelId): ChannelInterface {
            $data = $this->client->rooms->join($channelId);

            return new GitterChannel($this, $data);
        });
    }

    /**
     * @param string $channelId
     * @return bool
     */
    public function has(string $channelId): bool
    {
        try {
            $this->channel($channelId);
            return true;
        } catch (\Throwable $e) {
            return false;
        }
    }

    /**
     * @return \Traversable|ChannelInterface[]|GitterChannel[]
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Throwable
     */
    public function channels(): \Traversable
    {
        foreach ($this->client->rooms->all() as $room) {
            $channel = new GitterChannel($this, $room);

            $this->push(ChannelInterface::class, $channel->getId(), $channel);
        }

        $channels = $this->identities(ChannelInterface::class);

        foreach ($channels as $channel) {
            yield $channel;
        }
    }

    /**
     * @return array
     */
    public function __debugInfo(): array
    {
        return [
            'name' => $this->getName(),
        ];
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return self::SYSTEM_NAME;
    }
}