<?php

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

namespace App\Application\Query\Template;

use App\Application\Adapter\Query\Template\ReadQueryInterface;
use App\Application\Adapter\Query\Template\TemplateQueryInterface;
use App\Application\Adapter\Query\Variable\VariableReadQueryInterface;
use App\Application\Adapter\TemplateTwigExtensionInterface;
use App\Application\Exception\SubException\NotFoundMaestroException;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Application\View\Common\CommonIdView;
use App\Application\View\Common\CommonTextView;
use App\Application\View\ElementType\ElementTypeTemplateView;
use App\Application\View\Fields\FieldNameView;
use App\Application\View\Fields\FieldTemplateFieldsetView;
use App\Application\View\Fields\FieldTemplateView;
use App\Application\View\Layout\LayoutView;
use App\Application\View\Generation\GenerationDataView;
use App\Application\View\Page\PageDataGenerateView;
use App\Domain\Adapter\ExportsRepositoryInterface;
use App\Domain\Adapter\LayoutRepositoryInterface;
use App\Domain\Adapter\ProjectRepositoryInterface;
use App\Domain\Adapter\VariableProjectRepositoryInterface;
use App\Domain\Entity\Exports;
use App\Infrastructure\Adapter\Provider\ElementType\ElementTypeCollectInterface;
use App\Infrastructure\Adapter\Provider\ElementType\FindFieldTypeInterface;
use Exception;

class ReadQuery implements ReadQueryInterface
{
    /** @var ExportsRepositoryInterface */
    private $exportsRepository;

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

    /** @var VariableReadQueryInterface */
    private $variableReadQuery;

    /** @var TemplateTwigExtensionInterface */
    private $templateTwigExtension;

    /** @var ProjectRepositoryInterface */
    private $projectRepository;

    /** @var LayoutRepositoryInterface */
    private $layoutRepository;

    /** @var ElementTypeCollectInterface */
    private $collectElementType;

    /** @var FindFieldTypeInterface */
    private $findFieldTypeProvider;

    /** @var VariableProjectRepositoryInterface */
    private $variableProjectRepository;

    public function __construct(
        ExportsRepositoryInterface $exportsRepository,
        TemplateQueryInterface $templateQuery,
        VariableReadQueryInterface $variableReadQuery,
        TemplateTwigExtensionInterface $templateTwigExtension,
        ProjectRepositoryInterface $projectRepository,
        LayoutRepositoryInterface $layoutRepository,
        ElementTypeCollectInterface $collectElementType,
        FindFieldTypeInterface $findFieldTypeProvider,
        VariableProjectRepositoryInterface $variableProjectRepository
    ) {
        $this->exportsRepository = $exportsRepository;
        $this->templateQuery = $templateQuery;
        $this->variableReadQuery = $variableReadQuery;
        $this->templateTwigExtension = $templateTwigExtension;
        $this->projectRepository = $projectRepository;
        $this->layoutRepository = $layoutRepository;
        $this->collectElementType = $collectElementType;
        $this->findFieldTypeProvider = $findFieldTypeProvider;
        $this->variableProjectRepository = $variableProjectRepository;
    }

