<?php

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

namespace App\IU\Controller\Generation;

use App\Application\Adapter\Query\Element\ElementGabValueQueryInterface;
use App\Application\Adapter\Query\Export\ExportsQueryInterface;
use App\Application\Adapter\Query\Template\ReadQueryInterface;
use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\Adapter\Query\Page\PageOptionsQueryInterface;
use App\Application\Adapter\RespondInterface;
use App\Application\Exception\SubException\InternalServerErrorMaestroException;
use App\Application\Exception\SubException\UnhautorizedMaestroException;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Application\Services\Log\LogService;
use App\Application\View\Common\CommonIdView;
use App\Application\View\Common\CommonResponseView;
use App\Application\View\Page\PageElementsView;
use App\Application\View\Page\PageGenerateView;
use App\Application\View\Page\PreviewView;
use App\Application\View\Page\PageDataGenerateView;
use Exception;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;
use App\Infrastructure\Adapter\Provider\Media\MediaCollectInterface;
use App\Application\Adapter\GenerationInterface;
use App\Application\Message\GenerationExecuteMessage;
use App\Application\Message\GenerationNotificationMessage;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Messenger\Transport\AmqpExt\AmqpStamp;
use App\Application\Adapter\Query\Profile\ProfileQueryInterface;
use App\Application\Adapter\TemplateTwigExtensionInterface;
use App\Domain\Adapter\PageAutoGeneRepositoryInterface;
use DateTime;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

/**
 * @Route("/generate",
 *     name="generate",
 *     methods="POST",
 * )
 */
final class SendAction
{
    /** @var GenerationInterface */
    private GenerationInterface $generationService;

