<?php

/*
 * This file is part of the Maestro CDF.
 * Copyright (C) Compos Juliot
 */

namespace App\Application\Query\Page;

use App\Domain\Adapter\DataDiffInterface;
use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\Adapter\Query\ModuleQueryInterface;
use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\Adapter\Query\ElementTypesTemplates\ReadQueryInterface;
use App\Application\Adapter\Query\Template\TemplateQueryInterface;
use App\Application\View\Common\CommonArrayView;
use App\Application\View\Common\CommonIdView;
use App\Application\View\Page\PageExportView;
use App\Application\View\Page\PageIdView;
use App\Application\View\Page\PageTemplatesView;
use App\Application\View\Page\PageView;
use App\Application\View\Template\TemplateIdsNumberPageProductView;
use App\Application\View\Story\StoryPageOptionsView;
use App\Application\View\Story\StoryPageView;
use App\Domain\Adapter\CdfRepositoryInterface;
use App\Domain\Adapter\PageOptionsRepositoryInterface;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Adapter\GenerationFileDataRepositoryInterface;
use App\Domain\Adapter\TemplateRepositoryInterface;
use App\Domain\Entity\Page;
use App\Domain\Entity\PageOptions;
use App\Infrastructure\Adapter\Provider\Template\ListTemplateInterface;
use App\Infrastructure\Workflow\RegistryCustom;
use Doctrine\ORM\NonUniqueResultException;
use Exception;
use App\Domain\Entity\GenerationFileData;
use App\Domain\Entity\GenerationFile;
use DateTime;
use App\Application\Adapter\FolioInterface;
use App\Application\Adapter\Query\Page\PageAutoGenerationQueryInterface;
use App\Application\Exception\SubException\NotFoundMaestroException;
use App\Domain\Adapter\ElementTypesTemplatesRepositoryInterface;
use App\Domain\Adapter\PageAutoGeneRepositoryInterface;
use App\Domain\Entity\PageDuplicate;
use App\Domain\Entity\Template;
use App\Domain\Entity\VersionExport;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use App\Infrastructure\Adapter\Provider\Media\MediaCollectInterface;
use App\Application\Adapter\Query\ElementMedia\UpdateQueryInterface;
use App\Application\Adapter\Query\Workflow\CommandQueryInterface;
use App\Application\Adapter\Query\Workflow\PlacesQueryInterface;
use App\Application\Adapter\Query\Workflow\TransitionQueryInterface;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Application\View\ElementMedia\UpdateView;
use App\Application\View\Story\StoryPageDupliView;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use App\Application\View\Workflow\StatusView;
use App\Domain\Adapter\Workflow\ConfigurationRepositoryInterface;
use App\Domain\Adapter\Workflow\PlacesRepositoryInterface;
use App\Domain\Adapter\Workflow\TransitionsRepositoryInterface;

class PageQuery extends AbstractController implements PageQueryInterface
{
    /** @var CdfRepositoryInterface */
    private $cdfRepository;

    /** @var PageRepositoryInterface */
    private $pageCdfRepository;

    /** @var PageOptionsRepositoryInterface */
    private $pageOptionsRepository;

    /** @var TemplateRepositoryInterface */
    private $templateRepository;

    /** @var TransitionQueryInterface */
    private $transitionQuery;

    /** @var PlacesQueryInterface */
    private $placeQuery;

    /** @var ReadQueryInterface */
    private $elementTypeTemplateReadQuery;

    /** @var TemplateQueryInterface */
    private $templateQuery;

    /** @var RegistryCustom */
    private $registry;

    /** @var TransitionsRepositoryInterface */
    private $transition;

    /** @var PlacesRepositoryInterface */
    private $placeRepo;

    /** @var ConfigurationRepositoryInterface */
    private $configuration;

    /** @var CommandQueryInterface */
    private $commands;

    /** @var ModuleQueryInterface */
    private $module;

    /** @var StoryQueryInterface */
    private $story;

    /** @var DataDiffInterface */
    private $dataDiff;

    /** @var ListTemplateInterface */
    private $listTemplate;

    /** @var GenerationFileDataRepositoryInterface */
    private $generationFileDataRepository;

    /** @var FolioInterface */
    private $folioService;

    /** @var EntityManager */
    private $entityManager;

    /** @var ParameterBagInterface */
    private $params;

    /** @var PageAutoGeneRepositoryInterface */
    private $pageAutoGeneRepository;

    /** @var ElementTypesTemplatesRepositoryInterface */
    private $exportTemplateRepository;

    /** @var PageAutoGenerationQueryInterface */
    private $pageAutoGenerationQuery;

    /** @var MediaCollectInterface */
    private $mediaCollect;

    /** @var UpdateQueryInterface */
    private $elementMediaUpdateQuery;