    /**
     * @param int $id [description]
     *
     * @return array [description]
     */
    public function getElementFieldTemplate(int $id): ?array
    {
        // HELPER : TemplateView > ElementFieldsTemplatesView > ElementFieldTemplateView > FieldsetFieldIdView

        // TODO : get all project's element type in one request => get project
        // DEPRECATED : $elementType = $this->elementTypeRepository->findElementTypeByIdProject($elementTypeId, $idProject);

        $project = $this->projectRepository->findById($id);
        if (null === $project) {
            return null;
        }

        $elementTypesPim = $this->collectElementType->list();

        $elementTypesMap = array_map(function ($elementTypeProject) {
            return $elementTypeProject->getElementTypePIM()  != null ? $elementTypeProject->getElementTypePIM() : 0;
        }, $project->getElementTypes()->toArray());

        $fieldTypes = $this->findFieldTypeProvider->getFieldTypeByElementTypes(implode(',', $elementTypesMap));
        $fieldTypesByElementType = [];
        if (is_array($fieldTypes)) {
            foreach ($fieldTypes as $fieldType) {
                $fieldTypesByElementType[$fieldType['idElementType']][] = $fieldType;
            }
        }
        $elementTypes = [];

        $templateNoProduct = [];

        $elementFieldsTemplatesView = []; // ElementFieldsTemplatesView
        if (!empty($project->getElementTypes())) {
            $fields = [];
            $fieldsNoProduct = [];
            foreach ($project->getElementTypes() as $elementType) {
                if ($elementType->getDeletedAt() == null) {
                    // TODO : get field + fieldset field when retrieve field by element type
                    $elementFieldsTemplatesView = [];
                    if (!empty($elementType->getTemplates())) {
                        foreach ($elementType->getTemplates() as $template) {
                            if (!empty($template->getTemplates()) && $template->getDeletedAt() === NULL) {
                                foreach ($template->getTemplates() as $temp) {
                                    $elementFieldsTemplatesView[] = $temp['id'];
                                }
                            }
                        }
                    }
                    $templateFields = [];
                    if (!empty($elementFieldsTemplatesView)) {

                        $templateIdsView = new CommonTextView(
                            implode(',', $elementFieldsTemplatesView)
                        );
                        $listTemplates = $this->templateQuery->listByTemplateIds($templateIdsView);
                        $templateFields = $this->variableReadQuery->listByTwigsTemplates($listTemplates);
                    }
                    $layouts = $this->layoutRepository->findByElementTypeId($elementType->getId());
                    $fieldTypesPim = [];
                    if ($elementType->getElementTypePIM() && isset($fieldTypesByElementType[$elementType->getElementTypePIM()])) {
                        $fieldTypesPim = $fieldTypesByElementType[$elementType->getElementTypePIM()];
                    }

                    $templates = [];
                    if (is_object($templateFields) &&  isset($templateFields) && !empty($templateFields) && !empty($templateFields->templateVariables)) {


                        foreach ($templateFields->templateVariables as $template) {
                            if (!empty($template)) {
                                foreach ($template as $templateField) {
                                    if (!empty($templateField->variableProjectId)) {
                                        $linkedField = null;
                                        $name = $templateField->name;
                                        $editable = false;

                                        $inputs = [];
                                        if (isset($templateField->inputs)) {
                                            foreach ($templateField->inputs as $i => $iValue) {
                                                $linkedInput = null;
                                                $nameInput = $templateField->inputs[$i]->variableProjectName;
                                                $editableInput = false;


                                                $inputs[$templateField->inputs[$i]->variableProjectId] = new FieldTemplateView(
                                                    $templateField->inputs[$i]->variableProjectId, // $i,
                                                    $templateField->inputs[$i]->variableProjectName,
                                                    $linkedInput,
                                                    $nameInput,
                                                    $editableInput,
                                                    $templateField->inputs[$i]->fieldType
                                                );
                                            }
                                        }

                                        if (!empty($inputs)) {
                                            if ($templateField->forElement) {
                                                $fields[$templateField->variableProjectId] = new FieldTemplateFieldsetView(
                                                    $templateField->variableProjectId,
                                                    $templateField->variableProjectName,
                                                    $linkedField,
                                                    $inputs,
                                                    $name,
                                                    $editableInput,
                                                    $templateField->fieldType
                                                );
                                            } else {

                                                $fieldsNoProduct[$templateField->variableProjectId] = new FieldTemplateFieldsetView(
                                                    $templateField->variableProjectId,
                                                    $templateField->variableProjectName,
                                                    $linkedField,
                                                    $inputs,
                                                    $name,
                                                    $editableInput,
                                                    $templateField->fieldType

                                                );
                                            }
                                        } else {
                                            if ($templateField->forElement) {
                                                $fields[$templateField->variableProjectId] = new FieldTemplateView(
                                                    $templateField->variableProjectId,
                                                    $templateField->variableProjectName,
                                                    $linkedField,
                                                    $name,
                                                    $editable,
                                                    $templateField->fieldType
                                                );
                                            } else {

                                                $fieldsNoProduct[$templateField->variableProjectId] = new FieldTemplateView(
                                                    $templateField->variableProjectId,
                                                    $templateField->variableProjectName,
                                                    $linkedField,
                                                    $name,
                                                    $editable,
                                                    $templateField->fieldType
                                                );
                                            }
                                        }
                                    }
                                }

                                // if (!empty($fields)) {
                                //     $templates[] = new LayoutView(
                                //         reset($template)->templateId,
                                //         reset($template)->templateName,
                                //         $fields
                                //     );
                                // }
                                // if (!empty($fieldsNoProduct) && !$elementType->getElementTypePIM()) {
                                //     $find = false;
                                //     if (!empty($templateNoProduct)) {
                                //         $filter = array_filter($templateNoProduct, function ($temp) use ($template) {
                                //             return $temp->id == reset($template)->templateId;
                                //         });

                                //         if (!empty($filter)) {
                                //             $find = true;
                                //         }
                                //     }
                                //     if (!$find) {
                                //         $templateNoProduct[] = new LayoutView(
                                //             reset($template)->templateId,
                                //             reset($template)->templateName,
                                //             $fieldsNoProduct
                                //         );
                                //     }
                                // }
                            }
                        }
                    }

                    $elemType = array_values(array_filter($elementTypesPim, function ($type) use ($elementType) {
                        return $type['id'] === $elementType->getElementTypePIM();
                    }));


                    if (!empty($elemType)) {
                        $elementTypes[] = new ElementTypeTemplateView(
                            $elementType->getElementTypePIM(),
                            $elemType[0]['name'],
                            $templates,
                            $project->getDraft(),
                            true
                        );
                    } else if (!empty($templateNoProduct)) {
                        $elementTypes[] = new ElementTypeTemplateView(
                            null,
                            "Var No Product",
                            $templateNoProduct,
                            $project->getDraft(),
                            false
                        );
                    }
                }
                $fields = array_values($fields);
                $fieldsNoProduct = array_values($fieldsNoProduct);
                if (!empty($layouts)) {
                    $fields = $this->findLinkField($layouts, $templateField, $fieldTypesPim, $fields);
                    $fieldsNoProduct = $this->findLinkField($layouts, $templateField, $fieldTypesPim, $fieldsNoProduct);
                    // $linkedField = $findLinkField['linkedField'];
                    // $name = $findLinkField['twigName'];
                    // $idLayout = $findLinkField['idLayout'];
                    // $editable = $findLinkField['editable'];
                }
                if (!empty($layouts)) {

                    $findLinkInput = $this->findLinkInput($layouts, $templateField, $fieldTypesPim, $i);
                    $linkedInput = $findLinkInput['linkedField'];
                    $nameInput = $findLinkInput['twigName'];
                    $editableInput = $findLinkInput['editable'];
                }
            }
        }

        return $elementTypes;
    }

