<?php

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

namespace App\Command;

use App\Application\Adapter\Query\Variable\VariableReadQueryInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\console\Output\OutputInterface;
use App\Domain\Adapter\ValueRepositoryInterface;
use App\Domain\Adapter\VariableProjectRepositoryInterface;
use App\Domain\Adapter\VariableRepositoryInterface;
use App\Domain\Entity\ElementMedia;
use App\Domain\Entity\ExportTemplateOption;
use App\Domain\Entity\Input;
use App\Domain\Entity\Layout;
use App\Domain\Entity\Media;
use App\Domain\Entity\Option;
use App\Domain\Entity\Value;
use App\Domain\Entity\Variable;
use App\Domain\Entity\VariableProject;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Question\Question;

class TransfertValueToVariableProjectValueCommand extends Command
{

    /**
     * @var ValueRepositoryInterface
     */
    private $valueRepository;

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

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

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

    private $valueRepo;
    private $variableRepo;
    private $inputRepo;
    private $variableProjectRepo;
    private $mediaRepo;
    private $optionRepo;
    private $optionValueRepo;
    private $mediaValueRepo;

    public function __construct(
        ValueRepositoryInterface $valueRepository,
        VariableProjectRepositoryInterface $variableProjectRepository,
        VariableRepositoryInterface $variableRepository,
        EntityManagerInterface $entityManager
    ){
        parent::__construct();
        $this->valueRepository = $valueRepository;
        $this->variableProjectRepository = $variableProjectRepository;
        $this->variableRepository = $variableRepository;
        $this->entityManager = $entityManager;
        $this->valueRepo = $this->entityManager->getRepository(Value::class);
        $this->variableRepo = $this->entityManager->getRepository(Variable::class);
        $this->inputRepo = $this->entityManager->getRepository(Input::class);
        $this->variableProjectRepo = $this->entityManager->getRepository(VariableProject::class);
        $this->mediaRepo = $this->entityManager->getRepository(Media::class);
        $this->optionRepo = $this->entityManager->getRepository(Option::class);
        $this->optionValueRepo = $this->entityManager->getRepository(ExportTemplateOption::class);
        $this->mediaValueRepo = $this->entityManager->getRepository(ElementMedia::class);
    }

    protected function configure()
    {
        $this // the name of the command (the part after "bin/console")
            ->setName('transfert:variableprojectvalue')
            // the short description shown while running "php bin/console list"
            ->setDescription('Transfert Value to variableProject');
            // add 'processDate' argument
    }

    public function execute(InputInterface $input, OutputInterface $output)
    {
        $this->createVariableProject($input, $output);
        $this->createVariableProjectPhoto();
        $this->createVariableProjectOption();
        $this->step5linkVariableProject();
        $values = $this->valueRepository->list();

        foreach ($values as $value) {
            if(empty($value->getVariableProject())){
                $variable = $this->variableRepo->findOneBy(["id" => $value->getTemplateFieldId()]);
    
                if(!empty($variable) && !empty($variable->getVariableProject())){
    
                    $valsWithVarProject = $this->valueRepo->findBy([
                        "templateFieldId" => $value->getTemplateFieldId(),
                        "variableProject" => $variable->getVariableProject()->getId(),
                        "flatplanPageId" => $value->getFlatplanPageId()
                    ]);
                    if(empty($valsWithVarProject)){
                        if($variable->getFieldType() === "fieldset" || $variable->getFieldType() === "productLink"){
                            $valuesInput = $this->valueRepo->findBy([
                                "templateFieldId" => $value->getTemplateFieldId(),
                                "flatplanPageId" => $value->getFlatplanPageId(),
                                "pimElementId" => !empty($value->getPimElementId()) ? $value->getPimElementId() : null,
                                "variableProject" => null 
                            ]);

                            foreach ($valuesInput as $valueInput) {
                                $valueInput->setVariableProject($variable->getVariableProject());
                                $this->entityManager->persist($valueInput);
                            }

                        } else {
                            $value->setVariableProject($variable->getVariableProject());
                            $this->entityManager->persist($value);
                        }
                    }
                }
            }
        }
        $this->entityManager->flush();
    }