    /**
     * @throws UnprocessableEntityMaestroException
     * @throws InternalServerErrorMaestroException
     * @throws UnhautorizedMaestroException
     */
    public function __invoke(
        Request $request,
        RespondInterface $respond,
        ExportsQueryInterface $exportQuery,
        ReadQueryInterface $templateReadQuery,
        PageQueryInterface $pageQuery,
        PageOptionsQueryInterface $pageOptionQuery,
        ElementGabValueQueryInterface $elementGabValueQuery,
        MediaCollectInterface $mediaCollect,
        GenerationInterface $generation,
        MessageBusInterface $messageBus,
        ProfileQueryInterface $prof,
        ParameterBagInterface $parameterBag,
        LogService $logService,
        TemplateTwigExtensionInterface $templateTwigExtension,
        PageAutoGeneRepositoryInterface $pageAutoGeneRepository
    ) {
        $this->generationService = $generation;

        $logService->setLog('SendAction : Entry-point.');

        $token = $request->headers->get('x-auth-token');

        if ($token) {
            if ($parameterBag->get('spooler_generation_enabled')) {
                $userId = $prof->getUserIdFromToken($token);
                $data = json_decode($request->getContent(), true);
                $view = new CommonIdView($data['page']);
                $page = $pageQuery->read($view);
                $idProducts = $page->getIdProducts();

                if (isset($data['pageDuplicateId']) && $data['pageDuplicateId'] > 0) {
                    $pageDuplicate = $pageQuery->readDuplicate($data['pageDuplicateId']);
                    $idProducts = $pageDuplicate->getIdProducts();
                    $pageDuplicateId = (int) $data['pageDuplicateId'];
                } else {
                    $pageDuplicateId = null;
                }

                $logService->setLog('Request controlled.');

                $pageGenerate = new PageDataGenerateView(
                    $page->getId(),
                    $page->getFolio(),
                    $page->getCdf()->getExport()->getId(),
                    (int) $page->getOption()->getNbPages(),
                    (int) $page->getOption()->getNbProducts(),
                    (int) $page->getOption()->getTemplate()->getId(),
                    json_decode($idProducts, true),
                    $data['generationType'] ?? 0,
                    $pageDuplicateId
                );

                $pageElementsView = new PageElementsView(
                    $pageGenerate->id,
                    $pageGenerate->products,
                    $pageGenerate->export,
                    $pageGenerate->pageDuplicateId > 0 ? $pageGenerate->pageDuplicateId : null
                );

                $logService->setLog('Start ElementGabValue.');

                // TODO : Find a better way to get element_gab_values data like rather than call query
                $elementsGabValues = $elementGabValueQuery->getElementsGabValues($pageElementsView);
                $logService->setLog('End ElementGabValue.');

                if (!empty($elementsGabValues)) {
                    $optionGabValues = $elementGabValueQuery->getOptionGabValue($pageGenerate);

                    $exportView = new CommonIdView(
                        $pageGenerate->export
                    );

                    $export = $exportQuery->readEntity($exportView);

                    if ($export) {
                        $templateView = new CommonIdView(
                            $pageGenerate->template
                        );

                        $templateFiles = $templateReadQuery->getFiles($templateView, $export);

                        if (!$templateFiles instanceof Exception) {
                            $logService->setLog('Template files returned.');

                            $mediaIdsDam['medias'] = [];

                            if (!empty($templateFiles['pictoIds'])) {
                                $mediaIdsDam['medias'] = $templateFiles['pictoIds'];
                            }

                            $links = []; // Contains all media field links

                            foreach ($elementsGabValues as $element) {
                                $mediaFieldsId = $this->getMediasDataFromMediaFields($element->values);
                                $mediaFieldsLinks = $this->getMediasDataFromMediaFields($element->values, true);
                                $mediaElementLinks = $this->getMediasDataFromMediaElement($element->medias);

                                $mediaIdsDam['medias'] = [...$mediaIdsDam['medias'], ...$mediaFieldsId];
                                $links = [...$links, ...$mediaFieldsLinks, ...$mediaElementLinks];

                                if (!empty($element->medias)) {
                                    foreach ($element->medias as $media) {
                                        if (-1 !== $media->mediaId)
                                            $mediaIdsDam['medias'][] = $media->mediaId;
                                    }
                                }
                            }

                            $logService->setLog('Start get medias');

                            if (!empty($mediaIdsDam) && !empty($mediaIdsDam['medias'])) {
                                $mediaIdsDam['medias'] = array_unique($mediaIdsDam['medias']);
                                $mediasBd = (int) $pageGenerate->generationType === 0;
                                $mediasFiles = $mediaCollect->collectMediaByIds($mediaIdsDam, $mediasBd);
                            } else {
                                $mediasFiles = [];
                            }

                            $renamedMediasFiles = $generation->renameMediasFiles($mediasFiles);

                            $logService->setLog('End get medias');
                            $logService->setLog('Start get content');
                            $exportContent = $templateReadQuery->getContent($elementsGabValues, $templateView, $export, $pageGenerate, $renamedMediasFiles);

                            $logService->setLog('End get content');

                            if (!$exportContent instanceof Exception) {
                                $versionExport = isset($data['versionExport']) && $data['versionExport'] > 0 ? $data['versionExport'] : null;
                                $fileType = "";

                                if ($exportContent['contentType'] === 'xml') {
                                    if (!$templateTwigExtension->isHtml($exportContent['content'])) {
                                        $errors = $templateTwigExtension->validateContent($exportContent['content']);

                                        if (empty($errors)) {
                                            $pageData = new PageGenerateView(
                                                $pageGenerate->id,
                                                $export->getExportType() == 2 ? $pageGenerate->folio : 992,
                                                $export->getId(),
                                                $export->getName(),
                                                $pageGenerate->nbPage,
                                                $pageGenerate->nbProduct,
                                                $pageGenerate->template,
                                                $export->getProject()->getId(),
                                                $export->getProject()->getName(),
                                                $exportContent['content'],
                                                $renamedMediasFiles, // @TODO: Must contains links OR ADD NEW ATTRIBUTE
                                                $templateFiles['templateFiles'],
                                                $pageGenerate->generationType,
                                                $exportContent['fontPath'],
                                                $elementsGabValues,
                                                $optionGabValues,
                                                $versionExport,
                                                isset($data['pageDuplicateId']) && $data['pageDuplicateId'] > 0 ? $data['pageDuplicateId'] : null,
                                                $links
                                            );

                                            $generated = $generation->generate($pageData);

                                            if (!$generated instanceof Exception) {
                                                $logService->setLog('XML generation data ready to dispatch.');

                                                try {
                                                    $generationNotification = new GenerationNotificationMessage($pageData->id, $generated['generationType'], $generated['inPath'], $generated['outPath'], (int) $userId, $pageData->project, $pageData->export, $pageDuplicateId, $versionExport, $generated["dirName"], $token);
                                                    $messageBus->dispatch(new GenerationExecuteMessage($generated['scriptArgs'], $generationNotification), [new AmqpStamp('execute_generation')]);

                                                    $fileType = "pdf";

                                                    unset($generated['scriptArgs']);
                                                } catch (Exception $e) {
                                                    throw new UnprocessableEntityMaestroException($e->getMessage());
                                                }
                                            } else {
                                                throw new UnprocessableEntityMaestroException($generated->getMessage());
                                            }
                                        } else {
                                            $errorList = $templateTwigExtension->getValidationErrorList($errors);

                                            throw new UnprocessableEntityMaestroException($errorList, 'twig', 'validateContent');
                                        }
                                    } else {
                                        throw new UnprocessableEntityMaestroException('(Found HTML instead of XML)', 'twig', 'validateStructure');
                                    }
                                } else {
                                    try {
                                        $exportContent = str_replace("&quot;", '"', $exportContent);

                                        $logService->setLog('Start HTML creation.');

                                        $generated = $generation->generateHTML($exportContent, $renamedMediasFiles, $pageGenerate->export, $pageGenerate->id, $pageGenerate->generationType, $templateFiles, $elementsGabValues);

                                        $logService->setLog('End HTML creation.');

                                        $generated["fileType"] = 'html';
                                        $generated["pageDuplicateId"] = $pageDuplicateId;

                                        $logService->setLog('Start HTML generation.');

                                        $pageQuery->generate($generated, $page);

                                        if (!empty($pageDuplicateId)) {
                                            $pageGene = $pageAutoGeneRepository->findByPageAndDuplicate($page->getId(), $pageDuplicateId);
                                        } else {
                                            $pageGene = $pageAutoGeneRepository->findOneByPageId($page->getId());
                                        }

                                        if (null !== $pageGene) {
                                            $pageGene->setDateGeneration(new DateTime());
                                            $pageAutoGeneRepository->save($pageGene);
                                        }

                                        $logService->setLog('End HTML generation.');

                                        $fileType = "html";
                                    } catch (Exception $e) {
                                        throw new UnprocessableEntityMaestroException($e->getMessage());
                                    }
                                }

                                $view = new PreviewView(
                                    $page->getOption()->getId(),
                                    $pageGenerate->generationType,
                                    $fileType,
                                    $pageDuplicateId
                                );

                                $logService->setLog('Start get preview.');

                                $preview = $pageOptionQuery->getPreview([$view])[$page->getOption()->getId()];

                                $logService->setLog('End get preview.');

                                $logService->setLog('End generation.');

                                return $respond->createBodyObject(new CommonResponseView($preview, 'generate', 'generation', 'success'))->respond();
                            } else {
                                throw new UnprocessableEntityMaestroException($exportContent->getMessage());
                            }
                        } else {
                            throw new UnprocessableEntityMaestroException($templateFiles->getMessage());
                        }
                    } else {
                        throw new UnprocessableEntityMaestroException("No export found for id : $exportView->id !");
                    }
                } else {
                    throw new UnprocessableEntityMaestroException('Empty elementsGabValues !');
                }
            } else {
                throw new InternalServerErrorMaestroException('Generation disabled !');
            }
        } else {
            throw new UnhautorizedMaestroException('No token provided !');
        }
    }

