<?php

/*
 * This file is part of the Syspad Templates project.
 * Copyright (C) Compos Juliot
 */

namespace App\Application\Query\Twig;

use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\Adapter\Query\Twig\TwigUpdateQueryInterface;
use App\Application\View\Twig\TwigView;
use App\Domain\Adapter\TwigRepositoryInterface;
use App\Domain\Adapter\VariableRepositoryInterface;
use App\Domain\Adapter\InputRepositoryInterface;
use App\Domain\Entity\Twig;
use App\Application\Adapter\TwigVariableExtractorInterface;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Application\Exception\SubException\NotFoundMaestroException;
use App\Application\Adapter\Query\Template\DeleteQueryInterface;
use App\Application\Adapter\Query\Template\TemplateQueryInterface;
use App\Domain\Entity\Variable;
use App\Domain\Entity\Input;
use App\Domain\Entity\Template;
use Doctrine\ORM\EntityManagerInterface;

class TwigUpdateQuery implements TwigUpdateQueryInterface
{
    /** @var TwigRepositoryInterface */
    private $twigRepository;

    /** @var TwigVariableExtractorInterface */
    private $twigVariableExtractor;

    /** @var VariableRepositoryInterface */
    private $variableRepository;

    /** @var InputRepositoryInterface */
    private $inputRepository;

    /** @var DeleteQueryInterface */
    private $templateDeleteQuery;

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

    /** @var array */
    private $varKeys = [
        "twigContent" => "content",
        "twigVar" => "twigVar",
        "twigVarName" => "name",
        "twigVarInputName" => "variableName",
        "twigVarInputs" => "inputs"
    ];

    /** @var int */
    private $nbVar = 0;

    /** @var array */
    private $simpleIndexToRemove = []; // Store index of existing simple variables to remove from array data

    /** @var array */
    private $nestedIndexToRemove = []; // Store index of existing nested variable's inputs to remove from array data

    /** @var array */
    private $variablesToRemove = []; // Store Variable entities to remove from database

    /** @var array */
    private $inputsToRemove = []; // Store Input entities to remove from database

    /** @var array */
    private $controlNestedVariables = []; // Store Variable entities in nested variable case to retrieve object easier

    /** @var array */
    private $newNestedVariablesInputs = []; // Store new variable's inputs

    /** @var array */
    private $tmpNested = []; // Create a temporary array to extract all new nested content after removed existing 

    /** @var array */
    private $variableAndInputIds = []; // Store Variable and Input ids to remove from Project

    /** @var TemplateQueryInterface */
    private $templateQueryInterface = []; // Store Variable and Input ids to remove from Project

    public function __construct(TwigRepositoryInterface $twigRepository, TwigVariableExtractorInterface $twigVariableExtractor, VariableRepositoryInterface $variableRepository, InputRepositoryInterface $inputRepository, DeleteQueryInterface $templateDeleteQuery, EntityManagerInterface $entityManager, TemplateQueryInterface $templateQueryInterface)
    {
        $this->twigRepository = $twigRepository;
        $this->twigVariableExtractor = $twigVariableExtractor;
        $this->variableRepository = $variableRepository;
        $this->inputRepository = $inputRepository;
        $this->templateDeleteQuery = $templateDeleteQuery;
        $this->entityManager = $entityManager;
        $this->templateQueryInterface = $templateQueryInterface;
    }

