<?php

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

namespace App\Application\Query\Cdf;

use App\Application\Adapter\Query\Cdf\CdfQueryInterface;
use App\Application\Adapter\Query\Template\TemplateQueryInterface;
use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\View\Page\PageListView;
use App\Domain\Adapter\CdfRepositoryInterface;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Adapter\WorkflowProjectRepositoryInterface;
use App\Domain\Entity\Cdf;
use App\Infrastructure\Adapter\Provider\Template\ListTemplateInterface;
use Exception;
use App\Application\Adapter\FolioInterface;
use App\Application\Adapter\Query\Page\PageAutoGenerationQueryInterface;
use App\Application\Exception\SubException\InternalServerErrorMaestroException;
use App\Application\View\Common\CommonIdView;
use App\Application\View\Page\PageCreateView;
use App\Application\View\Template\TemplatesCdfView;
use App\Domain\Adapter\ExportsRepositoryInterface;
use App\Domain\Adapter\GenerationFileDataRepositoryInterface;
use App\Domain\Adapter\PageOptionsRepositoryInterface;
use App\Domain\Adapter\Workflow\ConfigurationRepositoryInterface;
use App\Domain\Adapter\Workflow\PlacesRepositoryInterface;
use App\Domain\Entity\Exports;
use App\Domain\Entity\Page;
use App\Domain\Entity\PageDuplicate;
use Doctrine\ORM\EntityManagerInterface;

/**
 * [description].
 */
class CdfQuery implements CdfQueryInterface
{
    /** @var CdfRepositoryInterface */
    private $cdfRepository;

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

    /** @var WorkflowProjectRepositoryInterface */
    private $workflowRepository;

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

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

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

    /** @var PageQueryInterface */
    private $pageQuery;

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

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

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

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

    /** @var ExportRepositoryInterface */
    private $exportRepo;

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

    private $exportRepository;

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

    public function __construct(
        CdfRepositoryInterface $cdfRepository,
        PageRepositoryInterface $pageCdfRepository,
        WorkflowProjectRepositoryInterface $workflowRepository,
        ConfigurationRepositoryInterface $configRepository,
        PlacesRepositoryInterface $placesRepository,
        TemplateQueryInterface $templateQuery,
        PageQueryInterface $pageQuery,
        ListTemplateInterface $template,
        FolioInterface $folioService,
        EntityManagerInterface $entityManager,
        GenerationFileDataRepositoryInterface $generationFileDataRepository,
        ExportsRepositoryInterface $exportRepo,
        PageOptionsRepositoryInterface $pageOptionRepository,
        PageAutoGenerationQueryInterface $pageAutoGenerationQuery
    ) {
        $this->cdfRepository = $cdfRepository;
        $this->pageCdfRepository = $pageCdfRepository;
        $this->workflowRepository = $workflowRepository;
        $this->configRepository = $configRepository;
        $this->placesRepository = $placesRepository;
        $this->templateQuery = $templateQuery;
        $this->pageQuery = $pageQuery;
        $this->template = $template;
        $this->folioService = $folioService;
        $this->entityManager = $entityManager;
        $this->exportRepository = $entityManager->getRepository(Exports::class);
        $this->generationFileDataRepository = $generationFileDataRepository;
        $this->exportRepo = $exportRepo;
        $this->pageOptionRepository = $pageOptionRepository;
        $this->pageAutoGenerationQuery = $pageAutoGenerationQuery;
    }