    /**
     * This function let to get media's ids or media's links
     * 
     * @param array $fields
     * @param bool $links
     * 
     * @return array
     */
    private function getMediasDataFromMediaFields(array $fields, bool $links = false): array
    {
        $data = [];

        $fieldsets = array_filter($fields, function ($field) {
            return $field->fieldType === "fieldset";
        });

        foreach ($fieldsets as $fieldset) {
            foreach ($fieldset->value as $collections) {
                $subData = $this->getMediasDataFromMediaFields($collections, $links);

                $data = [...$data, ...$subData];
            }
        }

        $mediaFields = array_filter($fields, function ($field) {
            return $field->fieldType === "media";
        });

        foreach ($mediaFields as $mediaField) {
            $medias = json_decode($mediaField->value, true);

            if (!empty($medias)) {
                $mediasWithTargetData = array_filter($medias, function ($media) use ($links) {
                    return $links ? $media["id"] === null : $media["id"] !== null;
                });

                $mediasData = array_map(function ($media) use ($links) {
                    if ($links && isset($media["loadMetadata"]) && true === $media["loadMetadata"]) {
                        $media = $this->generationService->getLinkMetadata($media);
                    }

                    return $links ? $media["link"] : $media['id'];
                }, $mediasWithTargetData);

                $data = [...$data, ...$mediasData];
            }
        }

        return $data;
    }

    /**
     * This function let to get element media's links (not media field)
     * 
     * @param array $medias
     * 
     * @return array
     */
    private function getMediasDataFromMediaElement(array $medias): array
    {
        $data = [];

        $medias = array_filter($medias, function ($media) {
            return $media->mediaId === -1;
        });

        foreach ($medias as $media) {
            if (isset($media->linkData) && isset($media->linkData["link"])) {
                if (isset($media->linkData["loadMetadata"]) && true === $media->linkData["loadMetadata"]) {
                    $media = $this->generationService->getLinkMetadata($media);
                }

                $data[] = $media->linkData["link"];
            }
        }

        return $data;
    }
}