    public function getLinkVariableProjectAndPim(int $id)
    {
        $project = $this->projectRepository->findById($id);
        if (null === $project) {
            throw new NotFoundMaestroException("Project with id " . $id);
        }

        $useProduct = $project->getProductsImport();
        if ($useProduct) {
            $elementTypesPim = $this->collectElementType->list();

            $elementTypesMap = array_map(function ($elementTypeProject) {
                return $elementTypeProject->getElementTypePIM()  != null ? $elementTypeProject->getElementTypePIM() : 0;
            }, $project->getElementTypes()->toArray());

            $fieldTypes = $this->findFieldTypeProvider->getFieldTypeByElementTypes(implode(',', $elementTypesMap));
            $fieldTypesByElementType = [];
            if (is_array($fieldTypes)) {
                foreach ($fieldTypes as $fieldType) {
                    $fieldTypesByElementType[$fieldType['idElementType']][] = $fieldType;
                }
            }
        }
        // ----- get field template ------
        $exports = $project->getExports();
        $variableProjects = [];
        $templates = [];
        if (!$exports->isEmpty()) {
            foreach ($exports as $export) {
                if ($export->getDeleted() == null) {
                    $elementTypeTemplates = $export->getTemplates();
                    if (!$elementTypeTemplates->isEmpty()) {
                        foreach ($elementTypeTemplates as $elementTypeTemplate) {
                            if (is_array($elementTypeTemplate->getTemplates())) {
                                $templateIds = array_map(function ($temp) {
                                    return $temp['id'];
                                }, $elementTypeTemplate->getTemplates());
                                $templates = array_merge($templates, $templateIds);
                            }
                        }
                    }
                }
            }
        }
        // ------ get variable project -------
        $variableProjectForTemplate = [];
        $variableProjectForElement = [];
        $inputProjects = [];

        if (!empty($templates)) {
            $templateVariableProjects = $this->variableProjectRepository->findByVariableInTemplateIds($templates);
            // Return template's medias positions
            // $templateMediasVariableProjects = $this->variableProjectRepository->findByTemplateMediaVariableInTemplateIds($templates);
            $inputProjects = $this->variableProjectRepository->findByInputInTemplateIds($templates);

            // $mergedVariables = array_merge($templateVariableProjects, $templateMediasVariableProjects);

            $variableProjectForElement = array_filter($templateVariableProjects/*$mergedVariables*/, function ($var) {
                return $var['forElement'];
            });

            $variableProjectForTemplate = array_filter($templateVariableProjects/*$mergedVariables*/, function ($var) {
                return !$var['forElement'];
            });
        }
        if ($useProduct) {

            $fieldTypes = $this->findFieldTypeProvider->getFieldTypeByElementTypes(implode(',', $elementTypesMap));
            $fieldTypesByElementType = [];
            if (is_array($fieldTypes)) {
                foreach ($fieldTypes as $fieldType) {
                    $fieldTypesByElementType[$fieldType['idElementType']][] = $fieldType;
                }
            }
        }

        $elementTypes = [];

        $templateNoProduct = [];

        $elementFieldsTemplatesView = []; // ElementFieldsTemplatesView
        if (!empty($project->getElementTypes())) {
            $fields = [];
            $fieldsNoProduct = [];
            foreach ($project->getElementTypes() as $elementType) {
                if ($elementType->getDeletedAt() == null) {
                    if ($useProduct) {
                        $elemType = array_values(array_filter($elementTypesPim, function ($type) use ($elementType) {
                            return $type['id'] === $elementType->getElementTypePIM();
                        }));
                    }
                    $templates = [];

                    $layouts = $this->layoutRepository->findByElementTypeId($elementType->getId());
                    $fieldTypesPim = [];
                    if ($useProduct && $elementType->getElementTypePIM() && isset($fieldTypesByElementType[$elementType->getElementTypePIM()])) {
                        $fieldTypesPim = $fieldTypesByElementType[$elementType->getElementTypePIM()];
                    }
                    $variables = [];
                    $variableProjectFilters = !empty($elementType->getElementTypePIM()) ? $variableProjectForElement : $variableProjectForTemplate;
                    foreach ($variableProjectFilters as $varProj) {
                        $variableIdsMap = array_map(function ($variable) {
                            return $variable['variableProjectId'];
                        }, $variables);

                        if (!in_array($varProj['variableProjectId'], $variableIdsMap)) {

                            $layoutProject = array_filter($layouts, function ($layout) use ($varProj) {
                                return !empty($layout->getVariableProject()) && $layout->getVariableProject()->getId() == $varProj['variableProjectId'];
                            });

                            $inputs = [];


                            foreach ($inputProjects as $input) {
                                $inputIdsMap = array_map(function ($inp) {
                                    return $inp['variableProjectId'];
                                }, $inputs);

                                if (!in_array($input['variableProjectId'], $inputIdsMap)) {
                                    if ($input['variableProjectParentId'] == $varProj['variableProjectId']) {
                                        $inputFilter = [];
                                        if (!empty($layoutProject)) {
                                            $inputLink = reset($layoutProject)->getInputs();
                                            $inputFilter = array_filter($inputLink, function ($inp) use ($input) {
                                                return isset($inp['variableProjectId']) && $inp['variableProjectId'] == $input['variableProjectId'];
                                            });
                                        }

                                        $linkedInput = null;
                                        if (!empty($inputFilter)) {
                                            $linkedInput = [
                                                "id" => reset($inputFilter)['inputId'],
                                                "name" => reset($inputFilter)['inputName']
                                            ];
                                        }
                                        $inputs[] = [
                                            "name" => !empty($inputFilter) ? reset($inputFilter)['name'] : "",
                                            "variableProjectId" => $input['variableProjectId'],
                                            "variableProjectName" => $input['variableProjectName'],
                                            "linkedField" => $linkedInput,
                                            "fieldType" => $input['fieldType'],
                                            "editable" => !empty($inputFilter) ? reset($inputFilter)['editable'] : true
                                        ];
                                    }
                                }
                            }
                            $linkedField = null;
                            if (!empty($layoutProject)) {
                                $layout = reset($layoutProject);
                                $valueFilter = array_filter($fieldTypesPim, function ($field) use ($layout) {
                                    return +$field['id'] === +$layout->getElementTypeFieldId();
                                });
                                if (!empty($valueFilter)) {
                                    $linkedField = new FieldNameView(
                                        reset($valueFilter)['id'],
                                        reset($valueFilter)['name']
                                    );
                                }
                            }
                            $variables[] = [
                                "id" => !empty($layoutProject) ? reset($layoutProject)->getId() : null,
                                "name" => !empty($layoutProject) ? reset($layoutProject)->getName() : "",
                                "variableProjectId" => $varProj['variableProjectId'],
                                "variableProjectName" => $varProj['variableProjectName'],
                                "linkedField" => !empty($linkedField) ? $linkedField : null,
                                "fieldType" => $varProj['fieldType'],
                                "fieldsets" => $inputs,
                                "editable" => !empty($layoutProject) ? reset($layoutProject)->getEditable() : true,
                                "forElement" => $varProj['forElement']
                            ];
                        }
                    }
                    if (!empty($elementType->getElementTypePIM())) {
                        if ($useProduct) {
                            $elementTypes[] = new ElementTypeTemplateView(
                                $elementType->getElementTypePIM(),
                                $elemType[0]['name'],
                                $variables,
                                $project->getDraft(),
                                true
                            );
                        }
                    } else {
                        $elementTypes[] = new ElementTypeTemplateView(
                            null,
                            "Var No Product",
                            $variables,
                            $project->getDraft(),
                            false
                        );
                    }
                }
            }
        }
        return $elementTypes;
    }

