<?php

/**
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; under version 2
 * of the License (non-upgradable).
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * Copyright (c) 2014-2017 (original work) Open Assessment Technologies SA;
 *
 *
 */

namespace oat\generis\scripts\update;

use common_Exception;
use common_exception_NotImplemented;
use common_ext_ExtensionsManager;
use common_ext_ExtensionUpdater;
use core_kernel_impl_ApiModelOO;
use core_kernel_persistence_smoothsql_SmoothModel;
use EasyRdf_Exception;
use League\Flysystem\Adapter\Local;
use League\Flysystem\Memory\MemoryAdapter;
use oat\generis\model\data\ModelManager;
use oat\generis\model\data\Ontology;
use oat\generis\model\fileReference\FileReferenceSerializer;
use oat\generis\model\fileReference\ResourceFileSerializer;
use oat\generis\model\kernel\persistence\smoothsql\search\ComplexSearchService;
use oat\generis\model\kernel\uri\UriProvider;
use oat\generis\model\user\AuthAdapter;
use oat\generis\model\user\UserFactoryService;
use oat\generis\model\WidgetRdf;
use oat\generis\persistence\PersistenceManager;
use oat\oatbox\action\ActionService;
use oat\oatbox\cache\KeyValueCache;
use oat\oatbox\cache\SimpleCache;
use oat\oatbox\config\ConfigurationService;
use oat\oatbox\filesystem\FileSystemService;
use oat\oatbox\log\logger\TaoLog;
use oat\oatbox\log\LoggerService;
use oat\oatbox\mutex\LockService;
use oat\oatbox\mutex\NoLockStorage;
use oat\oatbox\service\ServiceNotFoundException;
use oat\oatbox\session\SessionService;
use oat\oatbox\task\implementation\InMemoryQueuePersistence;
use oat\oatbox\task\implementation\SyncQueue;
use oat\oatbox\task\implementation\TaskQueuePayload;
use oat\oatbox\task\Queue;
use oat\oatbox\task\TaskRunner;
use oat\oatbox\user\UserLanguageService;
use oat\taoWorkspace\model\generis\WrapperModel;
use Psr\Log\LoggerInterface;
use oat\generis\model\kernel\persistence\file\FileIterator;
use Traversable;

/**
 * @author Joel Bout <joel@taotesting.com>
 * @deprecated use migrations instead. See https://github.com/oat-sa/generis/wiki/Tao-Update-Process
 */