    /** @var int */
    private const NO_PLACE = null;

    /** @var RequestStack */
    public $requestStack;

    /** @var KernelInterface */
    public $kernel;

    public function __construct(
        CdfRepositoryInterface $cdfRepository,
        PageRepositoryInterface $pageCdfRepository,
        PageOptionsRepositoryInterface $pageOptionsRepository,
        TemplateRepositoryInterface $templateRepository,
        ElementTypesTemplatesRepositoryInterface $exportTemplateRepository,
        TransitionQueryInterface $transitionQuery,
        PlacesQueryInterface $placeQuery,
        ReadQueryInterface $elementTypeTemplateReadQuery,
        TemplateQueryInterface $templateQuery,
        RegistryCustom $registry,
        TransitionsRepositoryInterface $transition,
        PlacesRepositoryInterface $placeRepo,
        ConfigurationRepositoryInterface $configuration,
        CommandQueryInterface $commands,
        ModuleQueryInterface $module,
        StoryQueryInterface $story,
        DataDiffInterface $dataDiff,
        ListTemplateInterface $listTemplate,
        GenerationFileDataRepositoryInterface $generationFileDataRepository,
        FolioInterface $folioService,
        EntityManagerInterface $entityManager,
        ParameterBagInterface $params,
        MediaCollectInterface $mediaCollect,
        UpdateQueryInterface $elementMediaUpdateQuery,
        PageAutoGeneRepositoryInterface $pageAutoGeneRepository,
        PageAutoGenerationQueryInterface $pageAutoGenerationQuery,
        RequestStack $requestStack,
        KernelInterface $kernel

    ) {
        $this->cdfRepository = $cdfRepository;
        $this->pageCdfRepository = $pageCdfRepository;
        $this->pageOptionsRepository = $pageOptionsRepository;
        $this->templateRepository = $templateRepository;
        $this->transitionQuery = $transitionQuery;
        $this->placeQuery = $placeQuery;
        $this->elementTypeTemplateReadQuery = $elementTypeTemplateReadQuery;
        $this->templateQuery = $templateQuery;
        $this->registry = $registry;
        $this->transition = $transition;
        $this->placeRepo = $placeRepo;
        $this->configuration = $configuration;
        $this->commands = $commands;
        $this->module = $module;
        $this->story = $story;
        $this->dataDiff = $dataDiff;
        $this->listTemplate = $listTemplate;
        $this->generationFileDataRepository = $generationFileDataRepository;
        $this->folioService = $folioService;
        $this->entityManager = $entityManager;
        $this->params = $params;
        $this->mediaCollect = $mediaCollect;
        $this->elementMediaUpdateQuery = $elementMediaUpdateQuery;
        $this->pageAutoGeneRepository = $pageAutoGeneRepository;
        $this->exportTemplateRepository = $exportTemplateRepository;
        $this->pageAutoGenerationQuery = $pageAutoGenerationQuery;
        $this->requestStack = $requestStack;
        $this->kernel = $kernel;
    }

    /**
     * @param int $id            [page's id]
     * @param array $arrayProducts [description]
     *
     * @return bool [description]
     */
    public function saveProductToPage($id, $arrayProducts): bool
    {
        $stringProduct = null;
        if (is_array($arrayProducts)) {
            foreach ($arrayProducts as $product) {
                $stringProduct .= $stringProduct ? ',' : null;
                $stringProduct .= '{"id":' . $product['id'] . ', "name": "' . $product['name'] . '"}';
            }
            $stringProduct = '[' . $stringProduct . ']';
        } else {
            $stringProduct = $arrayProducts;
        }
        $page = $this->pageCdfRepository->read($id);
        $page->setIdProducts($stringProduct);
        $diff = $this->pageCdfRepository->diff($page);
        $entity = $this->pageCdfRepository->save($page);

        if ($entity && count($diff) > 0) {
            $this->story->execute('update', ['pageId' => $id, 'value' => $this->dataDiff->viewDiff($diff)], $id, get_class($page), 0);
        }

        return true;
    }

