<?php

/**
 * Chill is a software for social workers
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Chill\MainBundle\Controller;

use Chill\MainBundle\Entity\Workflow\EntityWorkflow;
use Chill\MainBundle\Entity\Workflow\EntityWorkflowComment;
use Chill\MainBundle\Form\EntityWorkflowCommentType;
use Chill\MainBundle\Form\WorkflowStepType;
use Chill\MainBundle\Pagination\PaginatorFactory;
use Chill\MainBundle\Repository\Workflow\EntityWorkflowRepository;
use Chill\MainBundle\Security\Authorization\EntityWorkflowVoter;
use Chill\MainBundle\Workflow\EntityWorkflowManager;
use Chill\MainBundle\Workflow\Validator\StepDestValid;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Symfony\Component\Workflow\Registry;
use Symfony\Component\Workflow\TransitionBlocker;
use Symfony\Contracts\Translation\TranslatorInterface;
use function count;

class WorkflowController extends AbstractController
{
    private EntityManagerInterface $entityManager;

    private EntityWorkflowManager $entityWorkflowManager;

    private EntityWorkflowRepository $entityWorkflowRepository;

    private PaginatorFactory $paginatorFactory;

    private Registry $registry;

    private TranslatorInterface $translator;

    private ValidatorInterface $validator;

    public function __construct(EntityWorkflowManager $entityWorkflowManager, EntityWorkflowRepository $entityWorkflowRepository, ValidatorInterface $validator, PaginatorFactory $paginatorFactory, Registry $registry, EntityManagerInterface $entityManager, TranslatorInterface $translator)
    {
        $this->entityWorkflowManager = $entityWorkflowManager;
        $this->entityWorkflowRepository = $entityWorkflowRepository;
        $this->validator = $validator;
        $this->paginatorFactory = $paginatorFactory;
        $this->registry = $registry;
        $this->entityManager = $entityManager;
        $this->translator = $translator;
    }

    /**
     * @Route("/{_locale}/main/workflow/create", name="chill_main_workflow_create")
     */
    public function create(Request $request): Response
    {
        if (!$request->query->has('entityClass')) {
            throw new BadRequestHttpException('Missing entityClass parameter');
        }

        if (!$request->query->has('entityId')) {
            throw new BadRequestHttpException('missing entityId parameter');
        }

        if (!$request->query->has('workflow')) {
            throw new BadRequestHttpException('missing workflow parameter');
        }

        $entityWorkflow = new EntityWorkflow();
        $entityWorkflow
            ->setRelatedEntityClass($request->query->get('entityClass'))
            ->setRelatedEntityId($request->query->getInt('entityId'))
            ->setWorkflowName($request->query->get('workflow'));

        $errors = $this->validator->validate($entityWorkflow, null, ['creation']);

        if (count($errors) > 0) {
            $msg = [];

            foreach ($errors as $error) {
                /** @var \Symfony\Component\Validator\ConstraintViolationInterface $error */
                $msg[] = $error->getMessage();
            }

            return new Response(implode("\n", $msg), Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        $this->denyAccessUnlessGranted(EntityWorkflowVoter::CREATE, $entityWorkflow);

        $em = $this->getDoctrine()->getManager();
        $em->persist($entityWorkflow);
        $em->flush();

        return $this->redirectToRoute('chill_main_workflow_show', ['id' => $entityWorkflow->getId()]);
    }

    /**
     * @Route("/{_locale}/main/workflow/list/dest", name="chill_main_workflow_list_dest")
     */
    public function myWorkflowsDest(Request $request): Response
    {
        $this->denyAccessUnlessGranted('IS_AUTHENTICATED_REMEMBERED');

        $total = $this->entityWorkflowRepository->countByDest($this->getUser());
        $paginator = $this->paginatorFactory->create($total);

        $workflows = $this->entityWorkflowRepository->findByDest(
            $this->getUser(),
            ['createdAt' => 'DESC'],
            $paginator->getItemsPerPage(),
            $paginator->getCurrentPageFirstItemNumber()
        );

        return $this->render(
            '@ChillMain/Workflow/list.html.twig',
            [
                'workflows' => $this->buildHandler($workflows),
                'paginator' => $paginator,
                'step' => 'dest',
            ]
        );
    }

    /**
     * @Route("/{_locale}/main/workflow/list/subscribed", name="chill_main_workflow_list_subscribed")
     */
    public function myWorkflowsSubscribed(Request $request): Response
    {
        $this->denyAccessUnlessGranted('IS_AUTHENTICATED_REMEMBERED');

        $total = $this->entityWorkflowRepository->countBySubscriber($this->getUser());
        $paginator = $this->paginatorFactory->create($total);

        $workflows = $this->entityWorkflowRepository->findBySubscriber(
            $this->getUser(),
            ['createdAt' => 'DESC'],
            $paginator->getItemsPerPage(),
            $paginator->getCurrentPageFirstItemNumber()
        );

        return $this->render(
            '@ChillMain/Workflow/list.html.twig',
            [
                'workflows' => $this->buildHandler($workflows),
                'paginator' => $paginator,
                'step' => 'subscribed',
            ]
        );
    }

    /**
     * @Route("/{_locale}/main/workflow/{id}/show", name="chill_main_workflow_show")
     */
    public function show(EntityWorkflow $entityWorkflow, Request $request): Response
    {
        $this->denyAccessUnlessGranted(EntityWorkflowVoter::SEE, $entityWorkflow);

        $handler = $this->entityWorkflowManager->getHandler($entityWorkflow);
        $workflow = $this->registry->get($entityWorkflow, $entityWorkflow->getWorkflowName());
        $errors = [];

        if (count($workflow->getEnabledTransitions($entityWorkflow)) > 0) {
            // possible transition
            $transitionForm = $this->createForm(
                WorkflowStepType::class,
                $entityWorkflow->getCurrentStep(),
                ['transition' => true, 'entity_workflow' => $entityWorkflow]
            );

            $transitionForm->handleRequest($request);

            if ($transitionForm->isSubmitted() && $transitionForm->isValid()) {
                if (!$workflow->can($entityWorkflow, $transition = $transitionForm['transition']->getData()->getName())) {
                    $blockers = $workflow->buildTransitionBlockerList($entityWorkflow, $transition);
                    $msgs = array_map(function (TransitionBlocker $tb) {
                        return $this->translator->trans(
                            $tb->getMessage(),
                            $tb->getParameters()
                        );
                    }, iterator_to_array($blockers));

                    throw $this->createAccessDeniedException(
                        sprintf(
                            "not allowed to apply transition {$transition}: %s",
                            implode(', ', $msgs)
                        )
                    );
                }

                $workflow->apply($entityWorkflow, $transition);

                foreach ($transitionForm['future_dest_users']->getData() as $user) {
                    $entityWorkflow->getCurrentStep()->addDestUser($user);
                }

                $errors = $this->validator->validate(
                    $entityWorkflow->getCurrentStep(),
                    new StepDestValid()
                );

                if (count($errors) === 0) {
                    $this->entityManager->flush();

                    return $this->redirectToRoute('chill_main_workflow_show', ['id' => $entityWorkflow->getId()]);
                }

                return new Response((string) $errors, Response::HTTP_UNPROCESSABLE_ENTITY);
            }

            if ($transitionForm->isSubmitted() && !$transitionForm->isValid()) {
                $this->addFlash('error', $this->translator->trans('This form contains errors'));
            }
        }

        /*
        $commentForm = $this->createForm(EntityWorkflowCommentType::class, $newComment = new EntityWorkflowComment());
        $commentForm->handleRequest($request);

        if ($commentForm->isSubmitted() && $commentForm->isValid()) {
            $this->entityManager->persist($newComment);
            $this->entityManager->flush();

            $this->addFlash('success', $this->translator->trans('workflow.Comment added'));

            return $this->redirectToRoute('chill_main_workflow_show', ['id' => $entityWorkflow->getId()]);
        } elseif ($commentForm->isSubmitted() && !$commentForm->isValid()) {
            $this->addFlash('error', $this->translator->trans('This form contains errors'));
        }
         */

        return $this->render(
            '@ChillMain/Workflow/index.html.twig',
            [
                'handler_template' => $handler->getTemplate($entityWorkflow),
                'handler_template_title' => $handler->getTemplateTitle($entityWorkflow),
                'handler_template_data' => $handler->getTemplateData($entityWorkflow),
                'transition_form' => isset($transitionForm) ? $transitionForm->createView() : null,
                'entity_workflow' => $entityWorkflow,
                'transition_form_errors' => $errors,
                //'comment_form' => $commentForm->createView(),
            ]
        );
    }

    private function buildHandler(array $workflows): array
    {
        $lines = [];

        foreach ($workflows as $workflow) {
            $handler = $this->entityWorkflowManager->getHandler($workflow);
            $lines[] = [
                'handler' => $handler,
                'entity_workflow' => $workflow,
            ];
        }

        return $lines;
    }
}