    /**
     * @param int $idCdf
     *
     * @return array
     */
    public function getCdfPages(int $idCdf)
    {
        $arrayRet = [];

        $pages = $this->pageCdfRepository->getByCdfOrderByFolio($idCdf);

        $arrayIdTemplates = [];
        $listTemplate = [];

        foreach ($pages as $page) {
            $previews = $this->getPreviews($page);

            $pageOptionTemplateId = null;
            if (!empty($page->getOption()->getTemplate())) {

                $pageOptionTemplateId = $page->getOption()->getTemplate()->getId();

                if ($pageOptionTemplateId) {
                    $arrayIdTemplates[$pageOptionTemplateId] = $pageOptionTemplateId;
                }
            }

            if (!empty($arrayIdTemplates)) {
                $templateIdView = new TemplatesCdfView($arrayIdTemplates);
                $listTemplate = $this->templateQuery->pageNameCdf($templateIdView);
                // $listTemplate = $this->template->name(array_values($arrayIdTemplates));
            }

            $products = [];
            $stringProduct = $page->getIdProducts();
            $arrayProducts = json_decode($stringProduct, true);

            foreach ($arrayProducts as $idProduct) {
                $products[$idProduct['name']] = ['id' => $idProduct['id'], 'name' => $idProduct['name']];
            }


            $template = '';

            if (isset($pageOptionTemplateId) && !empty($pageOptionTemplateId) && !empty($listTemplate) && isset($listTemplate[$pageOptionTemplateId])) {
                $template = $listTemplate[$pageOptionTemplateId]->text; // CommonTextView attribute
            }

            $status = $page->getCurrentPlace();
            $color = '';

            if ($status) {
                $color = $this->workflowRepository->getColor($status);
            }

            $products = array_values($products);

            $nbPage = 0 == $page->getOption()->getNbPages() ? 1 : $page->getOption()->getNbPages(); // Avoid to ommit pages when nb page set to 0

            for ($i = 0; $i < $nbPage; $i++) { // Duplicate page when number page > 1 to display in front
                $arrayToAdd = [
                    'id' => $page->getId(),
                    'name' => $page->getOption()->getName(),
                    'status' => $color ? $color['color'] : '',
                    'option' => $page->getOption()->getId(),
                    'nbProducts' => $page->getOption()->getNbProducts(),
                    'nbPages' => $page->getOption()->getNbPages(),
                    'products' => $products,
                    'template' => $template,
                    'folio' => $i > 0 ? $page->getFolio() + $i : $page->getFolio(), // Get the right folio of non-existent page
                    'exist' =>  $i > 0 ? false : true, // Used to let front manage page display if exist in database or not 
                    'index' => $i, // Used to find the right page with id and index in order to set the right preview,
                    'previews' => $previews,
                    'templateId' => $pageOptionTemplateId,
                    'isImport' => $page->getOption()->getImport(),
                    'cover' => $page->getOption()->getCover()
                ];

                if ($page->getOption()->getCover()) {
                    $arrayRet["covers"][] = $arrayToAdd;
                } else {
                    $arrayRet["pages"][] = $arrayToAdd;
                }
            }
        }


        return $arrayRet;
    }
    /**
     * @param int $idCdf
     * @param int $version
     *
     * @return array|Exception [description]
     */
    public function getCdfPagesDuplicate(int $idCdf, int $version)
    {
        $arrayRet = [];

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

        $duplis = $pageDupliRepository->findBy([
            'version' => $version,
            'deletedAt' => null
        ]);

        $arrayIdTemplates = [];
        $listTemplate = [];

        foreach ($duplis as $dupli) {
            $previews = $this->getPreviews($dupli);

            $page = $dupli->getPage();
            $pageOptionTemplateId = null;
            if (!empty($page->getOption()->getTemplate())) {

                $pageOptionTemplateId = $page->getOption()->getTemplate()->getId();

                if ($pageOptionTemplateId) {
                    $arrayIdTemplates[$pageOptionTemplateId] = $pageOptionTemplateId;
                }
            }

            if (!empty($arrayIdTemplates)) {
                $templateIdView = new TemplatesCdfView($arrayIdTemplates);
                $listTemplate = $this->templateQuery->pageNameCdf($templateIdView);
            }

            $products = [];
            $stringProduct = $dupli->getIdProducts();
            $arrayProducts = json_decode($stringProduct, true);

            foreach ($arrayProducts as $idProduct) {
                $products[$idProduct['name']] = ['id' => $idProduct['id'], 'name' => $idProduct['name']];
            }


            $template = '';
            if (isset($pageOptionTemplateId) && !empty($pageOptionTemplateId) && !empty($listTemplate) && isset($listTemplate[$pageOptionTemplateId])) {
                $template = $listTemplate[$pageOptionTemplateId]->text; // CommonTextView attribute
            }

            $status = $dupli->getCurrentPlace();
            $color = '';

            if ($status) {
                $color = $this->workflowRepository->getColor($status);
            }

            ksort($products);

            $products = array_values($products);

            for ($i = 0; $i < $page->getOption()->getNbPages(); $i++) { // Duplicate page when number page > 1 to display in front
                $arrayToAdd = [
                    'id' => $page->getId(),
                    'name' => !empty($dupli->getName()) ? $dupli->getName() : $page->getOption()->getName(),
                    'status' => $color ? $color['color'] : '',
                    'option' => $page->getOption()->getId(),
                    'nbProducts' => $page->getOption()->getNbProducts(),
                    'nbPages' => $page->getOption()->getNbPages(),
                    'products' => $products,
                    'template' => $template,
                    'folio' => $i > 0 ? $dupli->getFolio() + $i : $dupli->getFolio(), // Get the right folio of non-existent page
                    'exist' =>  $i > 0 ? false : true, // Used to let front manage page display if exist in database or not 
                    'index' => $i, // Used to find the right page with id and index in order to set the right preview,
                    'pageDuplicateId' => $dupli->getId(),
                    'previews' => $previews,
                    'templateId' => $pageOptionTemplateId
                ];

                if ($page->getOption()->getCover()) {
                    $arrayRet["covers"][$dupli->getFolio() + $i] = $arrayToAdd;
                } else {
                    $arrayRet["pages"][$dupli->getFolio() + $i] = $arrayToAdd;
                }
            }
        }
        if (isset($arrayRet["covers"])) {
            ksort($arrayRet["covers"]);
            $arrayRet["covers"] = array_values($arrayRet["covers"]);
        }

        if (isset($arrayRet["pages"])) {
            ksort($arrayRet["pages"]);
            $arrayRet["pages"] = array_values($arrayRet["pages"]);
        }

        return $arrayRet;
    }

