Factory.php

<?php

namespace UNAM\Tupa\Backend\API;

use Gelf\Transport\TcpTransport;
use SIU\TobaDb\DbPDO;
use UNAM\Tupa\Core\Config\Builder\{ApiConfigBuilder,GeneralConfigBuilder,ServicesConfigBuilder};
use UNAM\Tupa\Core\Util\{Codigo,Varios,EnvLoader};
use UNAM\Tupa\Core\Manager\ManagerRegistro;
use UNAM\Tupa\Backend\API\Config\APIConfiguracion;
use Gelf\Publisher;
use Gelf\Transport\{UdpTransport,IgnoreErrorTransportWrapper};
use Monolog\Formatter\{LineFormatter,GelfMessageFormatter};
use Monolog\Handler\{ErrorLogHandler,GelfHandler,StreamHandler,SyslogHandler};
use Monolog\Logger;
use Pimple\Container;
use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Yaml\Yaml;

class Factory
{
    /**
     * @var Container
     */
    protected static $container;

    /**
     * @param bool $reload
     * @return Container
     */
    public static function getContainer($reload = false)
    {
        if (isset(static::$container) && !$reload) {
            return static::$container;
        }
        $proyect_dir = realpath(__DIR__ . '/../../../../..');

        $container = new Container();
        $container['project-dir'] = $proyect_dir;
        $container['temporal-dir'] = $proyect_dir.'/temp';
        $container['config-dir'] = $proyect_dir.'/config';
        $container['www-dir'] = $proyect_dir.'/www';
        $container['templates-dir'] = $proyect_dir.'/templates';
        $container['general-log-file'] = $proyect_dir.'/tupa.log';
        $container['env-instalacion'] = '.env';
        $container['env-instalacion-template'] = '/templates/.env.dist';


        $container['logger-handler'] = function ($c) {
            $logLevel = $c['configuration']->getApiLogLevel();
            $logHandler = $c['configuration']->getApiLogHandler();
            switch ($logHandler) {
                case 'errorlog':
                    $handler = new ErrorLogHandler();
                    $handler->setFormatter(new LineFormatter(null, null, true));
                    $handler->setLevel($logLevel);
                    break;
                case 'syslog':
                    $handler = new SyslogHandler('tupa');
                    $handler->setFormatter(new LineFormatter(null, null, true));
                    $handler->setLevel($logLevel);
                    break;
                case 'graylog':
                    $graylogHost = $c['configuration']->getGraylogHost();
                    $graylogPort = $c['configuration']->getGraylogPort();
                    $graylogProtocol = $c['configuration']->getGraylogProtocol();

                    if ($graylogProtocol == 'udp') {
                        $transport = new UdpTransport($graylogHost, $graylogPort);
                    } else {
                        $transport = new TcpTransport($graylogHost, $graylogPort);
                    }

                    $ignoreErrorTransport = new IgnoreErrorTransportWrapper($transport);
                    $publisher = new Publisher($ignoreErrorTransport);

                    $handler = new GelfHandler($publisher, $logLevel);

                    $formatter = new GelfMessageFormatter('tupa');
                    $handler->setFormatter($formatter);
                    break;
                case 'file':
                default:
                    $handler = new StreamHandler($c['general-log-file'], null, null, 0666);
                    $handler->setFormatter(new LineFormatter(null, null, true));
                    $handler->setLevel($logLevel);
                    break;
            }

            return $handler;
        };

        $container['main-logger'] = function ($c) {
            $logger = new Logger('MAIN');
            $handler = $c['logger-handler'];


            $logger->pushHandler($handler);
            return $logger;
        };

        $container['stdout-logger'] = function ($c) {
            $logger = new Logger('STDOUT');

            $handler = $c['logger-handler'];
            $logger->pushHandler($handler);

            $formatter = new LineFormatter("%message%\n", null, true);
            $handler = new StreamHandler('php://stdout', Logger::INFO);
            $handler->setFormatter($formatter);
            $logger->pushHandler($handler);

            return $logger;
        };

        $container['db-logger'] = function ($c) {
            $logger = new Logger('DB');
            $handler = $c['logger-handler'];


            $logger->pushHandler($handler);
            return $logger;
        };

        $container['api-logger'] = function ($c) {
            $logger = new Logger('API');
            $handler = $c['logger-handler'];


            $logger->pushHandler($handler);
            return $logger;
        };

        // CONFIG FILES
        $container['parameters-config-file'] = function ($c) {
            return $c['config-dir'].'/parameters.yml';
        };

        $container['parameters-config'] = function ($c) {
            return EnvLoader::parse(Yaml::parse(file_get_contents($c['parameters-config-file'])));
        };

        $container['api-config'] = function ($c) {
            $servicesConfig = $c['parameters-config']['api'];
            $processor = new Processor();
            $configuration = new ApiConfigBuilder();

            return $processor->processConfiguration($configuration, ['services' => $servicesConfig]);
        };

        $container['services-config'] = function ($c) {
            $servicesConfig = $c['parameters-config']['services'];
            $processor = new Processor();
            $configuration = new ServicesConfigBuilder();

            return $processor->processConfiguration($configuration, ['services' => $servicesConfig]);
        };

        $container['general-config'] = function ($c) {
            $generalConfig = $c['parameters-config']['general'];

            $processor = new Processor();
            $configuration = new GeneralConfigBuilder();

            return $processor->processConfiguration($configuration, ['general' => $generalConfig]);
        };

        $container['db-config'] = function ($c) {
            return $c['services-config']['db'];
        };

        $container['varios'] = function ($c) {
            return new Varios($c['main-logger']);
        };

        $container['configuration'] = function ($c) {
            $configuraciones = array(
                APIConfiguracion::API_INDEX => $c['api-config'],
                APIConfiguracion::SERVICES_INDEX => $c['services-config'],
                APIConfiguracion::GENERAL_INDEX => $c['general-config'],
                APIConfiguracion::DATABASE_DB_INDEX => $c['db-config'],
            );

            return new APIConfiguracion($configuraciones);
        };

        $container['db'] = function ($c) {
            return new DbPDO($c['db-config'], $c['db-logger']);
        };

        $container['codigo'] = function ($c) {
            return new Codigo();
        };

        $container['manager-registro'] = function ($c) {
            return new ManagerRegistro($c['db-logger'], $c['db'], $c['codigo']);
        };

//        $container['cache'] = function ($c) {
//            $namespace = 'arai';
//            $defaultLifetime = 3600;
//
//            $backend = $c['configuration']->getCacheBackend();
//
//            $parameters = [
//                'host' => $c['configuration']->getMemachedHost(),
//                'port' => $c['configuration']->getMemachedPort(),
//                'user' => $c['configuration']->getMemachedUsername(),
//                'pass' => $c['configuration']->getMemachedPassword(),
//                'temporal-dir' => $c['temporal-dir'],
//            ];
//
//            $cache = $c['varios']->getCacheByBackend($backend, $namespace, $defaultLifetime, $parameters);
//
//            return $cache;
//        };

        static::$container = $container;

        return static::$container;
    }

    /**
     * Singleton del Logger tipo MAIN.
     *
     * @return Logger
     */
    public static function getMainLogger()
    {
        return self::getContainer()['main-logger'];
    }

    /**
     * Singleton del Logger tipo STD-OUT.
     *
     * @return Logger
     */
    public static function getStdoutLogger()
    {
        return self::getContainer()['stdout-logger'];
    }


    /**
     * Singleton de ManagerRegistro.
     *
     * @return ManagerRegistro
     */
    public static function getManagerRegistro()
    {
        return self::getContainer()['manager-registro'];
    }

    /**
     * Singleton de ManagerRegistro.
     *
     * @return Codigo
     */
    public static function getCodigoGenerador()
    {
        return self::getContainer()['codigo'];
    }

    /**
     * Singleton de Varios.
     *
     * @return Varios
     */
    public static function getVarios()
    {
        return self::getContainer()['varios'];
    }

//    /**
//     * Singleton de Cache.
//     *
//     * @return AdapterInterface
//     */
//    public static function getCache()
//    {
//        return self::getContainer()['cache'];
//    }
}