<?php

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

namespace App\Application\Query\Product;

use App\Application\Adapter\Query\Page\PageAutoGenerationQueryInterface;
use App\Application\Adapter\Query\Page\PageQueryInterface;
use App\Application\Adapter\Query\Product\SaveQueryInterface;
use App\Application\Adapter\Query\Project\DraftQueryInterface;
use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\View\Story\ElementTypeStoryView;
use App\Domain\Adapter\ElementTypeRepositoryInterface;
use App\Domain\Adapter\ElementTypesTemplatesRepositoryInterface;
use App\Domain\Adapter\LayoutRepositoryInterface;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Adapter\ProjectRepositoryInterface;
use App\Domain\Entity\ElementType;
use App\Domain\Entity\Project;
use App\Infrastructure\Repository\PageRepository;
use Doctrine\ORM\EntityManagerInterface;

class SaveQuery implements SaveQueryInterface
{
    /** @var ElementTypeRepositoryInterface */
    private $elementTypeRepository;

    /** @var ElementTypesTemplatesRepositoryInterface */
    private $elementTypeTemplatesRepository;

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

    /** @var DraftQueryInterface */
    private $draftQuery;

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

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

    /** @var PageAutoGenerationQueryInterface */
    private $pageAutoGeneQuery;

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

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

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

    public function __construct(
        ElementTypeRepositoryInterface $elementTypeRepository,
        ElementTypesTemplatesRepositoryInterface $elementTypeTemplatesRepository,
        DraftQueryInterface $draftQuery,
        ProjectRepositoryInterface $projectRepository,
        StoryQueryInterface $story,
        PageRepositoryInterface $pageRepository,
        PageAutoGenerationQueryInterface $pageAutoGeneQuery,
        PageQueryInterface $pageQuery,
        LayoutRepositoryInterface $layoutRepository,
        EntityManagerInterface $entityManager
    ) {
        $this->elementTypeRepository = $elementTypeRepository;
        $this->elementTypeTemplatesRepository = $elementTypeTemplatesRepository;
        $this->projectRepository = $projectRepository;
        $this->draftQuery = $draftQuery;
        $this->story = $story;
        $this->pageRepository = $pageRepository;
        $this->pageAutoGeneQuery = $pageAutoGeneQuery;
        $this->pageQuery = $pageQuery;
        $this->entityManager = $entityManager;
        $this->layoutRepository = $layoutRepository;
    }

    /**
     * @return Project|bool
     */
    private function getProject(int $id)
    {
        $project = $this->projectRepository->findById($id);

        if (null === $project) {
            return false;
        }

        return $project;
    }

    /**
     * @param array $elementTypeData
     * @param int   $projectId
     *
     * @return bool
     */
    public function saveElementType(array $elementTypeData, int $projectId): bool
    {
        $elementTypes = [];
        $storyElementType = [];
        $elementTypeElementDel = [];
        $project = $this->getProject($projectId);
        if ($project) {
            $elementTypeIds = [];
            $diffElements = [];
            $diffElementTypeFields = [];
            $deleteElementPim = [];
            foreach ($elementTypeData as $elemType) {
                $type = $this->elementTypeRepository->findElementTypeByIdProject($elemType->id, $projectId);
                if (!$type) {
                    $type = new ElementType();
                }
                if(!empty($type->getElementsPIM())){
                    $diffElements = array_merge($diffElements, array_diff($type->getElementsPIM(),$elemType->elements));
                }
                if(!empty($type->getElementTypeFieldsPIM())){                
                    $diffElementTypeFields = array_merge($diffElementTypeFields, array_diff($type->getElementTypeFieldsPIM(),$elemType->fields));
                }
                // supprimer les éléments des export
                if(!empty($diffElements)){
                    $deleteElementPim = array_merge($deleteElementPim, $diffElements);
                    foreach($type->getTemplates() as $elementTypeExport){
                        if($elementTypeExport->getDeletedAt() == null){
                            $exportProduct = $elementTypeExport->getElementsPIM();
                            foreach ($diffElements as $diffElement) {
                                if (($key = array_search($diffElement, $exportProduct)) !== false) {
                                    unset($exportProduct[$key]);
                                }
                            }
        
                            $elementTypeExport->setElementsPIM($exportProduct);
                        }
                    }
                }
                
                $type->setElementTypePIM($elemType->id);
                $type->setVersionPIM($elemType->version);
                $type->setElementsPIM($elemType->elements);
                $type->setElementTypeFieldsPIM($elemType->fields);
                $type->setTagsPIM(json_encode($elemType->tags));
                $type->setProject($project);

                $storyElementType[] = new ElementTypeStoryView(
                    $elemType->id,
                    $elemType->version,
                    $elemType->elements,
                    $elemType->fields,
                    $projectId,
                    $elemType->tags
                );
                $elementTypes[] = $type;
                if (null !== $type->getId()) {
                    $elementTypeIds[] = $type->getId();
                }
            }
            
            // supprimer des export
            if (!empty($elementTypeIds)) {

                $deleteElementTypes = $this->elementTypeRepository->selectOtherMultiElementType( $elementTypeIds, $projectId);

                
                foreach ($deleteElementTypes as $deleteElementType) {
                    $deleteElementPim = array_merge($deleteElementPim, $deleteElementType->getElementsPIM());
                }
                
                $delTemplates = $this->elementTypeTemplatesRepository->removeElementType($projectId, implode(',', $elementTypeIds));
                if ($delTemplates) {
                    $this->elementTypeRepository->deleteMultiElementType(implode(',', $elementTypeIds), $projectId);
                }
            }

            $save = $this->elementTypeRepository->saveMultiple($elementTypes);

            if ($save) {

                if(!empty($diffElements)){
                    $this->preparePageToGeneViaElement($diffElements, $projectId);
                }

               
                if(!empty($diffElementTypeFields)){
                    $this->preparePageToGeneViaElementTypeField($diffElementTypeFields, $projectId);
                }

                if ($project->getCurrentStep() < 1) {
                    $project->setCurrentStep(1);
                    $this->projectRepository->create($project);
                }
                if (!empty($storyElementType)) {

                    $this->story->execute('Step 2', ['value' => $storyElementType], $projectId, get_class($project), 0);
                }

                if (isset($elementTypeData->lastStep) && $elementTypeData->lastStep) {
                    $this->draftQuery->changeDraft($projectId);
                }
            }

            return $save;
        }
        return false;
    }