    /**
     * @param [type] $layouts       [description]
     * @param [type] $templateField [description]
     * @param [type] $fieldTypesPim [description]
     *
     * @return array|null [description]
     */
    private function findLinkField($layouts, $templateField, $fieldTypesPim, $fields): ?array
    {
        for ($index = 0; $index < count($fields); $index++) {

            $findField = false;
            $linkedField = null;
            $i = 0;
            $nbLayouts = count($layouts);
            $name = $fields[$i]->name;
            $idLayout = null;
            $editable = false;
            while ($i < $nbLayouts && !$findField) {
                // if ($layouts[$i]->getTemplateTwigId() === $templateField->id && $layouts[$i]->getTemplateId() == $templateField->templateId && empty($layouts[$i]->getDeletedAt())) {
                if ($layouts[$index]->getTemplateTwigId() === $fields[$index]->id && empty($layouts[$i]->getDeletedAt())) {
                    $layout = $layouts[$i];

                    $editable = $layout->getEditable();
                    $valueFilter = array_filter($fieldTypesPim, function ($field) use ($layout) {
                        return +$field['id'] === +$layout->getElementTypeFieldId();
                    });
                    if (!empty($valueFilter)) {
                        $linkedField = new FieldNameView(
                            reset($valueFilter)['id'],
                            reset($valueFilter)['name']
                        );
                    }
                    if (!empty($layout->getName())) {
                        $name = $layout->getName();
                        $idLayout = $layout->getId();
                    }
                    $findField = true;
                }
                ++$i;
            }
            $fields[$index]->linkedField = $linkedField;
            $fields[$index]->editable = $editable;
        }

        return $fields;
    }

