<?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\PageOptionsQueryInterface;
use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\View\Common\CommonTextView;
use App\Application\View\PageOptions\PageOptionsReadView;
use App\Application\View\PageOptions\PageOptionsUpdateView;
use App\Application\View\Page\PreviewView;
use App\Domain\Adapter\PageOptionsRepositoryInterface;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Adapter\TemplateRepositoryInterface;
use App\Domain\Entity\PageOptions;
use App\Domain\Adapter\GenerationFileDataRepositoryInterface;
use App\Domain\Entity\GenerationFileData;
use App\Application\Adapter\Query\Template\TemplateQueryInterface;
use Exception;
use App\Application\Adapter\FolioInterface;
use App\Application\Adapter\GenerationInterface;
use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Application\View\Common\CommonArrayView;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Imagick;

class PageOptionsQuery implements PageOptionsQueryInterface
{
    /** @var PageOptionsRepositoryInterface */
    private $pageOptionsRepository;

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

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

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

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

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

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

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

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

    /** @var GenerationInterface */
    private $generationService;

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

    public function __construct(
        PageOptionsRepositoryInterface $pageOptionsRepository,
        TemplateQueryInterface $templateQuery,
        StoryQueryInterface $story,
        DataDiffInterface $dataDiff,
        GenerationFileDataRepositoryInterface $generationFileDataRepository,
        FolioInterface $folioService,
        PageRepositoryInterface $pageRepository,
        TemplateRepositoryInterface $templateRepository,
        ParameterBagInterface $params,
        GenerationInterface $generationService,
        PageQueryInterface $pageQuery
    ) {
        $this->pageOptionsRepository = $pageOptionsRepository;
        $this->templateQuery = $templateQuery;
        $this->story = $story;
        $this->dataDiff = $dataDiff;
        $this->generationFileDataRepository = $generationFileDataRepository;
        $this->folioService = $folioService;
        $this->pageRepository = $pageRepository;
        $this->templateRepository = $templateRepository;
        $this->params = $params;
        $this->generationService = $generationService;
        $this->pageQuery = $pageQuery;
    }

    /**
     * @param PageOptionsUpdateView $view
     *
     * @return bool|Exception
     */
    public function update(PageOptionsUpdateView $view)
    {
        $option = $this->pageOptionsRepository->read($view->id);

        if (!$option) {
            return new Exception("No page option found for id : $view->id !");
        }

        $result = false;
        $template = $this->templateRepository->findById($view->template);

        if (!empty($template)) {

            $option->setTemplate($template);

            $diff = $this->pageOptionsRepository->diff($option);

            $entity = $this->pageOptionsRepository->save($option);

            if ($entity instanceof Exception) {
                return $entity;
            }

            if (count($diff) > 0 && count($entity->getPages()) > 0) {
                $cdf = $entity->getPages()[0]->getCdf();
                $this->story->execute('update', ['pageOptionId' => $view->id, 'value' => $this->dataDiff->viewDiff($diff)], $cdf->getId(), get_class($cdf), 0);
            }

            $result = true;
        }

        return $result;
    }

    /**
     * @param int $pageId
     *
     * @return PageOptionsReadView|null
     */
    public function read(int $pageId): ?PageOptionsReadView
    {
        $result = null;

        $options = $this->pageOptionsRepository->findByPageId($pageId);

        if ($options) {
            $result = new PageOptionsReadView(
                $options->getId(),
                $options->getName(),
                $options->getNbProducts(),
                $options->getNbPages(),
                $options->getTemplate()->getId(),
                $options->getPages()->first()->getCdf()->getExport()->getId()
            );
        }

        return $result;
    }

