<?php

namespace App\Controller;

use App\Entity\Goal;
use App\Entity\Target;
use App\Entity\Action;
use App\Entity\Activity;
use App\Entity\Notation;
use App\Entity\Nature;
use App\Entity\Ministry;
use App\Entity\Commune;
use App\Entity\Appreciation;
use App\Form\ActionType;
use App\Form\ActivityType;
use App\Form\EvaluationType;
use App\Form\MinistryOnlySelType;
use App\Form\MinistryCommuneSelType;
use App\Form\NotationType;
use App\Form\NotationModelType;
use App\Form\NotationCollectionModelType;
use App\Form\Model\NotationModel;
use App\Form\Model\NotationCollectionModel;
use App\Form\Model\ActivityCollectionModel;
use App\Service\SettingsManager;
use App\Utils\PlanUtils;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;


class PlanController extends AbstractController
{

    function getWeighting($ministry, $settingsManager) {
        $weighting = 100;
        if ($ministry) {
            $ministryType = $ministry->getMtype();
            if ( $ministryType == 'strategie' ) {
                $weighting += $settingsManager->get('ministry_weight'); 
            }
        }
        return $weighting;
    }

    function getRates($type) {
        $natureRepository = $this->getDoctrine()->getRepository(Nature::class);
        if ($type == 'minRate')
            return $natureRepository->findMinRate();
        if ($type == 'maxRate')
            return $natureRepository->findMaxRate();
        if ($type == 'allRate')
            return json_encode($natureRepository->findAllRate());
    }

    function getSensitivity($notation, $minRate, $weighting) {
        $sensitivity = $notation->getTargetRate();
        if ($notation->getNature()->getRate() > $minRate) {
            $sensitivity = ($notation->getTargetRate() - ((100 - $notation->getLocationRate()) / 10)) * ($weighting / 100);
        }
        return $sensitivity;
    }