    /**
     * @param int $id [page's id]
     *
     * @return array [page's information]
     */
    public function readPageExport(int $id, ?int $pageDuplicateId): array
    {


        if (!empty($pageDuplicateId)) {
            $pageDupliRepo = $this->entityManager->getRepository(PageDuplicate::class);
            $dupli = $pageDupliRepo->findOneBy(['id' => $pageDuplicateId]);
            $page = null;
            if (!empty($dupli)) {
                $page = $dupli->getPage();
            }
        } else {
            $dupli = null;
            $page = $this->pageCdfRepository->read($id);
        }

        $idProducts = [];
        $arrayRet = [];

        if ($page) {
            if (!empty($dupli)) {
                $products = json_decode($dupli->getIdProducts(), true);
            } else {
                $products = json_decode($page->getIdProducts(), true);
            }
            $arrayRet['id'] = $page->getId();
            $arrayRet['folio'] = $page->getFolio();
            $arrayRet['pageOptionId'] = $page->getOption()->getId();
            if ($page->getOption()->getTemplate()) {
                $arrayRet['template'] = $page->getOption()->getTemplate()->getName();
                $arrayRet['templateId'] = $page->getOption()->getTemplate()->getId();
            }
            foreach ($products as $product) {
                $idProducts[] = $product['id'];
            }
            $arrayRet['products'] = $idProducts;
        }

        return $arrayRet;
    }

    public function readNbPageExport(int $exportId): array
    {
        $nbPage = $this->cdfRepository->readNbPage($exportId);
        $nbPageMax = $this->cdfRepository->readNbPageMax($exportId);

        $result['nb_page'] = $nbPage ? (int) $nbPage : 0;
        $result['max'] = $nbPageMax ? $nbPageMax['max'] : 0;

        return $result;
    }

    /**
     * {@inheritDoc}
     */
    public function addPage(array $views, ?string $idPageOption, ?bool $cover = false, ?int $folioCover = null): array
    {
        $cdf = $this->cdfRepository->read(reset($views)->idFlatplan);

        if ($cdf) {
            $pageEntities = [];
            $stories = [];
            $templates = [];

            foreach ($views as $view) {

                if (isset($templates[$view->templateId])) {
                    $template = $templates[$view->templateId];
                } else {
                    $template = $view->templateId ? $templates[$view->templateId] = $this->templateRepository->findById($view->templateId) : null;
                }

                $nbPages = $view->nbPages;

                if (!empty($idPageOption)) { // UPDATE CASE
                    $context = 'update page';
                    $pageOptions = $this->pageOptionsRepository->read($idPageOption);
                    $this->pageOptionSetup($pageOptions, $view->name, $nbPages, $view->nbProducts, $template, $cover);
                    $oldNbPages = (int) $pageOptions->getNbPages();

                    $page = $this->pageCdfRepository->findByOption($idPageOption);

                    if ($page) {
                        $page->setIdProducts($view->elements);
                        $pageEntity = $this->pageCdfRepository->save($page);
                    } else {
                        throw new NotFoundMaestroException("No page found for page option $idPageOption");
                    }

                    if ($oldNbPages !== (int) $nbPages) {
                        $pagesToSave = $this->folioService->updateFolios($pageOptions, $cdf);

                        if (!empty($pagesToSave)) {
                            $this->pageCdfRepository->saveMultiple($pagesToSave);
                        }
                    }
                } else { // CREATION CASE (Now in database we store only one page per page option)
                    $context = 'create page';
                    $pageOptions = new PageOptions();
                    $this->pageOptionSetup($pageOptions, $view->name, $nbPages, $view->nbProducts, $template, $cover);

                    $page = new Page();
                    $page->setCdf($cdf);
                    $page->setIdProducts($view->elements);
                    $page->setOption($pageOptions);

                    $folio = $this->pageCdfRepository->getMaxFolio($view->idFlatplan);
                    $lastCdfPage = $this->pageCdfRepository->findLastPageByCdfId($view->idFlatplan);
                    $lastFolio = $lastCdfPage ? $lastCdfPage->getOption()->getNbPages() : 1;
                    $newFolio = $folio + (int) $lastFolio; // Get the right folio based on last page's folio and option's number
                    if ($cover) {
                        $page->setFolio($folioCover);
                    } else {
                        $page->setFolio($newFolio);
                    }

                    $this->entityManager->persist($page);
                    

                    $export = $cdf->getExport();
                    if (empty($idPageOption) && !empty($export->getWorkflowProjects()) && !empty($export->getWorkflowProjects()->getWorkflow()) && $export->getWorkflowProjects()->getPage()) {
                        $firstTransition_key = $this->transitionQuery->getFirstTransition($export->getWorkflowProjects()->getWorkflow(), $this->module->getModule());
                        
                        $firstTransitionKey = $this->transition->findFirstTransition($export->getWorkflowProjects()->getWorkflow(), $this->module->getModule());
                        $firstTransition = $this->transition->findByKey($firstTransitionKey['keyInternal']);
                        $page->setCurrentPlace($firstTransition->getStartPlace()->getKey());
                    }
                    $pageEntity = $page;
                }

                $storyPage[] = new StoryPageView(
                    $pageEntity->getIdProducts(),
                    $pageEntity->getFolio()
                );

                $storyPageOption = new StoryPageOptionsView(
                    $view->name,
                    $view->idFlatplan,
                    $nbPages,
                    $view->nbProducts,
                    $pageOptions->getTemplate() ? $pageOptions->getTemplate()->getId() : null,
                    [$storyPage]
                );

                $stories[] = ['id' => $pageOptions->getId(), 'value' => $storyPageOption];

                $pageEntities[] = $page;
            }
        } else {
            throw new NotFoundMaestroException("No flatplan found for id : " . $views[0]->idFlatplan . " !");
        }

        $this->entityManager->flush();

        $this->story->execute($context, $stories, $views[0]->idFlatplan, get_class($cdf), 0);

        return $pageEntities;
    }

