PhpWinTools\WmiScripting\Configuration\Config

Complexity

Total Complexity

62

Size/Duplication

Total Lines	464
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveStack()	0	3	1
A	eventProvider()	0	3	1
A	addResolvable()	0	5	1
A	apiObjects()	0	3	1
A	commandBus()	0	3	1
A	getProvider()	0	7	1
A	getApiObject()	0	3	1
A	instance()	0	11	5
A	__invoke()	0	19	5
A	testInstance()	0	9	3
A	killTestInstance()	0	5	1
A	newInstance()	0	3	1
A	endTest()	0	6	1
A	com()	0	3	1
A	resolve()	0	3	1
A	addComObject()	0	5	1
A	addApiObject()	0	5	1
A	__construct()	0	6	1
A	resolveFromStack()	0	12	3
A	hasResolvable()	0	9	3
A	eventHistoryProvider()	0	3	1
A	getComClass()	0	3	1
A	getCacheDriver()	0	7	2
A	connections()	0	3	1
A	getDefaultConnectionName()	0	3	1
A	getComWrapper()	0	3	1
A	getConnection()	0	7	3
A	getVariantWrapper()	0	3	1
A	doNotTrackEvents()	0	5	1
A	getComVariantWrapper()	0	3	1
A	addConnection()	0	5	1
A	shouldTrackEvents()	0	3	1
A	registerProvider()	0	10	3
A	boot()	0	13	3
A	getVariantClass()	0	3	1
A	bootConnections()	0	5	1
A	registerProviders()	0	7	1
A	setDefaultConnection()	0	7	2
A	trackEvents()	0	5	1
A	getDefaultConnection()	0	3	1

<?php

namespace PhpWinTools\WmiScripting\Configuration;

use Illuminate\Support\Arr;
use PhpWinTools\Support\COM\ComWrapper;
use PhpWinTools\Support\COM\VariantWrapper;
use PhpWinTools\Support\COM\ComVariantWrapper;
use PhpWinTools\WmiScripting\Containers\Connections;
use PhpWinTools\WmiScripting\Containers\Container;
use PhpWinTools\WmiScripting\Support\Bus\CommandBus;
use PhpWinTools\WmiScripting\Connections\ComConnection;
use PhpWinTools\WmiScripting\Support\Events\EventProvider;
use PhpWinTools\WmiScripting\Support\Events\EventHistoryProvider;
use PhpWinTools\WmiScripting\Exceptions\InvalidConnectionException;
use PhpWinTools\WmiScripting\Exceptions\UnresolvableClassException;

class Config extends Container
{
    /** @var Config|null */
    protected static $instance = null;

    protected static $test_mode = false;

    protected $resolver;

    protected $eventProvider;

    protected $resolve_stack = [];

    public function __construct(array $config = [], Resolver $resolver = null)
    {
        $this->resolver = $resolver ?? new Resolver($this);
        $this->boot($config);

        static::$instance = $this;
    }

    /**
     * Returns current instance if available and merges any available configuration.
     * This is the method used throughout the library to retrieve configuration.
     *
     * @param array $items
     * @param Resolver|null $resolver
     *
     * @return Config
     */
    public static function instance(array $items = [], Resolver $resolver = null)
    {
        if (static::$instance && !empty($items)) {
            return static::newInstance(array_merge(static::$instance->container, $items), $resolver);
        }

        if (static::$instance && $resolver) {
            static::$instance->resolver = $resolver;
        }

        return static::$instance ?? static::newInstance($items, $resolver);
    }

    /**
     * Always returns a new instance. Used primary for testing. If used be aware that any previous changes
     * to the instance will be lost. If it's in test mode it will remain until you explicitly remove it.
     * You should never need to reference this directly except inside of tests.
     *
     * @param array $items
     * @param Resolver|null $resolver
     *
     * @return Config
     */
    public static function newInstance(array $items = [], Resolver $resolver = null)
    {
        return new static($items, $resolver);
    }