    /**
     * @Route("/app/actions", name="app_actions")
     */
    public function actionsAction(Request $request)
    {
        $actions = [];
        $entite=null;

        if($request->getSession()->get('_ministry')){
            $ministry = $this->getDoctrine()->getRepository(Ministry::class)->findOneBy(['id' => $request->getSession()->get('_ministry')]);
            $entite=$ministry;
            $actions = $this->getDoctrine()
                ->getRepository(Action::class)
                ->createQueryBuilder('a')
                ->select('a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.ministry = :ministry')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('ministry',$ministry)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
        }

        if($request->getSession()->get('_commune')){
            $commune = $this->getDoctrine()->getRepository(Commune::class)->findOneBy(['id' => $request->getSession()->get('_commune')]);
            $entite=$commune;
            $actions = $this->getDoctrine()
                ->getRepository(Action::class)
                ->createQueryBuilder('a')
                ->select('a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.commune = :commune')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('commune',$commune)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
        }

        $form = $this->createForm(MinistryCommuneSelType::class, null, [
            'sessionYear' => $request->getSession()->get('_year'),
            'sessionMinistry' => $request->getSession()->get('_ministry'),
            'sessionCommune' => $request->getSession()->get('_commune'),
            'sessionDepartement' => $request->getSession()->get('_departement'),
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            if($request->getSession()->get('_departement')){
                $type='commune';
            }else{
                $type = $form->get('type')->getData();
            }
            $entite = $form->get('entite')->getData();
            if($type=='ministere' && $entite){
                $ministry = $this->getDoctrine()->getRepository(Ministry::class)->findOneBy(['id' => $entite->getId()]);
                $actions = $this->getDoctrine()
                ->getRepository(Action::class)
                ->createQueryBuilder('a')
                ->select('a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.ministry = :ministry')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('ministry',$ministry)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
            }else if($type=='commune' && $entite){
                $commune = $this->getDoctrine()->getRepository(Commune::class)->findOneBy(['id' => $entite->getId()]);
                $actions = $this->getDoctrine()
                ->getRepository(Action::class)
                ->createQueryBuilder('a')
                ->select('a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.commune = :commune')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('commune',$commune)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
            }
        }

        return $this->render('plan/action_list.html.twig', [
            'actions' => $actions,
            'form' => $form->createView(),
            'entite' => $entite
        ]);
    }

    /**
     * @Route("/app/actions/new", name="app_action_new")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER", "ROLE_DPP", "ROLE_FOCAL"})
    public function newActionAction(Request $request)
    {
        $action = new Action();

        $form = $this->createForm(ActionType::class, $action, [
            'sessionYear' => $request->getSession()->get('_year'),
            'sessionMinistry' => $request->getSession()->get('_ministry'),
            'sessionCommune' => $request->getSession()->get('_commune'),
            'defaultType' => null,
            'defaultEntite' => null
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $action = $form->getData();
            $action->setYear($request->getSession()->get('_year'));
            $action->setCreatedBy($this->getUser());
            $action->setValidatedBy($this->getUser());
            $action->setValidated(true);

            $this->getDoctrine()->getManagerForClass(Action::class)->persist($action);
            $this->getDoctrine()->getManagerForClass(Action::class)->flush();


            $this->addFlash('success', 'Action ajoutée avec succès');

            return $this->redirectToRoute('app_actions');
        }

        return $this->render('plan/action_form.html.twig', [
            'action' => $action,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/actions/{id}", name="app_action")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER", "ROLE_DPP", "ROLE_FOCAL"})
    public function actionAction($id, Request $request)
    {
        $action = $this->getDoctrine()
            ->getRepository(Action::class)
            ->findOneBy(['id' => $id]);
        
        if($action->getProgramm()->getCommune()){
            $form = $this->createForm(ActionType::class, $action, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'defaultType' => 'commune',
                'defaultEntite' => $action->getProgramm()->getCommune(),
            ]);
        }
        if($action->getProgramm()->getMinistry()){
            $form = $this->createForm(ActionType::class, $action, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'defaultType' => 'ministere',
                'defaultEntite' => $action->getProgramm()->getMinistry(),
            ]);
        }

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $action = $form->getData();
            $action->setUpdatedBy($this->getUser());

            $this->getDoctrine()->getManagerForClass(Action::class)->flush();

            $this->addFlash('success', 'Action modifiée avec succès');

            return $this->redirectToRoute('app_actions');
        }

        return $this->render('plan/action_form.html.twig', [
            'action' => $action,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/activities", name="app_activities")
     */
    public function activitiesAction(Request $request)
    {
        $activities = [];
        $entite=null;

        if($request->getSession()->get('_ministry')){
            $ministry = $this->getDoctrine()->getRepository(Ministry::class)->findOneBy(['id' => $request->getSession()->get('_ministry')]);
            $entite=$ministry;
            $activities = $this->getDoctrine()
                ->getRepository(Activity::class)
                ->createQueryBuilder('y')
                ->select('y')
                ->join('y.action' ,'a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.ministry = :ministry')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('ministry',$ministry)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
        }

        if($request->getSession()->get('_commune')){
            $commune = $this->getDoctrine()->getRepository(Commune::class)->findOneBy(['id' => $request->getSession()->get('_commune')]);
            $entite=$commune;
            $activities = $this->getDoctrine()
                ->getRepository(Activity::class)
                ->createQueryBuilder('y')
                ->select('y')
                ->join('y.action' ,'a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.commune = :commune')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('commune',$commune)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
        }

        $form = $this->createForm(MinistryCommuneSelType::class, null, [
            'sessionYear' => $request->getSession()->get('_year'),
            'sessionMinistry' => $request->getSession()->get('_ministry'),
            'sessionCommune' => $request->getSession()->get('_commune'),
            'sessionDepartement' => $request->getSession()->get('_departement'),
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            if($request->getSession()->get('_departement')){
                $type='commune';
            }else{
                $type = $form->get('type')->getData();
            }
            $entite = $form->get('entite')->getData();
            if($type=='ministere' && $entite){
                $ministry = $this->getDoctrine()->getRepository(Ministry::class)->findOneBy(['id' => $entite->getId()]);
                $activities = $this->getDoctrine()
                ->getRepository(Activity::class)
                ->createQueryBuilder('y')
                ->select('y')
                ->join('y.action' ,'a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.ministry = :ministry')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('ministry',$ministry)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
            }
            if($type=='commune' && $entite){
                $commune = $this->getDoctrine()->getRepository(Commune::class)->findOneBy(['id' => $entite->getId()]);
                $activities = $this->getDoctrine()
                ->getRepository(Activity::class)
                ->createQueryBuilder('y')
                ->select('y')
                ->join('y.action' ,'a')
                ->join('a.programm' ,'p')
                ->andWhere('a.year = :year')
                ->andWhere('p.commune = :commune')
                ->andWhere('a.validated = :validated')
                ->setParameter('year', $request->getSession()->get('_year'))
                ->setParameter('commune',$commune)
                ->setParameter('validated', true)
                ->getQuery()->getResult();
            }
            
        }

        return $this->render('plan/activity_list.html.twig', [
            'activities' => $activities,
            'form' => $form->createView(),
            'entite' => $entite
        ]);
    }

    /**
     * @Route("/app/activities/new", name="app_activity_new")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER", "ROLE_DPP", "ROLE_FOCAL"})
    public function newActivityAction(Request $request)
    {
        $activity = new Activity();

        $form = $this->createForm(ActivityType::class, $activity, [
            'sessionYear' => $request->getSession()->get('_year'),
            'sessionMinistry' => $request->getSession()->get('_ministry'),
            'sessionCommune' => $request->getSession()->get('_commune'),
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $activity = $form->getData();
            $activity->setYear($request->getSession()->get('_year'));
            $activity->setCreatedBy($this->getUser());
            $activity->setValidatedBy($this->getUser());
            $activity->setValidated(true);

            $activity->getAction()->setTreated(PlanUtils::checkActionTreated($activity->getAction()));

            $this->getDoctrine()->getManagerForClass(Activity::class)->persist($activity);
            $this->getDoctrine()->getManagerForClass(Activity::class)->flush();

            $this->addFlash('success', 'Activité ajoutée avec succès');
            
            return $this->redirectToRoute('app_activity_new');
        }

        return $this->render('plan/activity_form.html.twig', [
            'activity' => $activity,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/activities/{id}", name="app_activity")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER", "ROLE_DPP", "ROLE_FOCAL"})
    public function activityAction($id, Request $request)
    {
        $activity = $this->getDoctrine()
            ->getRepository(Activity::class)
            ->findOneBy(['id' => $id]);
        $programm = $activity->getAction()->getProgramm();
        
        if($activity && $activity->getDirection()->getCommune()){
            $form = $this->createForm(ActivityType::class, $activity, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'defaultType' => 'commune',
                'defaultEntite' => $activity->getDirection()->getCommune(),
                'defaultProgramm' => $programm,
            ]);
        }else if($activity &&  $activity->getDirection()->getMinistry()){
            $form = $this->createForm(ActivityType::class, $activity, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'defaultType' =>'ministere',
                'defaultEntite' => $activity->getDirection()->getMinistry(),
                'defaultProgramm' => $programm,
            ]);
        }

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $activity = $form->getData();
            $activity->setUpdatedBy($this->getUser());

            $this->getDoctrine()->getManagerForClass(Activity::class)->flush();

            $this->addFlash('success', 'Activité modifiée avec succès');

            return $this->redirectToRoute('app_activities');
        }

        return $this->render('plan/activity_form.html.twig', [
            'activity' => $activity,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/notation/{id}", name="app_notations", defaults={"id"=0})
     */
    //* @IsGranted({"ROLE_ADMIN", "ROLE_MANAGER", "ROLE_DDD"})
    public function notationAction($id=0, Request $request, SettingsManager $settingsManager)
    {
        /*if (!($this->isGranted('ROLE_MANAGER') or $this->isGranted('ROLE_DDD'))) {
            return $this->redirectToRoute('app_evaluation', ['id' => 0]);
        }*/

        $show = !($this->isGranted('ROLE_MANAGER') or $this->isGranted('ROLE_DDD'));

        $collection = $request->request->get('notation_collection_model');
        $postId = isset($collection['action']) ? $collection['action'] : null;
        if ($postId and ($postId != $id)) {
            return $this->redirectToRoute('app_notations', ['id' => $postId]);
        }

        $ministry = null;
        $commune = null;
        $activities = [];
        $action = $this->getDoctrine()
            ->getRepository(Action::class)
            ->findOneBy(['id' => (int)$id]);

        $notationCollection = New NotationCollectionModel($action);

        if ($action) {
            $limit = 0;
            foreach ($action->getActivities() as $activity) {
                if (($activity->getValidated() == true) and ($activity->getTreated() == false)) {
                    if ($limit < 200) {
                        $model = New NotationModel();
                        $model->activity = $activity;
                        $notationCollection->addNotationModel($model);

                        $activities[] = $activity;
                    }
                    $limit += 1;
                }
                
            }
            $ministry = $action->getProgramm()->getMinistry();
            $commune = $action->getProgramm()->getCommune();
        }

        if($commune){
            $form = $this->createForm(NotationCollectionModelType::class, $notationCollection, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'sessionDepartement' => $request->getSession()->get('_departement'),
                'commune' => $commune,
                'grouping' => 'arrondissement',
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
                'show' => $show,
            ]);
        }else{
            $form = $this->createForm(NotationCollectionModelType::class, $notationCollection, [
                'sessionYear' => $request->getSession()->get('_year'),
                'sessionMinistry' => $request->getSession()->get('_ministry'),
                'sessionCommune' => $request->getSession()->get('_commune'),
                'sessionDepartement' => $request->getSession()->get('_departement'),
                'commune' => null,
                'enabledPoste' => $ministry ? $ministry->getPoste() : false,
                'grouping' => $ministry ? $ministry->getGrouping() : 'department',
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
                'show' => $show,
            ]);
        }
        
        
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            
            $notationModels = $form->get('notationModels')->getData();

            foreach ($notationModels as $model) {
;                
                if ($model->treated == true) {
                    $notation = New Notation();
                    $notation->setActivity($model->activity);
                    $notation->setNature($model->nature);
                    $notation->setTarget($model->target);
                    if($model->communes){
                        $notation->setNbOfLocation(count($model->communes));
                        foreach ($model->communes as $commune) {
                            $notation->addCommune($commune);
                        }
                        foreach ($model->postes as $poste) {
                            $notation->addPoste($poste);
                        }
                    }else if($model->arrondissements){
                        $notation->setNbOfLocation(count($model->arrondissements));
                        foreach ($model->arrondissements as $arrondissement) {
                            $notation->addArrondissement($arrondissement);
                        }
                    }
                    $notation->setTargetRate($model->targetRate);
                    $notation->setLocationRate($model->locationRate);
                    $notation->setSensitivity($model->sensitivity);
                    $appreciation = $this->getDoctrine()
                        ->getRepository(Appreciation::class)
                        ->findOneByValue($model->sensitivity);
                    $notation->setAppreciation($appreciation);

                    foreach ($model->indicators as $indicator) {
                        $notation->addIndicator($indicator);
                    }
                    
                    $this->getDoctrine()->getManagerForClass(Notation::class)->persist($notation);

                    $activity = $model->activity;
                    $activity->setTreated(true);
                }
            }
            $action->setTreated(PlanUtils::checkActionTreated($action));

            $this->getDoctrine()->getManagerForClass(Notation::class)->flush();
            
            return $this->redirectToRoute('app_notations', ['id'=>$action->getId()]);
        }
        
        return $this->render('plan/notation_form.html.twig', [
            'activities' => $activities,
            'form' => $form->createView(),
            'actionId' => $action ? $action->getId() : 0,
            'grouping' => $commune ? 'arrondissement' : 'department',
        ]);
    }