    private function step5linkVariableProject()
    {
        $layoutRepo = $this->entityManager->getRepository(Layout::class);

        $layouts = $layoutRepo->findBy([
            "variableProject" => null
        ]);

        if(!empty($layouts)){
            foreach ($layouts as $layout) {
                $variable = $this->variableRepo->findOneBy([
                    "id" => $layout->getTemplateTwigId()
                ]);

                if(!empty($variable) && !empty($variable->getVariableProject())){

                    $searchLayoutsWithVarProj = $layoutRepo->findBy([
                        "templateTwigId"=>$layout->getTemplateTwigId(),
                        "elementType"=>$layout->getElementType()->getId(),
                        "variableProject"=>$variable->getVariableProject()->getId(),
                    ]);

                    if(empty($searchLayoutsWithVarProj)){

                        $layout->setVariableProject($variable->getVariableProject());

                        $inputs = $layout->getInputs();
                        if(!empty($inputs)){
                            for ($i=0; $i < count($inputs); $i++) { 
                                $inp = $this->inputRepo->findOneBy([
                                    "id" => $inputs[$i]["twigInputId"]
                                ]);
                                
                                if(!empty($inp) && !empty($inp->getVariableProject())){
                                    $inputs[$i]["variableProjectId"] = $inp->getVariableProject()->getId();
                                    
                                }
                            }
                            $layout->setInputs($inputs);
                        }
                        $this->entityManager->persist($layout);
                    }
                }
            }
        }
    }