    /**
     * @param Page|PageDuplicate $pageEntity
     * 
     * @return array
     */
    private function getPreviews($pageEntity): array
    {
        $previews = [];

        if (null === $pageEntity->getDeletedAt()) {
            if ($pageEntity instanceof Page) {
                $pageOption = $pageEntity->getOption();
                $idOption = $pageOption->getId();
                $idDuplicate = null;
            } else if ($pageEntity instanceof PageDuplicate) {
                $page = $pageEntity->getPage();
                $pageOption = $page->getOption();
                $idOption = $pageOption->getId();
                $idDuplicate = $pageEntity->getId();
            } else {
                throw new InternalServerErrorMaestroException("Unexpected entity received !");
            }

            $previewData = $this->generationFileDataRepository->findPreview($idOption, 0, 'jpg', $idDuplicate);

            foreach ($previewData as $file) {
                if (!is_string($file->getGenerationFile()->getFile())) {
                    $previews[] = base64_encode(stream_get_contents($file->getGenerationFile()->getFile()));
                } else {
                    $previews[] = base64_encode($file->getGenerationFile()->getFile());
                }
            }
        }

        return $previews;
    }

    /**
     * @param int $idCdf
     *
     * @return array
     */
    public function getCdfProducts(int $idCdf): array
    {
        $pages = $this->pageCdfRepository->getByCdfOrderByFolio($idCdf);
        $arrayRet = [];

        if (!empty($pages)) {
            $pagePlace = reset($pages)->getCurrentPlace();
            $places = [];
            if (isset($pagePlace)) {
                $configurationId = $this->configRepository->findIdByPlace($pagePlace);
                if (isset($configurationId) && isset($configurationId['id'])) {
                    $places = $this->placesRepository->findByConfigId($configurationId['id']);
                }
            }

            foreach ($pages as $page) {
                if ($page->getIdProducts()) {
                    $products = json_decode($page->getIdProducts());


                    if (!empty($products)) {
                        $workflow = '';
                        if ($page->getCurrentPlace()) {
                            $placeFilter = array_filter($places, function ($plc) use ($page) {
                                return $plc->getKey() == $page->getCurrentPlace();
                            });
                            if (!empty($placeFilter)) {
                                $workflow = reset($placeFilter)->getName();
                            }
                        }

                        foreach ($products as $product) {
                            $pageView = new PageListView(
                                $page->getId(),
                                $page->getOption()->getName(),
                                $workflow,
                                $page->getFolio(),
                                $page->getOption()->getTemplate() ? $page->getOption()->getTemplate()->getId() : null
                            );

                            $arrayRet[$product->name]['name'] = $product->name;
                            $arrayRet[$product->name]['page'][] = $pageView;
                        }
                    }
                }
            }

            ksort($arrayRet);

            $arrayRet = array_values($arrayRet);
        }

        return $arrayRet;
    }

    /**
     * @param int $idExport   [description]
     * @param int $nbPages    [description]
     * @param int $nbProducts [description]
     *
     * @return int|Exception [description]
     */
    public function createCdf(int $idExport, int $nbPages, int $nbProducts)
    {
        $cdf = new Cdf();
        $cdf->setNbPage($nbPages);

        $export = $this->exportRepository->findOneBy(["id" => $idExport]);
        if (!empty($export)) {
            $cdf->setExport($export);
        }

        $saved = $this->cdfRepository->save($cdf);

        if (!$saved instanceof Exception) {
            $result = $cdf->getId();
            // if ($export->getExportType() == $this->exportRepo::EXPORT_CDF) {
            //     $this->createCoverCdf($cdf->getId());
            // }
        } else {
            $result = $saved;
        }

        return $result;
    }

    /**
     * @param int $idExport [description]
     *
     * @return array [description]
     */
    public function getCdf(int $idExport): array
    {
        $cdf = $this->cdfRepository->getCdfByIdExport($idExport);
        if ($cdf) {
            return ['id' => $cdf->getId()];
        }

        return ['id' => null];
    }