    /**
     * This merges in a testing configuration. Any instance from this point will use that configuration.
     *
     * @param array $items
     * @param Resolver|null $resolver
     *
     * @return Config
     */
    public static function testInstance(array $items = [], Resolver $resolver = null)
    {
        if (static::$test_mode === false && !is_null(static::$instance)) {
            static::$instance = null;
        }

        static::$test_mode = true;

        return static::instance($items, $resolver);
    }

    /**
     * Same as endTest, but also returns a fresh instance.
     *
     * @param array $items
     * @param Resolver|null $resolver
     *
     * @return Config
     */
    public static function killTestInstance(array $items = [], Resolver $resolver = null)
    {
        (new static())->endTest();

        return static::instance($items, $resolver);
    }

    /**
     * This removes the testing flag and allow the normal configuration to return. This must be called to have
     * the library behave normally when testing.
     *
     * @return Config
     */
    public function endTest()
    {
        static::$test_mode = false;
        static::$instance = null;

        return $this;
    }

    /**
     * Returns the Resolver if no class is specified otherwise it attempts to resolve the given class.
     *
     * @param string|null $class
     * @param mixed ...$parameters
     *
     * @return Resolver|mixed|null
     */
    public function __invoke(string $class = null, ...$parameters)
    {
        if (is_null($class)) {
            return $this->resolve();
        }

        if ($this->hasResolvable($class)) {
            return $this->resolveFromStack($class);
        }

        if (array_key_exists($class, $this->apiObjects())) {
            return $this->resolve()->make($this->getApiObject($class), ...$parameters);
        }

        if (array_key_exists($class, $this->com())) {
            return $this->resolve()->make($this->com()[$class], ...$parameters);
        }

        throw UnresolvableClassException::default($class);
    }

    /**
     * @return Resolver
     */
    public function resolve()
    {
        return $this->resolver;
    }

    /**
     * Returns the current resolve stack.
     *
     * @return array
     */
    public function resolveStack()
    {
        return $this->resolve_stack;
    }

    /**
     * This attempts to get a resolvable item from the stack. Items on the stack are FIFO (First In First Out).
     * This is only ever utilized if using the Config classes' __invoke capability.
     *
     * @param $abstract
     *
     * @return mixed|null
     */
    public function resolveFromStack($abstract)
    {
        foreach ($this->resolve_stack as $key => $resolvable) {
            if (array_key_exists($abstract, $resolvable)) {
                $result = $resolvable[$abstract];
                unset($this->resolve_stack[$key]);

                return $result;
            }
        }

        return null;
    }

    /**
     * Add new resolvable to the end of the stack.
     *
     * @param $abstract
     * @param $concrete
     *
     * @return Config
     */
    public function addResolvable($abstract, $concrete)
    {
        $this->resolve_stack[] = [$abstract => $concrete];

        return $this;
    }

