<?php

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

namespace App\Infrastructure\Workflow;

use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\Adapter\Query\Workflow\ConfigurationQueryInterface;
use App\Application\View\Workflow\StatusView;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Adapter\ProjectRepositoryInterface;
use App\Domain\Adapter\Workflow\TransitionsRepositoryInterface;
use App\Domain\Entity\Page;
use App\Domain\Entity\PageDuplicate;
use App\Domain\Entity\Project;
use Doctrine\ORM\EntityManagerInterface;
use Exception;
use Symfony\Component\Workflow\DefinitionBuilder;
use Symfony\Component\Workflow\MarkingStore\MethodMarkingStore;
use Symfony\Component\Workflow\Registry;
use Symfony\Component\Workflow\SupportStrategy\InstanceOfSupportStrategy;
use Symfony\Component\Workflow\Transition;
use Symfony\Component\Workflow\Workflow;

class RegistryCustom
{
    /** @var ProjectRepositoryInterface */
    private $projectRepository;

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

    /** @var TransitionsRepositoryInterface */
    private $transitionRepo;

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

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

    /** @var ConfigurationQueryInterface */
    private $configuration;

    public function __construct(ConfigurationQueryInterface $configuration, ProjectRepositoryInterface $projectRepository, PageRepositoryInterface $pageRepository, StoryQueryInterface $story, EntityManagerInterface $entityManager, TransitionsRepositoryInterface $transitionRepo)
    {
        $this->projectRepository = $projectRepository;
        $this->pageRepository = $pageRepository;
        $this->transitionRepo = $transitionRepo;
        $this->story = $story;
        $this->entityManager = $entityManager;
        $this->configuration = $configuration;
    }
    public function build(int $config_id, $entity): Registry
    {
        $configuration = $this->configuration->load($config_id);

        $transitions = $configuration['transitions'];
        $definitionBuilder = new DefinitionBuilder();
        $definition = $definitionBuilder
            ->addPlaces($configuration['places'])
        ;

        foreach ($transitions as $key => $transition) {
            $definition->addTransition(new Transition($key, $transition['from'], $transition['to']));
        }
        $endBuild = $definition->build();
        $marking = new MethodMarkingStore(true, $configuration['marking_store']['arguments'][0]);
        $workflow = new Workflow($endBuild, $marking, null, $configuration['name']);

        $registry = new Registry();
        $registry->addWorkflow($workflow, new InstanceOfSupportStrategy($entity));

        return $registry;
    }

    public function display($module): array
    {
        return $this->configuration->display($module);
    }

    public function applyStatus(StatusView $view, $configuration): array
    {
        try {
            $workflow = $this->build($configuration, Project::class)->get(new Project());
            $project = $this->projectRepository->findById($view->project);
            if ($project) {
                $can = false;
                if ($workflow->can($project, $view->transition)) {
                    $workflow->apply($project, $view->transition);
                    $can = true;
                }

                if ($can) {
                    $this->projectRepository->changePlace($project->getId(), $project->getCurrentPlace());
                    $arrayReturn = ['currentPlace' => $project->getCurrentPlace()];
                } else {
                    $arrayReturn = ['error' => "Erreur lors du changement d'étape"];
                }
            } else {
                $arrayReturn = ['error' => "Erreur lors du changement d'étape"];
            }

            return $arrayReturn;
        } catch (Exception $exception) {
            return ['error' => "Erreur lors du changement d'étape"];
        }
    }

    public function applyStatusMultiple(StatusView $view, $configuration, $projects): bool
    {
        try {
            $workflow = $this->build($configuration, Project::class)->get(new Project());
            $can = false;
            $ids = [];
            foreach ($projects as $project) {
                if ($workflow->can($project, $view->transition)) {
                    $workflow->apply($project, $view->transition);
                    $ids[] = $project->getId();
                    $can = true;
                }
            }

            if ($can) {
                $this->projectRepository->changePlaceMultiple(implode(',', $ids), $projects[0]->getCurrentPlace());
            }

            return true;
        } catch (Exception $exception) {
            return false;
        }
    }

    public function applyStatusPage(StatusView $view, $configuration_id, ?int $pageDuplicateId, string $note = ""): array
    {
        try {
            $arrayReturn = [];
            $workflow = $this->build($configuration_id, Page::class)->get(new Page());
            $page = $this->pageRepository->read($view->project);
            $transition = $this->transitionRepo->findByKey($view->transition);
            if(!empty($pageDuplicateId)){
                $pageDuplicate = $this->entityManager->getRepository(PageDuplicate::class)->findOneBy(["id" => $pageDuplicateId]);

                if(!empty($pageDuplicate)){
                    $dupliPageId = $this->verification($workflow, $view, $pageDuplicate);

                    if(count($dupliPageId) > 0) {


                        $this->entityManager->persist($pageDuplicate);
                        $this->entityManager->flush();
                        $scenario = 'Step_valid';
    
                        if (strpos($view->transition, 'Reject')) {
                            $scenario = 'Step_reject';
                        }

                        $stepStory = $pageDuplicate->getCurrentPlace();
                
                        if (false === strpos($transition->getName(), '_Reject')) {
                            $stepStory = $transition->getStartPlace()->getKey();

                        }
    
                        $this->story->execute($scenario, ['PageId'=>$page->getId(), "PageDuplicateId"=> $pageDuplicate->getId(), 'step'=>$stepStory, 'transition'=> $view->transition, "note" => $note], $pageDuplicate->getId(), get_class($pageDuplicate), 0);
                        
    
                        $arrayReturn = ['currentPlace' => $pageDuplicate->getCurrentPlace(), 'error' => null];
                    } else {
                        $arrayReturn = ['currentPlace' => null, 'error' => "Erreur lors du changement d'étape"];
                    }
                }
            } else {

                if ($page) {
                    $idValues = $this->verification($workflow, $view, $page);
    
                    if (count($idValues) > 0) {
                        $entity = $this->pageRepository->changePlace(implode(',', $idValues), $page->getCurrentPlace());
                        $scenario = 'Step_valid';
    
                        if (strpos($view->transition, 'Reject')) {
                            $scenario = 'Step_reject';
                        }
                        if ($entity) {

                            $stepStory = $page->getCurrentPlace();
                
                            if (false === strpos($transition->getName(), '_Reject')) {
                                $stepStory = $transition->getStartPlace()->getKey();

                            }

                            $this->story->execute($scenario, ['PageId'=>$page->getId(), 'step'=>$stepStory, 'transition'=> $view->transition, "note" => $note], $page->getId(), get_class($page), 0);

                        }
    
                        $arrayReturn = ['currentPlace' => $page->getCurrentPlace(), 'error' => null];
                    }
                } else {
                    $arrayReturn = ['currentPlace' => null, 'error' => "Erreur lors du changement d'étape"];
                }
            }
            return $arrayReturn;
        } catch (Exception $exception) {
            return [];
        }
    }

    public function verification($workflow, $view, $page): array
    {
        $idValues = [];
        if ($workflow->can($page, $view->transition)) {
            $workflow->apply($page, $view->transition);
            $idValues[] = $page->getId();
        }

        return $idValues;
    }
}