    private function createVariableProject($inputConsole, $output)
    {
        $variables = $this->variableRepo->findBy([
            "variableProject" => null,
            "deletedAt" => null
        ]);
        $variableCreated = [];
        $variableNameCreated = [];
        $variableTypeCreated = [];

        $inputCreated = [];
        $inputNameCreated = [];
        $inputTypeCreated = [];
        $variableProjs = $variableProject = $this->variableProjectRepo->findBy(["deletedAt" => null]);

        foreach ($variableProjs as $variableProj) {
            $variableCreated[] = $variableProj->getName();
            $variableNameCreate[$variableProj->getName()][$variableProj->getFieldType()] = $variableProj;
        }

        if(!empty($variables)){
            foreach ($variables as $variable) {
                $variableProject = $this->verifNameVariable($variable->getName(),$variable,$variableCreated,$variableNameCreated, $inputConsole, $output);     
                $variableCreated[$variable->getName()][$variable->getFieldType()] = $variableProject;                    
                $variableNameCreated[] = $variable->getName();
                $variable->setVariableProject($variableProject);
                if($variable->getFieldType() === "fieldset" || $variable->getFieldType() === "productLink"){
                    $inputs = $variable->getInputs();

                    if(!empty($inputs)){
                        foreach ($inputs as $input) {
                            if($input->getDeletedAt() === null && empty($input->getVariableProject())){
                                if(in_array($input->getName(), $inputNameCreated)){
                                    $input->setVariableProject($inputCreated[$input->getName()]);
                                } else{
                                    $inputProject = $this->variableProjectRepo->findOneBy([
                                        "name" => $input->getName(),
                                        "categorie" => "input",
                                        "fieldType" => $input->getFieldType()
                                    ]);
    
                                    if(!empty($inputProject)){
                                        $input->getVariableProject($inputProject);
                                    } else {
                                        $inputProject = new VariableProject();
                                        $inputProject->setName($input->getName());
                                        $inputProject->setCategorie("input");
                                        $inputProject->setFieldType($input->getFieldType() ? $input->getFieldType() : "textarea");
    
                                        $input->setVariableProject($inputProject);
                                    }

                                    $inputNameCreated[] = $input->getName();
                                    $inputCreated[$input->getName()] = $inputProject;
                                }

                                $this->entityManager->persist($input);
                            }
                        }
                    }
                }

                $this->entityManager->persist($variable);
            }

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

    private function verifNameVariable($name, $variable, $variableCreated, $variableNameCreated, $input, $output){
        $result = null;
        if(isset($variableCreated[$name])){
            if(isset($variableCreated[$name][$variable->getFieldType()])){

                $result = $variableCreated[$name][$variable->getFieldType()];
            } else {
                $helper = $this->getHelper('question');
                $question = new Question('The variable "'. $name.'" is already created, the new variable is a '.$variable->getFieldType().',please write a new name: ', 'AcmeDemoBundle');

                $variableName = $helper->ask($input, $output, $question);

                $result = $this->verifNameVariable($variableName, $variable, $variableCreated, $variableNameCreated, $input, $output);
            }
        } else{
            $variableProject = new VariableProject();
            $variableProject->setName($name);
            $variableProject->setCategorie("variable");
            $variableProject->setFieldType($variable->getFieldType() ? $variable->getFieldType() : "textarea");

            $result = $variableProject;
                             
        }

        return $result;
    }

    private function createVariableProjectPhoto()
    {
         
        $medias = $this->mediaRepo->findBy([
            "variableProject" => null,
            "deletedAt" => null
        ]);

        $variableCreated = [];
        $variableNameCreated = [];

        if(!empty($medias)){
            foreach ($medias as $media) {
                if(in_array($media->getName(), $variableNameCreated)){
                    $variableProject = $variableCreated[$media->getName()];
                    $media->setVariableProject($variableProject);
                } else{

                    $variableProject = $this->variableProjectRepo->findOneBy([
                        "name" => $media->getName(),
                        "categorie" => "media"
                    ]);

                    if(!empty($variableProject)){
                        $media->setVariableProject($variableProject);
                    } else {
                        $variableProject = new VariableProject();
                        $variableProject->setName($media->getName());
                        $variableProject->setCategorie("media");
                        $variableProject->setFieldType("-1");
                        $this->entityManager->persist($variableProject);
        
                        $media->setVariableProject($variableProject);
                        $this->entityManager->persist($media);

                    }
                    $variableNameCreated[] = $media->getName();
                    $variableCreated[$media->getName()] = $variableProject;
                }
                $mediaValues = $this->mediaValueRepo->findBy([
                    "templateMediaId" => $media->getId(),
                    "variableProject" => null
                ]);

                if(!empty($mediaValues)){
                    foreach ($mediaValues as $mediaValue) {
                        $mediaValue->setVariableProject($variableProject);
                        $this->entityManager->persist($mediaValue);
                    }
                }

            }

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

    private function createVariableProjectOption()
    {
        $options = $this->optionRepo->findBy([
            "variableProject" => null,
            "deletedAt" => null
        ]);
        $variableCreated = [];
        $variableNameCreated = [];
        if(!empty($options)){
            foreach ($options as $option) {

                if(in_array($option->getName(), $variableNameCreated)){
                    $option->setVariableProject($variableCreated[$option->getName()]);
                } else{
                    $variableProject = $this->variableProjectRepo->findOneBy([
                        "name" => $option->getName(),
                        "fieldType" => "option"
                    ]);
                    if(!empty($variableProject)){
                        $option->setVariableProject($variableProject);
                    } else {
                        $variableProject = new VariableProject();
                        $variableProject->setName($option->getName());
                        $variableProject->setCategorie("option");
                        $variableProject->setFieldType($option->getType());
    
                        $this->entityManager->persist($variableProject);
        
                        $option->setVariableProject($variableProject);
                        $this->entityManager->persist($option);

                    }
                    $variableNameCreated[] = $option->getName();
                    $variableCreated[$option->getName()] = $variableProject;
                }

                $optionValues = $this->optionValueRepo->findBy([
                    "templateOptionId" => $option->getId(),
                    "variableProject" => null
                ]);

                if(!empty($optionValues)){
                    foreach ($optionValues as $optionValue) {
                        $optionValue->setVariableProject($variableProject);
                        $this->entityManager->persist($optionValue);
                    }
                }
            }

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

}