<?php

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

namespace App\Application\Query\Export;

use App\Application\Adapter\Query\Export\SaveVersionQueryInterface;
use App\Domain\Adapter\GroupProjectRepositoryInterface;
use App\Domain\Entity\Exports;
use App\Domain\Entity\VersionExport;
use App\Domain\Entity\VersionWorkflowOption;
use App\Domain\Entity\WorkflowProjectOptions;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\EntityManagerInterface;
use Exception;
use App\Domain\Adapter\CdfRepositoryInterface;
use App\Domain\Entity\PageDuplicate;
use App\Application\Adapter\PageInterface;

class SaveVersionQuery implements SaveVersionQueryInterface
{
    /** @var GroupProjectRepositoryInterface */
    private $groupRepository;

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

    /** @var CdfRepositoryInterface */
    private $cdfRepository;

    /** @var PageInterface */
    private $pageService;

    public function __construct(
        EntityManagerInterface $entityManager,
        GroupProjectRepositoryInterface $groupRepository,
        CdfRepositoryInterface $cdfRepository,
        PageInterface $pageService

    ) {
        $this->entityManager = $entityManager;
        $this->groupRepository = $groupRepository;
        $this->cdfRepository = $cdfRepository;
        $this->pageService = $pageService;
    }

    /**
     * {@inheritDoc}
     */
    public function save(Exports $export, array $version, int $idUser, string $token)
    {
        $creation = false;

        $repo = $this->entityManager->getRepository(VersionExport::class);

        if (isset($version['id']) && !empty($version['id'])) {
            $versionExport = $repo->findOneBy(['id' => $version['id']]);
        } else {
            $versionExport = null;
        }

        if (!empty($versionExport)) {
            if (isset($version['groups'])) {
                $versionExport = $this->removeGroup($version['groups'], $versionExport);
            }

            $versionExport = $this->update($versionExport, $version, $export);
        } else {
            $versionExport = $this->create($export, $version, $idUser);
            $creation = true;
        }

        if (isset($version['steps']) && !empty($version['steps'])) {
            $saveWorkflow = $this->saveWorkflow($versionExport, $version['steps']);
        }

        $this->entityManager->persist($versionExport);
        $this->entityManager->flush();

        if ($creation) {
            $allDuplicatePages = $versionExport->getPageDuplicates()->getValues();
            $duplicatePages = [];

            foreach ($allDuplicatePages as $duplicatePage) {
                if (!$duplicatePage->getPage()->getOption()->getCover() && $duplicatePage->getPage()->getOption()->getTemplate()) { // Do no take cover and page with no template
                    $duplicatePages[] = $duplicatePage;
                }
            }

            $ids = $this->pageService->autoAssignMedias($duplicatePages);

            if (!empty($ids["pageOptionsId"])) {
                $this->pageService->managePagesGeneration($ids["pageOptionsId"], $duplicatePages, $token, $ids["pageIds"]);
            }
        }

        $result = null;

        if (isset($saveWorkflow) && $saveWorkflow instanceof Exception) {
            $result = $saveWorkflow;
        } else {
            $result = $versionExport->getId();
        }

        return $result;
    }

    private function create(Exports $export, array $version, int $idUser): VersionExport
    {
        $idOwner = !empty($version['groups']) ? $version['groups'][0] : null;

        $versionExport = new VersionExport();

        $versionExport->setIdUser($idUser);
        $versionExport->setIdOwnerGroup($idOwner);
        $versionExport = $this->update($versionExport, $version, $export);
        $versionExport->setExport($export);

        if (isset($version["duplicatePages"]) && $version["duplicatePages"]) {
            $cdf = $this->cdfRepository->getCdfByIdExport($export->getId());

            if ($cdf) {
                $criteriaObj = new Criteria();
                $criteriaObj->where(Criteria::expr()->eq('deletedAt', null))->orderBy(["folio" => Criteria::ASC]);

                $pages = $cdf->getCdfPage()->matching($criteriaObj);

                foreach ($pages as $page) {
                    $pageDuplicate = new PageDuplicate();

                    $pageDuplicate->setName($page->getOption()->getName());
                    $pageDuplicate->setPage($page);
                    $pageDuplicate->setIdProducts($page->getIdProducts());
                    $pageDuplicate->setVersion($versionExport);
                    $pageDuplicate->setFolio($page->getFolio());

                    $versionExport->addPageDuplicate($pageDuplicate);
                }
            }
        }

        return $versionExport;
    }

    private function update(VersionExport $versionExport, array $version, Exports $export): VersionExport
    {
        $versionExport->setName($version['name']);
        if (!empty($version['groups'])) {
            $groupProjects = $this->groupRepository->findByProjectAndGroups($export->getProject()->getId(), $version['groups']);
            foreach ($groupProjects as $group) {
                $versionExport->addGroup($group);
            }
        }

        return $versionExport;
    }

    private function saveWorkflow(VersionExport $versionExport, array $steps)
    {
        try {
            foreach ($steps as $step) {
                if ($step['name'] != "workflowEnd") {
                    $versionWorkflowRepo = $this->entityManager->getRepository(VersionWorkflowOption::class);
                    $versionWorkflow = $versionWorkflowRepo->findOneBy([
                        "versionExport" => $versionExport->getId(),
                        "workflowProjectOption" => $step['workflowOptionId']
                    ]);
                    if (empty($versionWorkflow)) {
                        $versionWorkflow = new VersionWorkflowOption();
                    }
                    $versionWorkflow->setDateFin(new \DateTime($step["dateFin"]));
                    $versionWorkflow->setUsers($step["users"]);
                    $versionWorkflow->setVersionExport($versionExport);

                    $workflowProjectOptionRepo = $this->entityManager->getRepository(WorkflowProjectOptions::class);

                    $workflowProjectOption = $workflowProjectOptionRepo->findOneBy(['id' => $step['workflowOptionId']]);

                    if (!empty($workflowProjectOption)) {

                        $versionWorkflow->setWorkflowProjectOption($workflowProjectOption);
                    }
                    $versionWorkflow->setUsers($step["users"]);
                    $this->entityManager->persist($versionWorkflow);
                }
            }

            return true;
        } catch (Exception $e) {
            return $e;
        }
    }

    private function removeGroup(array $groups, VersionExport $versionExport): VersionExport
    {
        foreach ($versionExport->getGroups()->toArray() as $group) {
            if (!in_array($group->getGroup(), $groups)) {
                $versionExport->removeGroup($group);
            }
        }

        return $versionExport;
    }
}