    /**
     * @param [type] $layouts       [description]
     * @param [type] $templateField [description]
     * @param [type] $fieldTypesPim [description]
     * @param [type] $index         [description]
     *
     * @return array|null [description]
     */
    private function findLinkInput($layouts, $templateField, $fieldTypesPim, $index): ?array
    {
        $findField = false;
        $linkedField = null;
        $i = 0;
        $nbLayouts = count($layouts);
        $name = $templateField->inputs[$index]->name;
        $idLayout = null;
        $editable = false;
        while ($i < $nbLayouts && !$findField) {
            if ($layouts[$i]->getTemplateTwigId() === $templateField->id && empty($layouts[$i]->getDeletedAt())) {
                $layout = $layouts[$i];
                $inputs = $layout->getInputs();
                if ($this->isInputValid($inputs, $index)) {
                    $linkedField = new FieldNameView(
                        $inputs[$index]['inputId'],
                        $inputs[$index]['inputName']
                    );
                    if (isset($inputs[$index]['editable'])) {
                        $editable = $inputs[$index]['editable'];
                    }

                    if (!empty($layout->getName())) {
                        $name = $inputs[$index]['name'];
                    }
                    $findField = true;
                }
            }
            ++$i;
        }

        return ["linkedField" => $linkedField, "twigName" => $name, "idLayout" => $idLayout, "editable" => $editable];
    }