    /**
     * @param PageOptions $pageOptions
     * @param string $name
     * @param int $nbPages
     * @param int $nbProducts
     * @param ?Template $template
     * 
     * @return void
     */
    private function pageOptionSetup(PageOptions $pageOptions, string $name, int $nbPages, int $nbProducts, ?Template $template, $cover): void
    {
        $pageOptions->setName($name);
        $pageOptions->setNbPages($nbPages);
        $pageOptions->setNbProducts($nbProducts);
        $pageOptions->setTemplate($template);
        $pageOptions->setCover($cover);

        $this->pageOptionsRepository->save($pageOptions);
    }


    /**
     * @param int $idPage [description]
     *
     * @return PageExportView [description]
     */
    public function readExport(int $idPage): PageExportView
    {
        $export = $this->pageCdfRepository->readExport($idPage);

        return $export->getId();
    }

    /**
     * @param int $export_id        [description]
     * @param int $configuration_id [description]
     *
     * @return array [description]
     */
    public function addWorkflow($export_id, $configuration_id): array
    {
        $firstTransition_key = null;
        if ($configuration_id > self::NO_PLACE) {
            $firstTransition_key = $this->transitionQuery->getFirstTransition($configuration_id, $this->module->getModule());
        }

        return $this->changeWorkflowExport($export_id, $firstTransition_key);
    }

    /**
     * @param [type] $export_id      [description]
     * @param [type] $transition_key [description]
     *
     * @return array [description]
     */
    public function changeWorkflowExport($export_id, $transition_key): array
    {
        $id = self::NO_PLACE;
        $statusView = $this->StatusViewPlace($export_id, $transition_key);
        if ($transition_key) {
            $id = $statusView['transition']->getConfiguration()->getId();
        }

        return $this->registry->applyStatus($statusView['view'], $id, null);
    }

    /**
     * @param int $export_id        [description]
     * @param int $configuration_id [description]
     *
     * @return bool [description]
     */
    public function updateWorkflow($export_id, $configuration_id): bool
    {
        if (isset($configuration_id)) {
            $firstTransition_key = $this->transitionQuery->getFirstTransition($configuration_id, $this->module->getModule());
            $transition = $this->transition->findByKey($firstTransition_key);
            $place = $transition->getStartPlace();

            $result = $this->pageCdfRepository->changeWorkflow($export_id, $place->getKey());

            return $result;
        }
    }

    /**
     * @param int $page_id        [description]
     * @param string $transition_key [description]
     *
     * @return array [description]
     */
    public function changePlace($page_id, $transition_key): array
    {
        $statusView = $this->StatusViewPlace($page_id, $transition_key);
        $changePlace = $this->registry->applyStatusPage($statusView['view'], $statusView['transition']->getConfiguration()->getId(), null);
        if ($changePlace && $changePlace['currentPlace']) {
            $transitionView = $this->transitionQuery->read($transition_key);
            $this->commands->getCommand($statusView['view'], $transitionView, $page_id);
        }

        return $changePlace;
    }

    /**
     * @param int $object_id      [description]
     * @param string $transition_key [description]
     *
     * @return array [description]
     */
    public function StatusViewPlace($object_id, $transition_key): array
    {
        $transition = null;
        if ($transition_key) {
            try {
                $transition = $this->transition->findByKey($transition_key);
            } catch (NonUniqueResultException $e) {
                $transition = null;
            }
        }

        return ['view' => new StatusView(
            (int) $object_id,
            $transition_key
        ), 'transition' => $transition];
    }

    /**
     * @param int $export_id [description]
     *
     * @return int|mixed|string|null [description]
     */
    public function getLessAdvancedPage(int $export_id)
    {
        $current_places = $this->pageCdfRepository->getCurrentPlacePages($export_id);
        return $this->placeQuery->findFirstPlace($current_places, 'cdf');
    }

    /**
     * @param int $workflow_id [description]
     *
     * @return array [description]
     */
    public function listIdByWorkflowId(int $workflow_id): array
    {
        $pages = $this->pageCdfRepository->listIdByWorkflowId($workflow_id);
        $view = [];

        foreach ($pages as $page) {
            $view[] = new PageIdView(
                $page['id']
            );
        }

        return $view;
    }