    /**
     * @param CommonIdView $view
     * @param array $uniqueOrderedCdfPages
     *
     * @return bool|Exception 
     */
    public function updateCdfFolios(CommonIdView $view, array $uniqueOrderedCdfPages)
    {
        $pages = $this->pageCdfRepository->getByCdfOrderByFolio($view->id);

        $pagesToSave = $this->folioService->updateCdfFolios($uniqueOrderedCdfPages, $pages);

        if (!empty($pagesToSave)) {
            $result = $this->pageCdfRepository->saveMultiple($pagesToSave);

            if (!$result instanceof Exception) {
                $pageToGenerate = [];
                foreach ($result as $page) {
                    $pageToGenerate[] = ["id" => $page->getId()];
                }

                if (!empty($pageToGenerate)) {
                    $this->pageAutoGenerationQuery->addPageToGenerate($pageToGenerate);
                }
                $result = true;
            }
        } else {
            $result = new Exception("Nothing to modify !");
        }

        return $result;
    }

    /**
     * @param CommonIdView $view
     * @param array $uniqueOrderedCdfPages
     *
     * @return bool|Exception 
     */
    public function updateCdfVersionFolios(CommonIdView $view, array $uniqueOrderedCdfPages)
    {
        $pageDupliRepository = $this->entityManager->getRepository(PageDuplicate::class);

        $dupliPages = $pageDupliRepository->findBy([
            'id' => $uniqueOrderedCdfPages,
        ]);

        if (!empty($dupliPages)) {
            $sortPages = $this->sortPagesById($dupliPages, $uniqueOrderedCdfPages);
            $nbPages = 0;
            for ($i = 0; $i < count($sortPages); $i++) {
                $pos = $i + 1 + $nbPages;
                $sortPages[$i]->setFolio($pos);
                $nbPages = $sortPages[$i]->getPage()->getOption()->getNbPages() - 1;
                $this->entityManager->persist($sortPages[$i]);
            }

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

        return true;
    }

    private function sortPagesById($pages, $ids)
    {
        $result = [];
        foreach ($pages as $page) {
            $pos = array_search($page->getId(), $ids);
            $result[$pos] = $page;
        }

        return $result;
    }

    /**
     * @param CommonIdView $view
     * @param int $maxPage
     *
     * @return bool|Exception   
     */
    public function updateMaxPage(int $id, int $maxPage)
    {
        $cdf = $this->cdfRepository->read($id);

        if ($cdf) {
            $cdf->setNbPage($maxPage);
            $saved = $this->cdfRepository->save($cdf);

            if (!$saved instanceof Exception) {
                $result = $saved->getId();
            } else {
                $result = $saved;
            }
        } else {
            $result = new Exception("No flatplan found for id : " . $id);
        }

        return $result;
    }

    /**
     * @param array $exportIds
     * 
     * @return bool
     */
    public function deleteByExportIds(array $exportIds): bool
    {
        $result = true;

        if (!empty($exportIds)) {
            $flatplans = $this->cdfRepository->getCdfByExportIds($exportIds/*implode(",", $exportIds)*/);

            $result = $this->cdfRepository->deleteMultiple($flatplans);
        }

        return $result;
    }

    public function reInitCoverCdf($exportId): bool
    {


        $pageOptions = $this->pageOptionRepository->findCoverByExport($exportId);
        if (!empty($pageOptions)) {
            foreach ($pageOptions as $pageOption) {
                $this->entityManager->remove($pageOption);
            }
            $this->entityManager->flush();
        }

        $cdf = $this->cdfRepository->getCdfByIdExport($exportId);

        $this->createCoverCdf($cdf->getId());

        return true;
    }

    /**
     * @param int $cdfId
     * 
     * @return bool
     */
    private function createCoverCdf(int $cdfId)
    {
        for ($i = 1; $i <= 4; $i++) {
            $view = new PageCreateView(
                $cdfId,
                1,
                0,
                "Cover " . $i,
                null,
                '[]',
                0
            );

            $this->pageQuery->addPage([$view], null, true, $i);
        }

        $pages = $this->pageCdfRepository->getByCdfOrderByFolio($cdfId);

        if (!empty($pages)) {
            $folio = 5;
            $pageToSave = [];
            foreach ($pages as $page) {
                if (!$page->getOption()->getCover()) {
                    $page->setFolio($folio);
                    $pageToSave[] = $page;
                    $folio = $folio + $page->getOption()->getNbPages();
                }
            }
            if (!empty($pageToSave)) {
                $this->pageCdfRepository->saveMultiple($pageToSave);
            }
        }
    }
}