    public function preparePageToGeneViaElement($diffElements, $projectId){
        
            $pageIds = [];
            $pages = $this->pageRepository->findByProjectId($projectId);
            if(!empty($pages)){
                $resavePages = [];
                foreach ($pages as $page) {
                    $pageProducts = json_decode($page->getIdProducts(), true);
                    if(!empty($pageProducts)){
                        $pageProductIds = array_column($pageProducts, 'id');
                        
                        $productsDeleteInPage = array_intersect($diffElements, $pageProductIds);
                        if(!empty($productsDeleteInPage)){
                            foreach ($productsDeleteInPage as $productDeleteInPage) {
                                if (($key = array_search($productDeleteInPage, $pageProductIds)) !== false) {
                                    unset($pageProducts[$key]);

                                }
                            }
                            $page->setIdProducts(json_encode($pageProducts));
                            
                            $pageIds[] = ['id' => $page->getId()];
                            if(!$page->getPageDuplicates()->isEmpty()){
                                foreach ($page->getPageDuplicates() as $dupli) {
                                    $dupliProducts = json_decode($dupli->getIdProducts(), true);

                                    if(!empty($dupliProducts)){
                                        $dupliProductsIds = array_column($dupliProducts, 'id');
                                        
                                        $productsDeleteInPageDupli = array_intersect($diffElements, $dupliProductsIds);

                                        if(!empty($productsDeleteInPageDupli)){
                                            foreach ($productsDeleteInPageDupli as $productDeleteInPageDupli) {
                                                if (($key = array_search($productDeleteInPageDupli, $dupliProductsIds)) !== false) {
                                                    unset($dupliProducts[$key]);
                                                }
                                            }
                                            $dupli->setIdProducts(json_encode($dupliProducts));

                                            $pageIds[] = ['id' => $page->getId(), "pageDuplicateId" => $dupli->getId()];
                                        }
                                    }
                                }
                            }

                            $resavePages[] = $page;
                        }
                    }
                }
                if(!empty($pageIds)){
                    $this->pageAutoGeneQuery->addPageToGenerate($pageIds);
                }

                if(!empty($resavePages)){
                    foreach ($resavePages as $resavePage) {
                        $this->entityManager->persist($resavePage);
                    }

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

    }

    private function preparePageToGeneViaElementTypeField($diffElementTypeFields, $projectId) {
        
            $layouts = $this->layoutRepository->findByProjectIdAndElementTypeFieldIds($projectId, $diffElementTypeFields);

            if(!empty($layouts)){
                $variableProjects = [];
                foreach ($layouts as $layout) {
                    $layout->setElementTypeFieldId(null);
                    $variableProjects[] = $layout->getVariableProject()->getId();
                }

                if(!empty($variableProjects)){
                    $pages = $this->pageRepository->findByVariableProjectAndProjectId($projectId, $variableProjects);
                    $pagesId = [];
                    if(!empty($pages)){
                        foreach ($pages as $page) {
                            $pagesId[] = ['id' => $page->getId()];
                            if(!$page->getPageDuplicates()->isEmpty()){
                                foreach ($page->getPageDuplicates() as $dupli) {
                                    $pagesId[] = ['id' => $page->getId(), "pageDuplicateId" => $dupli->getId()];
                                }
                            }
                        }
        
                        if(!empty($pagesId)){
                            $this->pageAutoGeneQuery->addPageToGenerate($pagesId);
                        }
                    }
                }
            }
        
    }
}