    /**
     * @param string $export_id [description]
     *
     * @return array [description]
     */
    public function readPageByExport(string $export_id): array
    {
        $pages = $this->pageCdfRepository->listByExport($export_id);

        $pagesView = [];
        if (count($pages) > 0) {
            foreach ($pages as $page) {
                $place = null;
                $placeName = '';
                $workflowName = '';
                $workflowPageProgression = 100;
                $i = 0;
                if ($page->getCurrentPlace()) {
                    $place = $this->placeRepo->findByKey($page->getCurrentPlace());
                    $workflow_id = $this->configuration->findIdByPlace($page->getCurrentPlace());
                    if (isset($workflow_id) && isset($workflow_id['id'])) {
                        $workflow = $this->configuration->findById($workflow_id['id']);
                        if (isset($workflow) && !$workflow->getDeletedAt()) {
                            $workflowName = $workflow->getName();
                            if (isset($place)) {
                                $placeName = $place->getName();
                                foreach ($workflow->getPlaces() as $workflowPlace) {
                                    $i++;
                                    if ($place == $workflowPlace) {
                                        $placeStepNumber = $i;
                                    }
                                }
                                $workflowPageProgression = intval(($placeStepNumber / $i * 100));
                            }
                        }
                    }
                }

                $pagesView[] = new PageView(
                    $page->getId(),
                    $page->getFolio(),
                    $page->getCdf()->getExport()->getId(),
                    $workflowName,
                    $placeName,
                    $page->getOption()->getName() ?: '',
                    $workflowPageProgression
                );
            }
        }

        return $pagesView;
    }

    /**
     * @param int $element [description]
     *
     * @return [type] [description]
     */
    public function deleteElement(int $element, int $elementType)
    {
        $exportTemplates = $this->exportTemplateRepository->listByElementType($elementType);
        if (!empty($exportTemplates)) {
            $exportsUpdate = [];
            foreach ($exportTemplates as $exportTemplate) {
                $products = $exportTemplate->getElementsPIM();
                if (($key = array_search($element, $products)) !== false) {
                    unset($products[$key]);
                    $exportTemplate->setElementsPIM($products);

                    $exportsUpdate[] = $exportTemplate;
                }
            }

            if (!empty($exportsUpdate)) {
                $this->exportTemplateRepository->saveMultiple($exportsUpdate);
            }
        }

        $pages = $this->pageCdfRepository->list();
        if (!empty($pages)) {
            $pagesUpdate = [];
            foreach ($pages as $page) {
                $decode = json_decode($page->getIdProducts(), true);
                $product = array_filter($decode, function ($prod) use ($element) {
                    return $prod['id'] === $element;
                });

                if (count($product) > 0) {
                    unset($decode[key($product)]);
                    $newPages = array_values($decode);
                    $encode = json_encode($newPages);
                    $page->setIdProducts($encode);
                    $pagesUpdate[] = $page;
                }
            }
            if (!empty($pagesUpdate)) {
                $this->pageCdfRepository->updateElement($pagesUpdate);
                $pageGeneAuto = [];
                foreach ($pagesUpdate as $pageUpdate) {
                    $pageGeneAuto[] = ['id' => $pageUpdate->getId(), "pageDuplicateId" => null];
                    if (!$pageUpdate->getPageDuplicates()->isEmpty()) {
                        foreach ($pageUpdate->getPageDuplicates() as $dupli) {
                            $pageGeneAuto[] = ['id' => $pageUpdate->getId(), "pageDuplicateId" => $dupli->getId()];
                        }
                    }
                }
                $this->pageAutoGenerationQuery->addPageToGenerate($pageGeneAuto);
            }
        }


        return true;
    }

    /**
     * @param CommonIdView $view [description]
     *
     * @return Page|null [description]
     */
    public function read(CommonIdView $view): ?Page
    {
        return $this->pageCdfRepository->read($view->id);
    }

    /**
     * @param int $pageDuplicateId [description]
     *
     * @return mixed [description]
     */
    public function readDuplicate(int $pageDuplicateId)
    {
        $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);

        $pageDuplicate = $dupliRepo->findOneBy([
            "id" => $pageDuplicateId
        ]);