    /**
     * @param string $id
     *
     * @return bool|Exception
     */
    public function delete(string $id)
    {
        $pageOptions = $this->pageOptionsRepository->read($id);

        if ($pageOptions) {
            $page = $pageOptions->getPages()->first();
            $pageId = $page->getId();
            $cdf = $page->getCdf();

            $result = $this->pageOptionsRepository->delete($pageOptions);

            if (true === $result) {
                $this->story->execute('delete', ['id' => $pageId], $pageId, get_class($page), 0); // Since PageOption's id is string we use associated Page data

                $pagesToSave = $this->folioService->updateFolios($pageOptions, $cdf, true);

                if (!empty($pagesToSave)) {
                    $updated = $this->pageRepository->saveMultiple($pagesToSave);

                    if ($updated instanceof Exception) {
                        $result = $updated;
                    }
                }
            }
        } else {
            $result = new Exception("No page option found for id : $id !");
        }

        return $result;
    }

    /**
     * @param CommonTextView $view
     *
     * @return PageOptions|null
     */
    public function getEntity(CommonTextView $view): ?PageOptions
    {
        $result = $this->pageOptionsRepository->findById($view->text);

        return $result;
    }

    /**
     * {@inheritDoc}
     */
    public function getPreview(array $views): array
    {
        $result = [];

        foreach ($views as $view) {
            if ($view->fileType === "html") {
                $preview = $this->generationFileDataRepository->findPreviewHTML($view->pageOptionId, $view->generationType, $view->fileType, $view->pageDuplicateId);
            } else {
                $preview = $this->generationFileDataRepository->findPreview($view->pageOptionId, $view->generationType, $view->fileType, $view->pageDuplicateId);
            }

            if (!empty($preview)) {
                $streams = [];

                foreach ($preview as $file) {
                    $streams[] = $this->getBase64($file);
                }

                $result[$view->pageOptionId] = $streams;
            } else {
                $version = isset($view->pageDuplicateId) ? "version $view->pageDuplicateId" : "no version";
                $result[$view->pageOptionId] = "No preview found for page $view->pageOptionId, generation type $view->generationType, file type $view->fileType and $version !";
            }
        }

        return $result;
    }

    /**
     * @param GenerationFileData $file
     *
     * @return string
     */
    private function getBase64(GenerationFileData $file): string
    {
        if (!is_string($file->getGenerationFile()->getFile())) {
            $result = base64_encode(stream_get_contents($file->getGenerationFile()->getFile()));
        } else {
            $result = base64_encode($file->getGenerationFile()->getFile());
        }
        if (str_contains($result, 'pdfbase64')) {
            $result = explode('pdfbase64', $result)[1];
        }

        return $result;
    }

    public function downloadGeneration(PageOptions $pageOption, ?int $pageDuplicateId, ?array $medias)
    {
        $result = [];
        $html = $this->generationFileDataRepository->findGenerateFileHTML($pageOption->getId(), $pageDuplicateId);

        if (!empty($html)) {
            $first = reset($html);

            $stream = $this->getBase64($first);

            $result[] = ["originalName" => $pageOption->getName() . '.' . $first->getExtension(), "file" => $stream, "extension" => $first->getExtension()];

            $template = $this->templateQuery->geTHTMLFile($pageOption->getTemplate()->getId());

            if (!empty($template) && isset($template['html']) && !empty($template['html'])) {
                foreach ($template['html'] as $fileHtml) {
                    $result[] = $fileHtml;
                }
            }

            $damUrl = $this->params->get('domain_dam');

            $medias = $this->generationService->renameMediasFiles($medias);

            foreach ($medias as $media) {
                if ($media['fileBdPath']) {
                    $fileStream = base64_encode(file_get_contents($damUrl . $media['fileBdPath']));
                    $result[] = ["originalName" => $media['originalName'], "file" => $fileStream];
                } else {
                    $result[] = ["originalName" => $media['originalName'], "file" => $media['fileBd']];
                }
            }
        } else {
            $result = "No generation found for page " . $pageOption->getName();
        }

        return $result;
    }