    /**
     * Check stack for resolvable. There may be a chance for caching pointers for resolvable abstracts.
     *
     * @param $abstract
     *
     * @return bool
     */
    public function hasResolvable($abstract): bool
    {
        foreach ($this->resolve_stack as $key => $resolvable) {
            if (array_key_exists($abstract, $resolvable)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @return array
     */
    public function apiObjects()
    {
        return $this->get('wmi.api_objects', []);
    }

    /**
     * @param string $abstract_class
     * @param string|callable|object $concrete_class
     *
     * @return Config
     */
    public function addApiObject(string $abstract_class, $concrete_class)
    {
        $this->set("wmi.api_objects.{$abstract_class}", $concrete_class);

        return $this;
    }

    /**
     * @param string $class
     *
     * @return string
     */
    public function getApiObject(string $class)
    {
        return $this->get("wmi.api_objects.{$class}");
    }

    /**
     * @return array
     */
    public function com()
    {
        return $this->get('com', []);
    }

    /**
     * @param string $abstract_class
     * @param string|callable|object $concrete_class
     *
     * @return Config
     */
    public function addComObject(string $abstract_class, $concrete_class)
    {
        $this->set("com.{$abstract_class}", $concrete_class);

        return $this;
    }

    /**
     * @return EventProvider
     */
    public function eventProvider()
    {
        return $this->getProvider('event');
    }

    /**
     * @return EventHistoryProvider
     */
    public function eventHistoryProvider()
    {
        return $this->getProvider('event_history');
    }

    /**
     * @return CommandBus
     */
    public function commandBus()
    {
        return $this->getProvider('bus');
    }

    /**
     * Return an already registered provider or instantiate it from configuration when $default is null.
     *
     * @param string $alias
     * @param null|mixed $default
     *
     * @return mixed
     */
    public function getProvider($alias, $default = null)
    {
        $default = $default ?? function () use ($alias) {
            return $this->registerProvider($alias);
        };

        return $this->get("providers.registered.{$alias}", $default);
    }

    public function getCacheDriver($provider = null)
    {
        $provider = is_null($provider) ? $provider : "{$provider}.";

        $driver = $this->get("{$provider}cache.driver");

        return new $driver($this);
    }

    public function shouldTrackEvents()
    {
        return $this->get('event.track', false);
    }

    public function trackEvents()
    {
        $this->set('event.track', true);

        return $this;
    }

    public function doNotTrackEvents()
    {
        $this->set('event.track', false);

        return $this;
    }

    /**
     * @return string
     */
    public function getComClass()
    {
        return $this->get('com.com_class');
    }

    /**
     * @return string
     */
    public function getVariantClass()
    {
        return $this->get('com.variant_class');
    }

    /**
     * @return string
     */
    public function getComVariantWrapper()
    {
        return $this->get('com.' . ComVariantWrapper::class);
    }

    /**
     * @return string
     */
    public function getComWrapper()
    {
        return $this->get('com.' . ComWrapper::class);
    }

    /**
     * @return string
     */
    public function getVariantWrapper()
    {
        return $this->get('com.' . VariantWrapper::class);
    }

    /**
     * @return Connections
     */
    public function connections()
    {
        return $this->get('wmi.connections.servers');
    }

    /**
     * @param string $name
     *
     * @return ComConnection|null
     */
    public function getConnection(string $name = null)
    {
        if ($name === 'default' || is_null($name)) {
            $name = $this->get('wmi.connections.default');
        }

        return $this->connections()->get($name);
    }

    /**
     * @param string        $name
     * @param ComConnection $connection
     *
     * @return Config
     */
    public function addConnection(string $name, ComConnection $connection): self
    {
        $this->connections()->set($name, $connection);

        return $this;
    }

    public function getDefaultConnection()
    {
        return $this->getConnection($this->getDefaultConnectionName());
    }

    public function getDefaultConnectionName()
    {
        return $this->get('wmi.connections.default');
    }

    public function setDefaultConnection(string $name)
    {
        if (!$this->getConnection($name)) {
            throw InvalidConnectionException::new($name);
        }

        return $this->set('wmi.connections.default', $name);
    }

    public function registerProvider($provider_alias, $instance = null)
    {
        if (!is_object($instance) && ($instance = $this->getProvider($provider_alias, false)) === false) {
            $instance = $this->get("providers.bootstrap.{$provider_alias}");
            $instance = new $instance($this);
        }

        $this->set("providers.registered.{$provider_alias}", $instance);

        return $instance;
    }

    protected function boot(array $config)
    {
        if (static::$test_mode) {
            $this->merge(include(__DIR__ . '/../config/testing.php'));
        }

        if (!empty($config)) {
            $this->merge($config);
        }

        $this->merge(include(__DIR__ . '/../config/bootstrap.php'))
            ->registerProviders()
            ->bootConnections();
    }

    protected function registerProviders()
    {
        array_map(function ($alias) {
            $this->registerProvider($alias);
        }, array_keys($this->get('providers.bootstrap', [])));

        return $this;
    }

    protected function bootConnections()
    {
        Arr::set($this->container, 'wmi.connections.servers', new Connections($this));

        return $this;
    }
}