    /**
     * @param array $inputs [list input]
     * @param int   $index  [index]
     *
     * @return bool [description]
     */
    private function isInputValid(array $inputs, int $index): bool
    {
        $result = !empty($inputs) && isset($inputs[$index]);

        return $result;
    }

    /**
     * @param array        $elementsGabValues [description]
     * @param CommonIdView $templateView      [description]
     *
     * @return array|Exception [description]
     */
    public function getContent(array $elementsGabValues, CommonIdView $templateView, Exports $export, ?PageDataGenerateView $pageInformation, array $allMedias)
    {
        $exportType = $this->getExportType($export);

        if ($exportType === 'HTML') {
            $templateData = $this->getTemplateGenerationDataHTML($elementsGabValues, $pageInformation, $templateView, $allMedias);
            $arrayData['contentType'] = 'html';
        } else {
            $arrayData['contentType'] = 'xml';
            $templateData = $this->getTemplateGenerationDataXML($elementsGabValues, $pageInformation, $templateView, $exportType, $allMedias);
        }

        $arrayData["fontPath"] = isset($templateData->fontPath) ? $templateData->fontPath : null;

        if (isset($templateData->content) && $templateData->content) {
            $arrayData["content"] = $templateData->content;
            $result = $arrayData;
        } else {
            $result = new Exception('No Content provided !'); // TODO : Create service to store Exception's message and generate them dynamically
        }

        return $result;
    }