class Updater extends common_ext_ExtensionUpdater
{
    /**
     * @param string $initialVersion
     *
     * @return string $versionUpdatedTo
     * @throws common_Exception
     * @throws EasyRdf_Exception
     */
    public function update($initialVersion)
    {
        if ($this->isBetween('0.0.0', '2.11.0')) {
            throw new common_exception_NotImplemented(
                'Updates from versions prior to Tao 3.1 are not longer supported, please update to Tao 3.1 first'
            );
        }
        // in order to prevent update scripts to fail we run some early fixes
        $this->runPreChecks();

        $this->skip('2.12.0', '2.18.0');

        if ($this->isVersion('2.18.0')) {
            $this->getServiceManager()->register(ActionService::SERVICE_ID, new ActionService());
            $this->setVersion('2.19.0');
        }

        if ($this->isVersion('2.19.0')) {
            try {
                $this->getServiceManager()->get(Queue::CONFIG_ID);
            } catch (ServiceNotFoundException $e) {
                $service = new SyncQueue([]);
                $service->setServiceManager($this->getServiceManager());

                $this->getServiceManager()->register(Queue::CONFIG_ID, $service);
            }
            $this->setVersion('2.20.0');
        }


        $this->skip('2.20.0', '2.29.1');
        if ($this->isVersion('2.29.1')) {
            $this->getServiceManager()->register(FileReferenceSerializer::SERVICE_ID, new ResourceFileSerializer());
            $this->setVersion('2.30.0');
        }

        $this->skip('2.30.0', '2.31.6');

        if ($this->isVersion('2.31.6')) {
            $complexSearch = new ComplexSearchService(
                [
                    'shared' => [
                        'search.query.query' => false,
                        'search.query.builder' => false,
                        'search.query.criterion' => false,
                        'search.tao.serialyser' => false,
                        'search.tao.result' => false,
                    ],
                    'invokables' => [
                        'search.query.query' => '\\oat\\search\\Query',
                        'search.query.builder' => '\\oat\\search\\QueryBuilder',
                        'search.query.criterion' => '\\oat\\search\\QueryCriterion',
                        'search.driver.postgres' => '\\oat\\search\\DbSql\\Driver\\PostgreSQL',
                        'search.driver.mysql' => '\\oat\\search\\DbSql\\Driver\\MySQL',
                        'search.driver.tao' => '\\oat\\generis\\model\\kernel\\persistence\\smoothsql\\search\\driver\\TaoSearchDriver',
                        'search.tao.serialyser' => '\\oat\\search\\DbSql\\TaoRdf\\UnionQuerySerialyser',
                        'search.factory.query' => '\\oat\\search\\factory\\QueryFactory',
                        'search.factory.builder' => '\\oat\\search\\factory\\QueryBuilderFactory',
                        'search.factory.criterion' => '\\oat\\search\\factory\\QueryCriterionFactory',
                        'search.tao.gateway' => '\\oat\\generis\\model\\kernel\\persistence\\smoothsql\\search\\GateWay',
                        'search.tao.result' => '\\oat\\generis\\model\\kernel\\persistence\\smoothsql\\search\\TaoResultSet',
                    ],
                    'abstract_factories' => [
                        '\\oat\\search\\Command\\OperatorAbstractfactory',
                    ],
                    'services' => [
                        'search.options' => [
                            'table' => 'statements',
                            'driver' => 'taoRdf',
                        ],
                    ],
                ]
            );

            $this->getServiceManager()->register(ComplexSearchService::SERVICE_ID, $complexSearch);
            $this->setVersion('3.0.0');
        }

        $this->skip('3.0.0', '3.6.1');

        if ($this->isVersion('3.6.1')) {
            $model = ModelManager::getModel();
            if ($model instanceof core_kernel_persistence_smoothsql_SmoothModel) {
                $model->setOption(
                    core_kernel_persistence_smoothsql_SmoothModel::OPTION_SEARCH_SERVICE,
                    ComplexSearchService::SERVICE_ID
                );
                ModelManager::setModel($model);
            }
            $this->setVersion('3.7.0');
        }

        if ($this->isBetween('3.7.0', '3.8.3')) {
            /* @var $modelWrapper WrapperModel */
            $modelWrapper = ModelManager::getModel();
            if ($modelWrapper instanceof WrapperModel) {
                $inner = $modelWrapper->getInnerModel();
                $inner->setOption(
                    core_kernel_persistence_smoothsql_SmoothModel::OPTION_SEARCH_SERVICE,
                    ComplexSearchService::SERVICE_ID
                );

                $workspace = $modelWrapper->getWorkspaceModel();
                $workspace->setOption(
                    core_kernel_persistence_smoothsql_SmoothModel::OPTION_SEARCH_SERVICE,
                    ComplexSearchService::SERVICE_ID
                );

                $wrappedModel = WrapperModel::wrap($inner, $workspace);
                $wrappedModel->setServiceLocator($this->getServiceManager());
                ModelManager::setModel($wrappedModel);
            }
            $this->setVersion('3.8.4');
        }
        $this->skip('3.8.4', '3.9.0');

        if ($this->isVersion('3.9.0')) {
            $fsm = $this->getServiceManager()->get(FileSystemService::SERVICE_ID);
            $fsm->createFileSystem(Queue::FILE_SYSTEM_ID, Queue::FILE_SYSTEM_ID);
            $this->getServiceManager()->register(FileSystemService::SERVICE_ID, $fsm);
            $this->setVersion('3.10.0');
        }

        $this->skip('3.10.0', '3.27.0');

        if ($this->isVersion('3.27.0')) {
            if (!$this->getServiceManager()->has(common_ext_ExtensionsManager::SERVICE_ID)) {
                $this->getServiceManager()->register(
                    common_ext_ExtensionsManager::SERVICE_ID,
                    new common_ext_ExtensionsManager()
                );
            }
            $this->setVersion('3.28.0');
        }

        $this->skip('3.28.0', '3.29.1');

        if ($this->isVersion('3.29.1')) {
            $this->getServiceManager()->register(LoggerService::SERVICE_ID, new LoggerService());
            $this->setVersion('3.30.0');
        }

        $this->skip('3.30.0', '3.34.0');

        /**
         * replaced update script 3.34.0 because of potential config loss
         */
        if ($this->isVersion('3.34.0')) {
            $queue = $this->getServiceManager()->get(Queue::SERVICE_ID);

            if (get_class($queue) === 'oat\Taskqueue\Persistence\RdsQueue') {
                $persistence = $queue->getOption('persistence');
                $queue->setOptions(
                    [
                        'payload' => '\oat\oatbox\task\implementation\TaskQueuePayload',
                        'runner' => '\oat\oatbox\task\TaskRunner',
                        'persistence' => '\oat\Taskqueue\Persistence\TaskSqlPersistence',
                        'config' => ['persistence' => $persistence],
                    ]
                );
            } else {
                $queue->setOptions(
                    [
                        'payload' => TaskQueuePayload::class,
                        'runner' => TaskRunner::class,
                        'persistence' => InMemoryQueuePersistence::class,
                        'config' => [],
                    ]
                );
            }
            $this->getServiceManager()->register(Queue::SERVICE_ID, $queue);
            /**
             * skip because you don't need to fix config
             */
            $this->setVersion('3.35.2');
        }

        /**
         * you are on a bad version needs to be fixed
         */
        $this->skip('3.35.0', '3.35.1');

        /**
         * fix for bad config
         */
        if ($this->isVersion('3.35.1')) {
            $queue = $this->getServiceManager()->get(Queue::SERVICE_ID);
            if (get_class($queue) === 'oat\Taskqueue\Persistence\RdsQueue') {
                $queue->setOptions(
                    [
                        'payload' => '\oat\oatbox\task\implementation\TaskQueuePayload',
                        'runner' => '\oat\oatbox\task\TaskRunner',
                        'persistence' => '\oat\Taskqueue\Persistence\TaskSqlPersistence',
                        'config' => ['persistence' => 'default'],
                    ]
                );
            }
            $this->getServiceManager()->register(Queue::SERVICE_ID, $queue);
            $this->setVersion('3.35.2');
        }

        $this->skip('3.35.2', '4.1.4');

        if ($this->isVersion('4.1.4')) {
            /** Rdf synchronization was moved to version 4.4.1 (see below) because OntologyUpdater is in tao extension */
            //            OntologyUpdater::syncModels();
            $this->setVersion('4.2.0');
        }
        $this->skip('4.2.0', '4.4.0');

        if ($this->isVersion('4.4.0')) {
            $file = __DIR__ . DIRECTORY_SEPARATOR .
                '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR .
                'core' . DIRECTORY_SEPARATOR .
                'ontology' . DIRECTORY_SEPARATOR .
                'taskqueue.rdf';
            $api = core_kernel_impl_ApiModelOO::singleton();
            $api->importXmlRdf('http://www.tao.lu/Ontologies/taskqueue.rdf', $file);
            $this->setVersion('4.4.1');
        }

        $this->skip('4.4.1', '6.7.0');

        if ($this->isVersion('6.7.0')) {
            $file = __DIR__ . DIRECTORY_SEPARATOR .
                '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR .
                'core' . DIRECTORY_SEPARATOR .
                'ontology' . DIRECTORY_SEPARATOR .
                'generis.rdf';
            $api = core_kernel_impl_ApiModelOO::singleton();
            $api->importXmlRdf('http://www.tao.lu/Ontologies/generis.rdf', $file);
            $this->setVersion('6.8.0');
        }

        $this->skip('6.8.0', '6.8.1');

        if ($this->isVersion('6.8.1')) {
            if ($this->getExtension()->hasConfig('logger')) {
                $this->getExtension()->unsetConfig('logger');
            }

            $conf = $this->getExtension()->getConfig('log');
            if (!$conf instanceof LoggerInterface) {
                $logger = new LoggerService([
                    LoggerService::LOGGER_OPTION => new TaoLog([
                        TaoLog::OPTION_APPENDERS => $conf,
                    ]),
                ]);
                $header = $this->getExtension()->getConfigHeader('log');
                $logger->setHeader($header);
                $this->getServiceManager()->register(LoggerService::SERVICE_ID, $logger);
            }
            $this->setVersion('6.9.0');
        }

        $this->skip('6.9.0', '6.16.0');

        if ($this->isVersion('6.16.0')) {
            $userFactory = new UserFactoryService([]);
            $this->getServiceManager()->register(UserFactoryService::SERVICE_ID, $userFactory);

            /** @var common_ext_ExtensionsManager $extensionManager */
            $extensionManager = $this->getServiceManager()->get(common_ext_ExtensionsManager::SERVICE_ID);
            $config = $extensionManager->getExtensionById('generis')->getConfig('auth');

            foreach ($config as $index => $adapter) {
                if ($adapter['driver'] === AuthAdapter::class) {
                    $adapter['user_factory'] = UserFactoryService::SERVICE_ID;
                }
                $config[$index] = $adapter;
            }

            $extensionManager->getExtensionById('generis')->setConfig('auth', array_values($config));

            $this->setVersion('6.17.0');
        }

        $this->skip('6.17.0', '7.1.1');

        if ($this->isVersion('7.1.1')) {
            $this->getServiceManager()->register(UserLanguageService::SERVICE_ID, new UserLanguageService());
            $this->setVersion('7.2.0');
        }

        $this->skip('7.2.0', '7.14.2');

        if ($this->isVersion('7.14.2')) {
            $this->getServiceManager()->register(SessionService::SERVICE_ID, new SessionService());
            $modelConfig = $this->getServiceManager()->get(Ontology::SERVICE_ID)->getConfig();
            $className = $modelConfig['class'];
            $ontologyModel = new $className($modelConfig['config']);
            if ($ontologyModel instanceof core_kernel_persistence_smoothsql_SmoothModel) {
                $ontologyModel->setOption(
                    \core_kernel_persistence_smoothsql_SmoothModel::OPTION_CACHE_SERVICE,
                    \common_cache_Cache::SERVICE_ID
                );
            }
            $this->getServiceManager()->register(Ontology::SERVICE_ID, $ontologyModel);
            $this->setVersion('8.0.0');
        }

        $this->skip('8.0.0', '9.1.3');

        if ($this->isVersion('9.1.3')) {
            $this->getServiceManager()->unregister('generis/profiler');
            $this->setVersion('10.0.0');
        }

        $this->skip('10.0.0', '10.1.0');

        if ($this->isBetween('10.1.0', '11.0.0')) {
            /** @var \common_persistence_Manager $persistenceManager */
            $persistenceManager = $this->getServiceManager()->get(\common_persistence_Manager::SERVICE_ID);

            $persistenceManagerConfig = $persistenceManager->getOption('persistences');
            foreach ($persistenceManagerConfig as $persistenceId => $persistenceParams) {
                // wrap pdo drivers in dbal
                if (strpos($persistenceParams['driver'], 'pdo_') === 0) {
                    $persistenceManagerConfig[$persistenceId] = [
                        'driver' => 'dbal',
                        'connection' => $persistenceParams,
                    ];
                }
            }
            $persistenceManager->setOption('persistences', $persistenceManagerConfig);
            $this->getServiceManager()->register(\common_persistence_Manager::SERVICE_ID, $persistenceManager);

            $this->setVersion('11.0.0');
        }

        $this->skip('11.0.0', '11.1.1');

        if ($this->isVersion('11.1.1')) {
            //            $service = new LockService([
            //                LockService::OPTION_PERSISTENCE_CLASS => PdoStore::class,
            //                LockService::OPTION_PERSISTENCE_OPTIONS => 'default',
            //            ]);
            //            $this->getServiceManager()->register(LockService::SERVICE_ID, $service);
            //            $service->install();
            $this->setVersion('11.2.0');
        }

        $this->skip('11.2.0', '11.2.1');

        if ($this->isVersion('11.2.1')) {
            $service = new LockService([
                LockService::OPTION_PERSISTENCE_CLASS => NoLockStorage::class
            ]);
            $this->getServiceManager()->register(LockService::SERVICE_ID, $service);
            $this->setVersion('11.2.2');
        }

        $this->skip('11.2.2', '11.3.1');

        if ($this->isVersion('11.3.1')) {
            /** @var \common_persistence_Manager $persistenceManager */
            $persistenceManager = $this->getServiceManager()->get(\common_persistence_Manager::SERVICE_ID);
            $persistenceManagerConfig = $persistenceManager->getOption('persistences');

            foreach ($persistenceManagerConfig as $persistenceId => $persistenceParams) {
                $persistenceManager->registerPersistence($persistenceId, $persistenceParams);
            }

            $this->getServiceManager()->register(\common_persistence_Manager::SERVICE_ID, $persistenceManager);
            $this->setVersion('11.3.2');
        }

        $this->skip('11.3.2', '11.5.2');

        if ($this->isVersion('11.5.2')) {
            $this->runExtensionScript(RegisterDefaultKvPersistence::class);

            $this->setVersion('11.6.0');
        }

        $this->skip('11.6.0', '12.1.0');

        if ($this->isBetween('12.1.0', '12.2.0')) {
            $fs = $this->getServiceManager()->get(FileSystemService::SERVICE_ID);
            $adapters = $fs->getOption(FileSystemService::OPTION_ADAPTERS);
            if (!isset($adapters['default'])) {
                if (get_class($fs) == FileSystemService::class) {
                    // override default behavior to ensure an adapter and not a directory is created
                    $adapters['default'] = [
                        'class' => Local::class,
                        'options' => ['root' => $fs->getOption(FileSystemService::OPTION_FILE_PATH)]
                    ];
                    $fs->setOption(FileSystemService::OPTION_ADAPTERS, $adapters);
                } else {
                    $fs->createFileSystem('default', '');
                }
                $this->getServiceManager()->register(FileSystemService::SERVICE_ID, $fs);
            }
            $this->setVersion('12.2.0');
        }
        $this->skip('12.2.0', '12.4.0');
        if ($this->isVersion('12.4.0')) {
            $uriService = $this->getServiceManager()->get(UriProvider::SERVICE_ID);
            if ($uriService instanceof ConfigurationService) {
                $innerService = $uriService->getConfig();
                if ($innerService instanceof UriProvider) {
                    $this->getServiceManager()->register(UriProvider::SERVICE_ID, $innerService);
                } else {
                    throw new \common_exception_InconsistentData('Unknown URI Provider found');
                }
            }
            $this->setVersion('12.4.1');
        }
        $this->skip('12.4.1', '12.11.0');

        if ($this->isVersion('12.11.0')) {
            /** @var \common_persistence_Persistence $defaultPersistence */
            $defaultPersistence = $this->getServiceManager()
                ->get(PersistenceManager::SERVICE_ID)
                ->getPersistenceById('default');
            /** @var \common_persistence_sql_SchemaManager $schemaManager */
            $schemaManager = $defaultPersistence->getDriver()->getSchemaManager();
            $schema = $schemaManager->createSchema();
            $fromSchema = clone $schema;
            $schema->dropTable('models');
            $queries = $defaultPersistence->getPlatform()->getMigrateSchemaSql($fromSchema, $schema);
            foreach ($queries as $query) {
                $defaultPersistence->exec($query);
            }
            $this->setVersion('12.12.0');
        }

        $this->skip('12.12.0', '12.20.2');

        if ($this->isVersion('12.20.2')) {
            $file = __DIR__ . DIRECTORY_SEPARATOR .
                '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR .
                'core' . DIRECTORY_SEPARATOR .
                'ontology' . DIRECTORY_SEPARATOR .
                'generis.rdf';
            $api = core_kernel_impl_ApiModelOO::singleton();
            $api->importXmlRdf('http://www.tao.lu/Ontologies/generis.rdf', $file);

            $this->setVersion('12.21.0');
        }
        $this->skip('12.21.0', '12.22.1');

        if ($this->isVersion('12.22.1')) {
            /** @var FileSystemService $fs */
            $fs = $this->getServiceManager()->get(FileSystemService::SERVICE_ID);
            $adapters = $fs->getOption(FileSystemService::OPTION_ADAPTERS);
            $adapters['memory'] = [ 'class' => MemoryAdapter::class, ];
            $fs->setOption(FileSystemService::OPTION_ADAPTERS, $adapters);
            $this->getServiceManager()->register(FileSystemService::SERVICE_ID, $fs);

            $this->setVersion('12.23.0');
        }

        $this->skip('12.23.0', '12.26.1');

        if ($this->isVersion('12.26.1')) {
            core_kernel_impl_ApiModelOO::singleton()->importXmlRdf(
                WidgetRdf::NAMESPACE,
                __DIR__ . '/../../core/ontology/widgetdefinitions.rdf'
            );

            $this->setVersion('12.27.0');
        }

        $this->skip('12.27.0', '12.28.0');

        if ($this->isVersion('12.28.0')) {
            $this->removeDuplicates(new FileIterator(__DIR__ . '/../../core/ontology/widgetdefinitions.rdf'));
            $this->setVersion('12.28.1');
        }

        //Updater files are deprecated. Please use migrations.
        //See: https://github.com/oat-sa/generis/wiki/Tao-Update-Process

        $this->setVersion($this->getExtension()->getManifest()->getVersion());
    }

    /**
     * Helper for the unfortunate scenario where we generated duplicate
     * entries in the statement table.
     *
     * Fixes the duplicates by removing all matching triples and then
     * readding them only once
     */
    protected function removeDuplicates(Traversable $triples): void
    {
        $rdfModel = $this->getServiceLocator()->get(Ontology::SERVICE_ID)->getRdfInterface();
        foreach ($triples as $triple) {
            $rdfModel->remove($triple);
        }
        $rdfModel->addTripleCollection($triples);
    }

    /**
     * Runs required fixes that allow the rest of the updates to run
     */
    protected function runPreChecks(): void
    {
        // 12.22.0 introduced PSR-16 cache required for update process
        if (!$this->getServiceManager()->has(SimpleCache::SERVICE_ID)) {
            $psrCache = new KeyValueCache([KeyValueCache::OPTION_PERSISTENCE => 'cache']);
            $this->getServiceManager()->register(SimpleCache::SERVICE_ID, $psrCache);
        }
    }
}