    /**
     * @param TwigView $twigView
     *
     * @throws NotFoundMaestroException
     * 
     * @return bool
     */
    public function update(TwigView $twigView): bool
    {
        $twigEntity = $this->twigRepository->findById($twigView->id);

        if ($twigEntity) {
            $twigView->name ? $twigEntity->setName($twigView->name) : null;
            $twigView->exportType ? $twigEntity->setExportType($twigView->exportType) : null;
            $twigEntity->setContent($twigView->content);

            $diff = $this->twigRepository->diff($twigEntity);
            if(!empty($twigView->templates)){
                $templateRepository = $this->entityManager->getRepository(Template::class);
                $template = $templateRepository->findOneBy(['id' => reset($twigView->templates)]);
                if(!empty($template)){
                    $template->setTwig($twigEntity);
                    $this->entityManager->persist($template);
                    $this->entityManager->flush();
                }
            }
            if (!empty($diff)) {
                $this->twigRepository->save($twigEntity);

                $contentToUpdate = array_key_exists($this->varKeys["twigContent"], $diff);

                if ($contentToUpdate) {
                    $this->updateVariablesAndInputs($twigEntity);
                    if (!empty($this->variableAndInputIds)) {
                        $this->templateDeleteQuery->deleteByVariables($this->variableAndInputIds);
                    }
                }                
                
                foreach($twigEntity->getTemplates() as $template){
                    $this->templateQueryInterface->addTemplatePageToGenerate($template);
                }
                return true;
            } else {
                return "Nothing to update !";
            }
        } else {
            throw new NotFoundMaestroException("Twig for id : $twigView->id !");
        }
    }

    /**
     * @param Twig $twig
     * 
     * @return void
     */
    public function updateVariablesAndInputs(Twig $twig): void
    {
        $twigContent = $twig->getContent(); // Get twig's content which contains variables and inputs

        // Extract simple variables by content 
        $simpleVariables = $this->twigVariableExtractor->extractSimpleVariables($twigContent);

        // Extract nested variables with inputs by content
        $nestedVariables = $this->twigVariableExtractor->extractNestedVariables($twigContent);
        $extractTwigVariables = array_merge($simpleVariables, $nestedVariables);
        $this->tmpNested = $nestedVariables;

        $twigVariables = $twig->getVariables(); // Get twig's variables
        $variableRepo = $this->entityManager->getRepository(Variable::class);
        $variables = $variableRepo->findBy([
            "twig" => $twig->getId(),
            "deletedAt" => null
        ]);
        $this->nbVar = count($variables);
        $saveVariables = [];
        foreach ($extractTwigVariables as $extractTwigVariable) {
            // Value to find in arrays
            $saveVariables[] = $this->controlExtractVariables($extractTwigVariable, $twigVariables, $twig);  
        }
        if(!empty($saveVariables)){
            $this->variableRepository->saveMultiple($saveVariables);
        }


        foreach($twig->getTemplates() as $template){
            $this->templateQueryInterface->addTemplatePageToGenerate($template);
        }
    }

    
     /**
     * @param array $nestedVariables
     * @param Twig $twig
     * 
     * @return Variable
     */
    private function controlExtractVariables(array $extractTwigVariable, $variables, Twig $twig)
    {
        $variable = $variables->filter(function($var) use ($extractTwigVariable) {
            return $var->getTwigVar() == $extractTwigVariable['twigVar'] && $var->getDeletedAt() == null;
        });
        // $inputs = [];
        if (!$variable->isEmpty()) {
            // Get Variable
            $variableEntity = $variable->first();
        } else {
            // Create Variable
            $this->nbVar++;
            $variableEntity = new Variable();
            $variableEntity->setFieldType('textarea');
            $variableEntity->setTwigVar($extractTwigVariable['twigVar'])
            ->setName($extractTwigVariable['name'])
            ->setForElement($extractTwigVariable['forElement'])
            ->setTwig($twig)
            ->setPosition($this->nbVar);
        }
            if(isset($extractTwigVariable['inputs']) && !empty($extractTwigVariable['inputs'])){
                $variableEntity->setFieldType('fieldset');
                foreach ($extractTwigVariable['inputs'] as $extractInput) {
                    if($variableEntity->getId()){
                        $input = $variableEntity->getInputs()->filter(function($inp) use ($extractInput){
                            return $inp->getVariableName() == $extractInput['variableName'] && $inp->getDeletedAt() == null;
                        });
                        if(!$input->isEmpty()){
                            continue;
                        }
                    }
                    $inputEntity = new Input();
                    $inputEntity->setVariableName($extractInput['variableName'])
                        ->setName($extractInput['name'])
                        ->setVariable($variableEntity)
                        ->setFieldType('textarea');
                    $variableEntity->addInput($inputEntity);
                }
            }
        return $variableEntity;
    }   
}