    /**
     * @Route("/app/evaluation/{id}", name="app_evaluation")
     */
    //* @IsGranted({"ROLE_ADMIN", "ROLE_MANAGER"})
    public function planEvaluationAction($id, Request $request)
    {
        $notations = [];
        $appreciation = '---';
        $sensitivity = 0;
        $amount = 0;

        $evaluation = $request->request->get('evaluation');
        $postId = isset($evaluation['action']) ? $evaluation['action'] : null;
        if ($postId and ($postId != $id)) {
            return $this->redirectToRoute('app_evaluation', ['id' => $postId]);
        }

        $action = $this->getDoctrine()
            ->getRepository(Action::class)
            ->findOneBy(['id' => (int)$id]);

        
        $commune = $action ? $action->getProgramm()->getCommune() : null;

        $notationCollection = New NotationCollectionModel($action);

        if ($action) {
            foreach ($action->getActivities() as $activity) {
                if ($activity->getValidated() == true) {
                    foreach ($activity->getNotations() as $notation) {
                        $notations[] = $notation;
                    }
                }
            }
        }

        $form = $this->createForm(EvaluationType::class, $notationCollection, [
            'sessionYear' => $request->getSession()->get('_year'),
            'sessionMinistry' => $request->getSession()->get('_ministry'),
            'sessionCommune' => $request->getSession()->get('_commune'),
            'sessionDepartement' => $request->getSession()->get('_departement'),
            'defaultEntite' => $commune
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            //$ministry = $form->get('ministry')->getData();
            //$programm = $form->get('programm')->getData();
            //$action = $form->get('action')->getData();
            
        }

        return $this->render('plan/evaluation_list.html.twig', [
            'notations' => $notations,
            'form' => $form->createView(),
            'actionId' => $action ? $action->getId() : 0
        ]);
    }

    /**
     * @Route("/app/notation/duplicate/{id}", name="app_notation_duplicate")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER"})
    public function duplicateNotationAction($id, Request $request, SettingsManager $settingsManager)
    {
        $activity = $this->getDoctrine()
            ->getRepository(Notation::class)
            ->findOneBy(['id' => $id])
            ->getActivity();

        $notation = new Notation();
        $notation->setActivity($activity);

        $ministry = $notation->getActivity()->getAction()->getProgramm()->getMinistry();
        $commune = $notation->getActivity()->getAction()->getProgramm()->getCommune();

        if($commune){
            $form = $this->createForm(NotationType::class, $notation, [
                'enabledPoste' => false,
                'grouping' => 'arrondissement',
                'commune' => $commune,
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
            ]);
        }else{
            $form = $this->createForm(NotationType::class, $notation, [
                'enabledPoste' => $ministry ? $ministry->getPoste() : false,
                'grouping' => $ministry ? $ministry->getGrouping() : 'department',
                'commune' => null,
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
            ]);
        }

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $notation = $form->getData();
            $treated = $form->get('treated')->getData();
            
            if ($treated == true) {
                $appreciation = $this->getDoctrine()
                    ->getRepository(Appreciation::class)
                    ->findOneByValue($notation->getSensitivity());
                $notation->setAppreciation($appreciation);
                $notation->setNbOfLocation(count($notation->getCommunes()));
                $notation->setDuplicated(true);

                $this->getDoctrine()->getManagerForClass(Notation::class)->persist($notation);
            }

            $this->getDoctrine()->getManagerForClass(Notation::class)->flush();

            $actionId = $notation->getActivity()->getAction()->getId();
            return $this->redirectToRoute('app_evaluation', ['id' => $actionId]);
        }

        return $this->render('plan/evaluation_form.html.twig', [
            'notation' => $notation,
            'grouping' => $commune ? 'arrondissement' : 'department',
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/notation/edit/{id}", name="app_notation_edit")
     * 
     */
	 //@IsGranted({"ROLE_ADMIN", "ROLE_MANAGER"})
	 
    public function editNotationAction($id, Request $request, SettingsManager $settingsManager)
    {
        $notation = $this->getDoctrine()
            ->getRepository(Notation::class)
            ->findOneBy(['id' => $id]);

        $ministry = $notation->getActivity()->getAction()->getProgramm()->getMinistry();
        $commune = $notation->getActivity()->getAction()->getProgramm()->getCommune();

        if($commune){
            $grouping='arrondissement';
            $form = $this->createForm(NotationType::class, $notation, [
                'enabledPoste' => false,
                'grouping' => 'arrondissement',
                'commune' => $commune,
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
            ]);
        }else{
            $grouping=$ministry ? $ministry->getGrouping() : 'department';
            $form = $this->createForm(NotationType::class, $notation, [
                'enabledPoste' => $ministry ? $ministry->getPoste() : false,
                'grouping' => $ministry ? $ministry->getGrouping() : 'department',
                'commune' => null,
                'minRate' => $this->getRates('minRate'),
                'maxRate' => $this->getRates('maxRate'),
                'allRate' => $this->getRates('allRate'),  
                'weighting' => $this->getWeighting($ministry, $settingsManager),
            ]);
        }

        /*$form = $this->createForm(NotationType::class, $notation, [
            'enabledPoste' => $ministry ? $ministry->getPoste() : false,
            'grouping' => $ministry ? $ministry->getGrouping() : 'department',
            'minRate' => $this->getRates('minRate'),
            'maxRate' => $this->getRates('maxRate'),
            'allRate' => $this->getRates('allRate'),  
            'weighting' => $this->getWeighting($ministry, $settingsManager),
        ]);*/

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $notation = $form->getData();
            $treated = $form->get('treated')->getData();
            
            if ($treated == true) {
                $appreciation = $this->getDoctrine()
                    ->getRepository(Appreciation::class)
                    ->findOneByValue($notation->getSensitivity());
                $notation->setAppreciation($appreciation);
                $notation->setNbOfLocation(count($notation->getCommunes()));

                $this->getDoctrine()->getManagerForClass(Notation::class)->persist($notation);
            }

            $this->getDoctrine()->getManagerForClass(Notation::class)->flush();

            $actionId = $notation->getActivity()->getAction()->getId();
            return $this->redirectToRoute('app_evaluation', ['id' => $actionId]);
        }

        return $this->render('plan/evaluation_form.html.twig', [
            'notation' => $notation,
            'grouping' =>$grouping,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/app/notation/delete/{id}", name="app_notation_delete")
     */
    public function deleteNotationtionAction($id, Request $request)
    {
        $notation = $this->getDoctrine()
            ->getRepository(Notation::class)
            ->findOneBy(['id' => $id]);

        $this->getDoctrine()->getManagerForClass(Notation::class)->remove($notation);
        $this->getDoctrine()->getManagerForClass(Notation::class)->flush();

        $actionId = $notation->getActivity()->getAction()->getId();
        return $this->redirectToRoute('app_evaluation', ['id' => $actionId]);
    }
}