Pbxg33k\MusicInfo\MusicInfo

Complexity

Total Complexity

33

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	21	4
A	setClient()	0	6	1
A	getClient()	0	4	1
A	loadService()	0	18	3
A	mergeConfig()	0	14	2
A	loadServices()	0	8	2
A	addService()	0	6	1
A	getServices()	0	4	1
A	getService()	0	9	2
A	initializeService()	0	8	2
A	removeService()	0	8	2
A	getPreferredService()	0	4	1
A	doSearch()	0	16	3
B	_prepareSearch()	0	21	8

<?php
namespace Pbxg33k\MusicInfo;

use Doctrine\Common\Collections\ArrayCollection;
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use Pbxg33k\MusicInfo\Exception\ServiceConfigurationException;
use Pbxg33k\MusicInfo\Model\IMusicService;
use Pbxg33k\MusicInfo\Service\BaseService;
use Pbxg33k\Traits\PropertyTrait;

class MusicInfo
{
    use PropertyTrait;
    /**
     * @var ClientInterface
     */
    protected $client;

    /**
     * @var ArrayCollection
     */
    protected $services;

    /**
     * @var array
     */
    protected $config;

    /**
     * Supported Services
     * @var array
     */
    protected $supportedServices = [];

    /**
     * MusicInfo constructor.
     *
     * @param $config
     *
     * @throws ServiceConfigurationException if musicinfo.service is missing
     */
    public function __construct($config)
    {
        $this->config = $config;

        $this->services = new ArrayCollection();
        $this->setClient(
            new Client($config['defaults']['guzzle'])
        );

        if (isset($config['services'])) {
            foreach ($config['services'] as $service) {
                if (!isset($config['init_services'])) {
                    $config['init_services'] = null;
                }
                $this->loadService($service, $config['init_services']);
                $this->supportedServices[] = $service;
            }
        } else {
            throw new ServiceConfigurationException("musicinfo.services is required");
        }
    }

    /**
     * @param ClientInterface $client
     *
     * @return $this
     */
    public function setClient(ClientInterface $client)
    {
        $this->client = $client;

        return $this;
    }

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

    /**
     * Load service
     *
     * @param $service
     * @param $init
     *
     * @return IMusicService
     *
     * @throws \Exception
     */
    public function loadService($service, $init = false)
    {
        $fqcn = implode('\\', ['Pbxg33k', 'MusicInfo', 'Service', $service, 'Service']);
        if (class_exists($fqcn)) {
            /** @var IMusicService $client */
            $client = new $fqcn();
            $client->setConfig($this->mergeConfig($service));
            $client->setClient($this->getClient());
            if ($init === true) {
                $client->init();
            }
            $this->addService($client, $service);

            return $service;
        } else {
            throw new \Exception('Service class does not exist: ' . $service . ' (' . $fqcn . ')');
        }
    }

    /**
     * Merge shared config with service specific configuration
     *
     * @param $service
     *
     * @return array
     */
    public function mergeConfig($service)
    {
        $service = strtolower($service);
        if (isset($this->config['service_configuration'][$service])) {
            $config = array_merge(
                $this->config['defaults'],
                $this->config['service_configuration'][$service]
            );

            return $config;
        } else {
            return $this->config['defaults'];
        }
    }

    /**
     * Load all services
     *
     * @param bool $initialize
     *
     * @return ArrayCollection
     * @throws \Exception
     */
    public function loadServices($initialize = false)
    {
        foreach ($this->supportedServices as $service) {
            $this->loadService($service, $initialize);
        }

        return $this->getServices();
    }

    /**
     * @param IMusicService $service
     * @param               $key
     *
     * @return $this
     */
    public function addService(IMusicService $service, $key)
    {
        $this->services[strtolower($key)] = $service;

        return $this;
    }

    /**
     * @return ArrayCollection
     */
    public function getServices()
    {
        return $this->services;
    }

    /**
     * @param $key
     *
     * @return BaseService|null
     */
    public function getService($key)
    {
        $key = strtolower($key);
        if (isset($this->services[$key])) {
            return $this->initializeService($this->services[$key]);
        } else {
            return null;
        }
    }

    /**
     * @param BaseService $service
     *
     * @return BaseService
     * @throws ServiceConfigurationException
     */
    public function initializeService(BaseService $service)
    {
        if (!$service->isInitialized()) {
            $service->init();
        }

        return $service;
    }

    /**
     * @param string $key
     *
     * @return $this
     */
    public function removeService($key)
    {
        if (isset($this->services[$key])) {
            unset($this->services[$key]);
        }

        return $this;
    }

    /**
     * @return BaseService|null
     */
    public function getPreferredService()
    {
        return $this->getService($this->config['preferred_order'][0]);
    }

    /**
     * Perform Multi-service search
     *
     * @param      $argument
     * @param      $type
     * @param null $servicesArg
     *
     * @return ArrayCollection
     * @throws \Exception
     */
    public function doSearch($argument, $type, $servicesArg = null)
    {
        $services = $this->_prepareSearch($servicesArg);
        $results = new ArrayCollection();

        foreach ($services as $serviceKey => $service) {
            $methodName = $this->getMethodName($type);

            if (!method_exists($service, $methodName)) {
                throw new \Exception(sprintf('Method (%s) not found in %s', $methodName, get_class($service)));
            }
            $results->set($serviceKey, $service->{$methodName}()->getByName($argument));
        }

        return $results;
    }

    /**
     * Return an arraycollection with (loaded) services
     *
     * @param mixed $servicesArg
     *
     * @return ArrayCollection
     * @throws \Exception
     */
    protected function _prepareSearch($servicesArg = null)
    {
        $services = new ArrayCollection();

        if (null === $servicesArg) {
            $services = $this->getServices();
        } elseif (is_array($servicesArg)) {
            foreach ($servicesArg as $service) {
                if (is_string($service) && $loadedService = $this->getService($service)) {
                    $services->set($service, $loadedService);
                } else {
                    throw new \Exception(sprintf('Service (%s) cannot be found', $service));
                }
            }
        } elseif (is_string($servicesArg) && $loadedService = $this->getService($servicesArg)) {
            $services->set($servicesArg, $loadedService);

        }

        return $services;
    }
}