    /**
     * @param CommonIdView $templateView      [description]
     *
     * @return array|Exception [description]
     */
    public function getFiles(CommonIdView $templateView, Exports $export)
    {
        $exportType = $this->getExportType($export);

        if ($exportType === 'HTML') {
            // $result = $this->templateCollect->getHTMLTemplateFilesGenerationData($templateView->id);

            $pictosIds = $this->templateQuery->getPictoIds($templateView);

            $dedicatedFiles = $this->templateQuery->geTHTMLFile($templateView->id);

            $files = $dedicatedFiles;
            $files['pictoIds'] = $pictosIds;
        } else {
            // $result = $this->templateCollect->getTemplateFilesGenerationData($templateView->id);

            $pictosIds = $this->templateQuery->getPictoIds($templateView);

            $dedicatedFiles = $this->templateQuery->getDedicatedFiles($templateView);

            $files = ["pictoIds" => $pictosIds, "templateFiles" => $dedicatedFiles];
        }

        return $files;
    }

    private function getExportType($export)
    {
        return $exportType = $this->exportsRepository::EXPORT_TYPE[$export->getExportType()];
    }

    /**
     * {@inheritDoc}
     */
    public function getTemplateGenerationDataXML(array $elementsGabValues, ?PageDataGenerateView $pageInformation, CommonIdView $view, string $exportType = "xml", array $allMedias = [])
    {
        $error = "Empty data";

        // Get Template name, File name, Twig content & Element Number
        $generatedData = $this->templateQuery->getGenerationData($view, $exportType);
        // Create a temporary file with twigContent
        $this->templateTwigExtension->createTwigFile($generatedData['twigContent']);
        // Get an array whith __variable__ => pimValue based on $elementGabValues
        // TODO : Get from getGenerationData method Variable.name and Variable.twigVar and do a correspondence between $elementGabValues.key and Variable.name to set as array's key Variable.twigVar insteadOf '__'.$elementGabValues.key.'__'
        $elementsGabValues = ['values' => $elementsGabValues, 'folio' => $pageInformation->folio];
        $variablesValues = $this->templateTwigExtension->getVariablesValues($elementsGabValues, $generatedData['elementNumber'], "xml", $view->id, $allMedias);

        $variablesValues["_utils_"] = [
            "template" => $generatedData['templateName'],
            "nbPage" => $pageInformation->nbPage,
            "nbProduct" => $pageInformation->nbProduct
        ];

        if (is_array($variablesValues) && !empty($variablesValues)) {
            // Generate xml content
            $xmlContent = $this->templateTwigExtension->getXmlContent($variablesValues);

            $generationDataView = new GenerationDataView(
                isset($generatedData['templateName']) ? $generatedData['templateName'] : '',
                isset($generatedData['fileOriginalName']) ? $generatedData['fileOriginalName'] : '',
                $xmlContent,
                isset($generatedData['fontPath']) ? $generatedData['fontPath'] : null,
            );
            return $generationDataView;
        } else {
            throw new UnprocessableEntityMaestroException($error, "variable", "getVariablesValues");
        }
    }

    private function getTemplateGenerationDataHTML(array $elementsGabValues, ?PageDataGenerateView $pageInformation, CommonIdView $view, array $allMedias = [])
    {
        $error = "Empty data";
        // Get Template entity
        $generatedData = $this->templateQuery->read($view);

        // TODO : Get from getGenerationData method Variable.name and Variable.twigVar and do a correspondence between $elementGabValues.key and Variable.name to set as array's key Variable.twigVar insteadOf '__'.$elementGabValues.key.'__'
        $elementsGabValues = ['values' => $elementsGabValues, 'folio' => $pageInformation->folio];
        $variablesValues = $this->templateTwigExtension->getVariablesValues($elementsGabValues, $generatedData->getNbElement(), "html", $view->id, $allMedias);
        if (is_array($variablesValues) && !empty($variablesValues)) {
            // Generate HTML content
            $htmlContent = $this->templateTwigExtension->getHtmlContent($variablesValues, $view->id, $elementsGabValues);
            $name = $generatedData->getName();

            $htmlGenerationDataView = new GenerationDataView(
                isset($name) ? $name : '',
                'export.twig.html',
                $htmlContent,
                null
            );

            return $htmlGenerationDataView;
        } else {
            throw new UnprocessableEntityMaestroException($error, "variable", "getVariablesValues");
        }
    }
}