    public function importPDF(string $pageOptionId, array $files, $content, $pageDuplicateId)
    {
        $pageOption = $this->pageOptionsRepository->read($pageOptionId);

        $result = false;
        $arrayFiles = [];
        if (!empty($pageOption)) {

            foreach ($files as $file) {
                $arrayFiles['type'] = 0;
                $name = $file->getClientOriginalName();
                $extension = $file->guessExtension();

                $blobpdf = explode('data:application/pdf;base64,', $content)[1];
                $arrayFiles['files'][] = [
                    'name' => $name,
                    'extension' => $extension,
                    'content' => $blobpdf
                ];

                $nameWithoutExt = explode('.pdf', $name)[0];

                // instantiate Imagick
                $im = new Imagick();

                $im->readImageBlob(base64_decode($blobpdf));
                $im->setImageFormat('jpeg');
                $blobJpg = $im->getImageBlob();
                $arrayFiles['files'][] = [
                    'name' => $nameWithoutExt . '.jpg',
                    'extension' => 'jpg',
                    'content' => base64_encode($blobJpg)
                ];
                $im->clear();
                $im->destroy();
            }

            $arrayFiles['pageDuplicateId'] = $pageDuplicateId;

            $arrayFiles['files'] = $this->pageQuery->reorderFilesByName($arrayFiles['files'], 'name');

            $viewData = new CommonArrayView(
                $arrayFiles
            );

            $addGeneratedFile = $this->pageQuery->addGeneratedFiles($pageOption, $viewData, true);
            if (!$addGeneratedFile instanceof Exception) {

                $preview = $this->generationFileDataRepository->findPreview($pageOption->getId(), $arrayFiles['type'], "jpg", $pageDuplicateId);

                foreach ($preview as $file) {
                    $result[] = $this->getBase64($file);
                }
            }
        }

        return $result;
    }


    /**
     * {@inheritDoc}
     */
    public function downloadMultipleGeneration(string $object, array $ids, bool $archiveHd): array
    {
        if ("page" === $object) {
            $pageOptionIds = $ids;
        } else {
            $pageOptions = $this->pageOptionsRepository->findByObjectIds($object, $ids);
            $pageOptionIds = array_map(function ($pageOption) {
                return $pageOption->getId();
            }, $pageOptions);
        }

        if (!empty($pageOptionIds)) {
            $generationFileData = $this->generationFileDataRepository->findByPageOptionIdsAndGenerationType($pageOptionIds, intval($archiveHd));

            if (!empty($generationFileData)) {
                $data = ["totalFiles" => 0, "zipName" => "maestro-project-archive_" . time(), "files" => []];

                foreach ($generationFileData as $generationData) {
                    $stream = $this->getBase64($generationData);
                    $export = $generationData->getPageOptions()->getPages()->first()->getCdf()->getExport();
                    $project = $export->getProject();
                    $pageOptionName = (empty($generationData->getPageOptions()->getName()) ? $generationData->getPageOptions()->getId() : $generationData->getPageOptions()->getName());
                    $originalName = $pageOptionName . "-" . $generationData->getId() . '.' . $generationData->getExtension();
                    $exportName = empty($export->getName()) ? "Export-" . $export->getId() : $export->getName();
                    $projectName = empty($project->getName()) ? "Project-" . $project->getId() : $project->getName();
                    $folio = $generationData->getPageOptions()->getPages()->first()->getFolio();

                    $data["files"][$projectName][$exportName][$pageOptionName][] = [
                        "pageOptionName" =>  $folio . "-" . $pageOptionName,
                        "originalName" => $originalName,
                        "file" => $stream,
                        "extension" => $generationData->getExtension()
                    ];

                    $data["totalFiles"]++;
                }

                return $data;
            } else {
                throw new UnprocessableEntityMaestroException("No generation data available for selected items", "pageOption", "downloadMultipleGeneration");
            }
        } else {
            throw new UnprocessableEntityMaestroException("No generation data available, no selected items", "pageOption", "downloadMultipleGeneration");
        }
    }
}