        return $pageDuplicate;
    }

    /**
     * @param array $generated [description]
     *
     * @return bool|Exception [description]
     */
    public function generate(array $generated, Page $page)
    {
        if (!$generated instanceof Exception) {
            $fileType = isset($generated['fileType']) ?? false;
            if ($fileType && $generated['fileType'] === 'html' && isset($generated['files']) && !empty($generated['files'])) {

                $viewData = new CommonArrayView(
                    $generated
                );

                $pageOption = $page->getOption();

                $this->addGeneratedFiles($pageOption, $viewData);
            }

            if (isset($generated['message'])) {
                $message = $generated['message'];
            } else {
                $message = "No message returned.";
            }

            $result = ["message" => $message, "fileType" => $fileType ? $generated['fileType'] : "unknow"];
        } else {
            $result = $generated;
        }

        return $result;
    }

    /**
     * @param CommonIdView $view [description]
     *
     * @return array|Exception [description]
     */
    public function getExportTemplates(CommonIdView $view)
    {
        $exportIdView = new CommonIdView(
            $view->id
        );

        $exportTemplates = $this->elementTypeTemplateReadQuery->templatesByExportId($exportIdView);

        return $exportTemplates;
    }

    /**
     * @param PageTemplatesView $view [description]
     *
     * @return array|Exception [description]
     */
    public function getPageTemplates(PageTemplatesView $view)
    {
        // $pageTemplates = $this->listTemplate->getPageTemplates($view);

        $templatePageProductView = new TemplateIdsNumberPageProductView(
            $view->templateIds,
            $view->nbPage,
            $view->nbProduct
        );

        $templates = $this->templateQuery->readByIdsAndNumberPageProduct($templatePageProductView);

        return $templates;
    }

    /**
     * @param PageOptions $pageOption [description]
     * @param CommonArrayView $view [description]
     *
     * @return string|null|Exception [description]
     */
    public function addGeneratedFiles(PageOptions $pageOption, CommonArrayView $view, bool $import = false)
    {
        $type = $view->data["type"];
        $pageDuplicateId = $view->data["pageDuplicateId"];
        $archived = $this->archivePageGenerationType($pageOption->getId(), $type, $pageDuplicateId);
        $pageDuplicate = null;
        if (isset($pageDuplicateId)) {
            $pageDupliRepo = $this->entityManager->getRepository(PageDuplicate::class);
            $pageDuplicate = $pageDupliRepo->findOneBy(["id" => $pageDuplicateId]);
        }


        if ($archived) {
            foreach ($view->data['files'] as $file) {
                $fileExtension = $file["extension"];
                $fileContent = $file["content"];

                "pdf" === $fileExtension ? $preview = $fileContent : null;

                $generationFileData = new GenerationFileData();
                $generationFileData->setName($file["name"]);
                $generationFileData->setType($type);
                $generationFileData->setExtension($fileExtension);
                if (!empty($pageDuplicate)) {
                    $generationFileData->setPageDuplicate($pageDuplicate);
                }

                $generationFile = new GenerationFile();
                $decoded = base64_decode($fileContent);
                $generationFile->setFile($decoded);
                $generationFile->setGenerationFileData($generationFileData);

                $generationFileData->setGenerationFile($generationFile);
                $generationFileData->setPageOptions($pageOption);

                $pageOption->addGenerationFileData($generationFileData);
            }

            $pageOption->setUpdatedAt(new DateTime()); // Not catched by listener and auto-updated
            if ($import) {
                $pageOption->setImport(true);
            }

            $update = $this->pageOptionsRepository->save($pageOption);

            if (!$update instanceof Exception) {
                $result = isset($preview) ? $preview : null;
            } else {
                $result = $update;
            }
        } else {
            $result = new Exception("Error in archiving generation's files type from page !");
        }

        return $result;
    }

    /**
     * @param string $pageOptionId [description]
     * @param int $generationType [description]
     *
     * @return bool [description]
     */
    private function archivePageGenerationType(string $pageOptionId, int $generationType, ?int $pageDuplicateId): bool
    {
        $generationFileDatas = $this->generationFileDataRepository->findByPageOptionsAndType($pageOptionId, $generationType, $pageDuplicateId);

        if (!empty($generationFileDatas)) {
            $result = $this->generationFileDataRepository->archive($generationFileDatas);
        } else {
            $result = true;
        }

        return $result;
    }

    /**
     * @param array $data [description]
     * @param string $comparaisonKey [description]
     *
     * @return array [description]
     */
    public function reorderFilesByName(array $data, string $comparaisonKey): array
    {
        usort($data, function ($a, $b) use ($comparaisonKey) {
            return $a[$comparaisonKey] <=> $b[$comparaisonKey];
        });

        return $data;
    }

    /**
     * {@inheritDoc}
     */
    public function addPageDuplicate(array $views): array
    {
        $versionId = reset($views)->version;
        $versionRepository = $this->entityManager->getRepository(VersionExport::class);
        $version = $versionRepository->findOneBy([
            "id" => $versionId
        ]);

        if ($version) {
            $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);
            $duplis = $dupliRepo->findBy([
                "version" => $version,
                "deletedAt" => null
            ]);

            $folio = count($duplis);

            $pageDuplicateEntities = [];
            $stories = [];
            $context = 'duplicate page';

            foreach ($views as $view) {
                $pageId = $view->idPage;
                $page = $this->pageCdfRepository->read($pageId);

                if ($page) {
                    $pageDupli = new PageDuplicate();
                    $pageDupli->setName($view->name);
                    $pageDupli->setPage($page);
                    $pageDupli->setIdProducts($view->elements);
                    $pageDupli->setVersion($version);
                    $pageDupli->setFolio(++$folio);

                    $this->entityManager->persist($pageDupli);

                    if ($pageDupli->getPage()->getOption()->getTemplate()) { // Do no take page with no template
                        $pageDuplicateEntities[] = $pageDupli;
                    }

                    $storyPage[] = new StoryPageView(
                        $pageDupli->getIdProducts(),
                        $pageDupli->getFolio()
                    );

                    $pageOption = $page->getOption();

                    $storyPageDupli = new StoryPageDupliView(
                        $view->name,
                        $page->getId(),
                        $view->nbPages,
                        $view->nbProducts,
                        $pageOption->getTemplate() ? $pageOption->getTemplate()->getId() : null,
                        $view->version,
                        [$storyPage]
                    );

                    $stories[] = ['id' => $page->getId(), 'value' => $storyPageDupli];
                } else {
                    throw new NotFoundMaestroException("No page found for id '$pageId' !");
                }
            }

            $this->entityManager->flush();

            $this->story->execute($context, $stories, $page->getId(), get_class($page), 0);

            return $pageDuplicateEntities;
        } else {
            throw new NotFoundMaestroException("No version found for id '$versionId' !");
        }
    }

    /**
     * @param int $idDuplicate [description]
     * @param string $idProducts [description]
     * @param string $name [description]
     */
    public function updatePageDuplicate(int $idDuplicate, string $idProducts, ?string $name)
    {
        try {

            $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);

            $pageDupli = $dupliRepo->findOneBy([
                "id" => $idDuplicate
            ]);

            if (!empty($pageDupli)) {
                $pageDupli->setName($name);
                $pageDupli->setIdProducts($idProducts);

                $this->entityManager->persist($pageDupli);
                $this->entityManager->flush();
            }

            return true;
        } catch (Exception $e) {
            return false;
        }
    }

    public function listPageDuplicate(int $idPage, ?int $version)
    {
        try {
            $result = [];

            $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);

            $duplis = $dupliRepo->findBy([
                "page" => $idPage,
                "version" => $version
            ]);

            if (!empty($duplis)) {
                foreach ($duplis as $dupli) {
                    $products = json_decode($dupli->getIdProducts(), true);
                    $result[] = [
                        "id" => $dupli->getId(),
                        "idProducts" => $products
                    ];
                }
            }

            return $result;
        } catch (Exception $e) {
            return $e;
        }
    }

    public function deleteDuplicate(int $idDuplicate)
    {
        try {
            $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);

            $pageDuplicate = $dupliRepo->findOneBy(["id" => $idDuplicate]);

            if (!empty($pageDuplicate)) {
                $this->entityManager->remove($pageDuplicate);
                $this->entityManager->flush();
            }

            return true;
        } catch (Exception $e) {
            return false;
        }
    }

    public function downloadLastXml(int $pageId, ?int $pageDuplicateId)
    {
        $page = $this->pageCdfRepository->read($pageId);

        $xmlPathId = "";
        if ($page) {

            $page->getCdf()->getExport()->getProject();

            $xmlPathId = $page->getCdf()->getExport()->getProject()->getId() . '_' . $page->getCdf()->getExport()->getId() . '_' . $pageId . '_'; // ProjectID_ExportID_PageID_Folio_Time
            $xmlPathId .= $page->getCdf()->getExport()->getExportType() == 2 ? $page->getFolio() : 992;
            if ($pageDuplicateId) {
                $dupliRepo = $this->entityManager->getRepository(PageDuplicate::class);
                $pageDupli = $dupliRepo->findOneBy([
                    "id" => $pageDuplicateId
                ]);

                $xmlPathId .= '_' . $pageDupli->getVersion()->getId() . '_' . $pageDuplicateId;
            }

            $xmlPathId = $this->params->get('arborescence_base') . DIRECTORY_SEPARATOR . $this->params->get('arborescence_generation_xml') . DIRECTORY_SEPARATOR . $xmlPathId . ".xml";

            try {
                $stream = [
                    "name" => !empty($page->getOption()->getName()) ? $page->getOption()->getName() . ".xml" : $xmlPathId,
                    "content" => base64_encode(file_get_contents($xmlPathId))
                ];
            } catch (\Exception $e) {
                $stream = $e;
            }
        }

        return $stream;
    }

    /**
     * {@inheritDoc}
     */
    public function autoAssignPhotoPositions(array $elements, int $exportId, array $templateMediasForElement, int $pageId, ?int $versionExport = null, ?int $pageDuplicateId = null): void
    {
        $elementsIds = array_map(function ($element) {
            return $element['id'];
        }, $elements);

        $elementsMedias = $this->mediaCollect->getByElementIds($elementsIds);

        $views = [];

        foreach ($elementsMedias as $elementMedias) {
            $elementMediasImageOnly = array_values(array_filter($elementMedias, function ($m) {
                return $m["type"] === "image";
            }));

            for ($i = 0; $i < count($templateMediasForElement); $i++) {
                if (isset($elementMediasImageOnly[$i])) {
                    if (array_key_exists('id', $elementMediasImageOnly[$i])) {
                        if (isset($elementMediasImageOnly[$i]['idElement'])) {
                            if (isset($elementMediasImageOnly[$i]['thumb'])) {
                                if (isset($elementMediasImageOnly[$i]['thumbPath'])) {
                                    if (isset($elementMediasImageOnly[$i]['copyright'])) {
                                        if (isset($elementMediasImageOnly[$i]['legend'])) {
                                            if (isset($elementMediasImageOnly[$i]['dateValid'])) {
                                                if ((-1 === (int) $elementMediasImageOnly[$i]['id'] || null === $elementMediasImageOnly[$i]['id']) && isset($elementMediasImageOnly[$i]['link']) && $elementMediasImageOnly[$i]['link']) {
                                                    $linkData = [
                                                        "type" => isset($elementMediasImageOnly[$i]['type']) ? $elementMediasImageOnly[$i]['type'] : "",
                                                        "link" => isset($elementMediasImageOnly[$i]['link']) ? $elementMediasImageOnly[$i]['link'] : "",
                                                        "loadMetadata" => isset($elementMediasImageOnly[$i]['loadMetadata']) ? $elementMediasImageOnly[$i]['loadMetadata'] : false
                                                    ];
                                                } else {
                                                    $linkData = null;
                                                }

                                                $view = new UpdateView(
                                                    null, // Project's ElementMedia
                                                    isset($elementMediasImageOnly[$i]['id']) ? $elementMediasImageOnly[$i]['id'] : -1, // DAM media's id (can be null transformed ino -1 if external link)
                                                    $exportId,
                                                    0,
                                                    0,
                                                    0,
                                                    0,
                                                    0,
                                                    $elementMediasImageOnly[$i]['idElement'], // PIM element's id
                                                    $i, // Media's position
                                                    $pageId,
                                                    false,
                                                    false,
                                                    $elementMediasImageOnly[$i]['thumb'],
                                                    $elementMediasImageOnly[$i]['thumbPath'],
                                                    isset($templateMediasForElement[$i]) && $templateMediasForElement[$i]->getVariableProject() ? $templateMediasForElement[$i]->getVariableProject()->getId() : null,
                                                    $versionExport,
                                                    $elementMediasImageOnly[$i]['copyright'],
                                                    $elementMediasImageOnly[$i]['legend'],
                                                    $elementMediasImageOnly[$i]['dateValid'],
                                                    $pageDuplicateId,
                                                    $linkData
                                                );

                                                $views[] = $view;
                                            } else {
                                                throw new UnprocessableEntityMaestroException("Missing 'dateValid' parameter !");
                                            }
                                        } else {
                                            throw new UnprocessableEntityMaestroException("Missing 'legend' parameter !");
                                        }
                                    } else {
                                        throw new UnprocessableEntityMaestroException("Missing 'copyright' parameter !");
                                    }
                                } else {
                                    throw new UnprocessableEntityMaestroException("Missing 'thumbPath' parameter !");
                                }
                            } else {
                                throw new UnprocessableEntityMaestroException("Missing 'thumb' parameter !");
                            }
                        } else {
                            throw new UnprocessableEntityMaestroException("Missing 'idElement' parameter !");
                        }
                    } else {
                        throw new UnprocessableEntityMaestroException("Missing 'id' parameter !");
                    }
                }
            }
        }

        if (!empty($views)) {
            $this->elementMediaUpdateQuery->update($views);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function generatePages(array $pageOptionsId, array $pageDuplicatesId, string $token): string
    {
        $application = new Application($this->kernel);
        $application->setAutoExit(false);

        $input = new ArrayInput([
            'command' => 'generation:auto',
            'page_options' => implode(";", $pageOptionsId),
            'page_duplicates' => implode(";", $pageDuplicatesId),
            'token' => $token
        ]);

        $output = new BufferedOutput();
        $application->run($input, $output);

        return $output->fetch();
    }
}