<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Form\FormError;
use Symfony\Component\HttpFoundation\JsonResponse;

use App\Entity\Tallyday as Entity;
use App\Form\TallydayType as Form;

class TallydayController extends AbstractController
{
    private $data   = "tallyday";
    private $route  = "app_tallyday";
    private $render = "Tallyday/";
    private $entity = "App:Tallyday";

    public function tallyday(Request $request)
    {
        $datenow=new \DateTime();
        $em = $this->getDoctrine()->getManager();
        $datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$datenow);

        // Calcul du temps de la journée
        $e = new  \DateTime('00:00');
        $f = clone $e;
        foreach($datas as $data) {
            $e->add($data->getTimeday());
        }
        $interval = $f->diff($e);
        $timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);

        
        return $this->render('Tallyday/tallyday.html.twig',[
            "useheader"     => true,
            "usesidebar"    => false,
            "usemonocolor"  => true,
            "maxwidth"      => true,
            $this->data."s" => $datas,
            "timeday"       => $timeday,
            "capitaltime"   => $em->getRepository("App:Tallyday")->getCapitaltime(["user"=>$this->getUser()]),
            "message"       => $request->get("message"),
        ]);
    }


    public function usertallydays(Request $request) {
        if($request->get("week")) {
            $weeknow=new \DateTime($request->get("week"));
            $weeknow->modify('monday this week');
            $weeknext=clone $weeknow;
            $weeknext->modify('monday next week');
            $weekprev=clone $weeknow;
            $weekprev->modify('monday previous week');
        }
        else {
            $weeknow=new \DateTime('monday this week');
            $weeknext=new \DateTime('monday next week');
            $weekprev=new \DateTime('monday previous week');
        }
        
        $em = $this->getDoctrine()->getManager();

        $dates=[];
        $dateend=clone $weeknow;
        $dateend->modify("sunday this week");
        
        $eweek = new  \DateTime('00:00');
        $fweek = clone $eweek;

        $datenow=clone $weeknow;
        while($datenow<=$dateend) {
            $eday = new  \DateTime('00:00');
            $fday = clone $eday;

            $isvalideuser=false;
            $isvalidemaster=false;

            $datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$datenow);
            foreach($datas as $data) {
                $eweek->add($data->getTimeday());
                $eday->add($data->getTimeday());
                $isvalideuser=$data->getValidateuser();
                $isvalidemaster=$data->getValidatemaster();
            }

            $interval = $fday->diff($eday);
            $timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
            array_push($dates,["date"=>clone $datenow,"isvalideuser"=>$isvalideuser,"isvalidemaster"=>$isvalidemaster,"timeday"=>$timeday,"tallydays"=>$datas]);
    
            $datenow->add(new \DateInterval('P1D'));
        }

        $interval = $fweek->diff($eweek);
        $timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);

        // récupérer la premier validation master
        $firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);

        return $this->render('Tallyday/user.html.twig',[
            "useheader"     => true,
            "usesidebar"    => false,
            "usemonocolor"  => false,
            "maxwidth"      => true,
            "dates"         => $dates,
            "week"          => $weeknow,
            "weeknext"      => $weeknext,
            "weekprev"      => $weekprev,
            "timeweek"      => $timeweek,
            "firstvalidate" => $firstvalidate,
            "capitaltime"   => $em->getRepository("App:Tallyday")->getCapitaltime(["user"=>$this->getUser()]),
            "message"       => $request->get("message"),
        ]);
    }

    public function mastertallydays(Request $request) {
        $dates=[];

        // Pour l'ensemble des utlisateurs
        $em = $this->getDoctrine()->getManager();
        $users = $em->getRepository("App:User")->findBy([],["firstname"=>"ASC","lastname"=>"ASC"]);
        foreach($users as $user) {
            if($user->hasRole("ROLE_USER")) {
                $dates[$user->getId()] = [
                    "id"=>$user->getId(),
                    "avatar"=>$user->getAvatar(),
                    "displayname"=>$user->getDisplayname(),
                    "capitaltime"=>$em->getRepository("App:Tallyday")->getCapitaltime(["user"=>$user]),
                    "validates"=>[],
                    "notvalidates"=>[],
                ];

                // On recherche le dernier pointage validé
                $tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"DESC"]);
                unset($datenow);
                if($tallyday) {
                    $datenow=clone $tallyday->getDateof();
                    $datenow=$datenow->modify("monday this week");
                    $dateend=clone $tallyday->getDateof();
                    $dateend->modify("sunday this week");  
                    
                    $eweek = new  \DateTime('00:00');
                    $fweek = clone $eweek;

                    while($datenow<=$dateend) {
                        $tallydays= $em->getRepository($this->entity)->findTallyday($user,$datenow);

                        $eday = new  \DateTime('00:00');
                        $fday = clone $eday;
                        foreach($tallydays as $tallyday) {
                            $eweek->add($tallyday->getTimeday());
                            $eday->add($tallyday->getTimeday());
                        }
                        $interval = $fday->diff($eday);
                        $timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);

                        $tmp= [
                            "dateof"=>clone $datenow,
                            "tallydays"=>$tallydays,
                            "timeweek"=>"00:00",
                            "timeday"=>$timeday,
                        ];
                                    
                        array_push($dates[$user->getId()]["validates"],$tmp);
                        $datenow->add(new \DateInterval('P1D'));
                    }

                    $interval = $fweek->diff($eweek);
                    $timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
                    $dates[$user->getId()]["validates"][0]["timeweek"]=$timeweek;
                }

                // On recherche le pointage à valider
                if(isset($datenow))
                    $datenow->add(new \DateInterval('P1D'));
                else 
                    $datenow=new \DateTime();

                $datenow->modify("monday this week");  
                $dateend=new \DateTime("now");
                $dateend->modify("last day of this month");  
                $dateend->modify("next sunday");
                
                $i=0;
                while($datenow<=$dateend) {
                    if($datenow->format('w')==1) {
                        $eweek = new  \DateTime('00:00');
                        $fweek = clone $eweek;
                        $entrymonday=$i;
                    }

                    $tallydays= $em->getRepository($this->entity)->findTallyday($user,$datenow);

                    $eday = new  \DateTime('00:00');
                    $fday = clone $eday;
                    foreach($tallydays as $tallyday) {
                        $eweek->add($tallyday->getTimeday());
                        $eday->add($tallyday->getTimeday());
                    }
                    $interval = $fday->diff($eday);
                    $timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);

                    $tmp= [
                        "dateof"=>clone $datenow,
                        "tallydays"=>$tallydays,
                        "timeweek"=>"00:00",
                        "timeday"=>$timeday,
                    ];

                    array_push($dates[$user->getId()]["notvalidates"],$tmp);
                    
                    if($datenow->format('w')==0) {
                        $interval = $fweek->diff($eweek);
                        $timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
                        $dates[$user->getId()]["notvalidates"][$entrymonday]["timeweek"]=$timeweek;
                    }

                    $datenow->add(new \DateInterval('P1D'));
                    $i++;
                }
               
            }
        }
        
        return $this->render('Tallyday/master.html.twig',[
            "useheader"     => true,
            "usesidebar"    => false,
            "usemonocolor"  => false,
            "maxwidth"      => false,
            "dates"         => $dates,
            "message"       => $request->get("message"),
        ]);
    }

    public function usersubmit($dateof,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $dateof=new \DateTime($dateof);

        // Pas normal = on ne peut créer une donnée sur une journée déjà validé par l'utilisateur
        $isvalideuser= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validateuser"=>true]);
        if($isvalideuser) return $this->redirectToRoute("app_tallyday_userlist");

        // Pas normal = on ne peut créer une donnée sur une journée déjà validé par master
        $isvalidemaster= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validatemaster"=>true]);
        if($isvalidemaster) return $this->redirectToRoute("app_tallyday_userlist");

        return $this->submit($this->getUser(),$dateof,"user",$request);
    } 
    
    public function mastersubmit($userid,$dateof,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $dateof=new \DateTime($dateof);

        // Pas normal = on ne peut créer un enregistrement sur un utilisateur inexistant
        $user = $em->getRepository("App:User")->find($userid);
        if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");

        // Pas normal = on ne peut créer une donnée sur une journée déjà validé par master
        $isvalidemaster= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validatemaster"=>true]);
        if($isvalidemaster) return $this->redirectToRoute("app_tallyday_masterlist");

        return $this->submit($user,$dateof,"master",$request);
    } 

    public function submit($user,$dateof,$access,Request $request)
    {
        $em = $this->getDoctrine()->getManager();

        // Récupérer la premier validation master
        $firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"ASC"]);
        
        // Pas normal = on ne peut créer une donnée antérieur à la première validation master
        if($firstvalidate && $firstvalidate->getDateof() > $dateof) return $this->redirectToRoute("app_tallyday_".$mode."list");
        
        $data = new Entity();
        $data->setUser($user);
        $data->setDateof($dateof);
        $data->setValidateuser(false);
        $data->setValidatemaster(false);
        $data->setIsbreakday(false);

        // Création du formulaire
        $form = $this->createForm(Form::class,$data);

        // Récupération des data du formulaire
        $form->handleRequest($request);

        // Set le jour au différent horaire
        if($data->getDatestart()) {
            $datestart= clone $data->getDateof();
            $datestart->setTime($data->getDatestart()->format("H"),$data->getDatestart()->format("i"));
            $data->setDatestart($datestart);
        } else $data->setDatestart(null);

        if($data->getDateend()) {
            $dateend= clone $data->getDateof();
            $dateend->setTime($data->getDateend()->format("H"),$data->getDateend()->format("i"));
            $data->setDateend($dateend);
        } else $data->setDateend(null);

        // Sur erreur
        $this->getErrorForm($data->getId(),$form,$request,$data,"update");

        // Sur validation
        if ($form->get('submit')->isClicked() && $form->isValid()) {  
            $data = $form->getData();  


            $em->persist($data);
            $em->flush();

            // Retour à la liste
            if($access=="master") 
                return $this->redirectToRoute("app_tallyday_masterlist");
            else 
                return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
        }
        
        // Affichage du formulaire
        return $this->render($this->render.'edit.html.twig', [
            "useheader"         => true,
            "usesidebar"        => false,
            "usemonocolor"      => true,  
            "maxwidth"          => true,
            $this->data         => $data,
            "week"              => $request->get("week"),
            "access"            => $access,
            "mode"              => "submit",
            'form'              => $form->createView()
        ]);
    }    
    
    public function userupdate($id,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->find($id);

        // Pas normal = on ne peut modifier un enregistrement inexistant
        if(!$data) return $this->redirectToRoute("app_tallyday_userlist");
        
        // Pas normal = un user ne peut modifier que ses propres données
        if($data->getUser()!=$this->getUser()) return $this->redirectToRoute("app_tallyday_userlist");

        // Pas normal = un user ne peut modifier une données validées
        if($data->getValidateuser()||$data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_userlist");

        return $this->update($data,"user",$request);
    } 
    
    public function masterupdate($id,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->find($id);

        // Pas normal = on ne peut modifier un enregistrement inexistant
        if(!$data) return $this->redirectToRoute("app_tallyday_masterlist");

        // Pas normal = un master ne peut modifier une données validées
        if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_masterlist");

        return $this->update($data,"master",$request);
    } 

    public function update($data,$access,Request $request)
    {
        $em = $this->getDoctrine()->getManager();

        // Récupérer la premier validation master
        $firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$data->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
        
        // Pas normal = on ne peut modifier une donnée antérieur à la première validation master
        if($firstvalidate && $firstvalidate->getDateof() > $data->getDateof()) return $this->redirectToRoute("app_tallyday_".$mode."list");

        // Création du formulaire
        $form = $this->createForm(Form::class,$data);

        // Récupération des data du formulaire
        $form->handleRequest($request);

        // Set le jour au différent horaire
        if($data->getDatestart()) {
            $datestart= clone $data->getDateof();
            $datestart->setTime($data->getDatestart()->format("H"),$data->getDatestart()->format("i"));
            $data->setDatestart($datestart);
        } else $data->setDatestart(null);

        if($data->getDateend()) {
            $dateend= clone $data->getDateof();
            $dateend->setTime($data->getDateend()->format("H"),$data->getDateend()->format("i"));
            $data->setDateend($dateend);
        } else $data->setDateend(null);

        // Sur erreur
        $this->getErrorForm($data->getId(),$form,$request,$data,"update");

        // Sur validation
        if ($form->get('submit')->isClicked() && $form->isValid()) {  
            $data = $form->getData();  


            $em->persist($data);
            $em->flush();

            // Retour à la liste
            if($access=="master") 
                return $this->redirectToRoute("app_tallyday_masterlist");
            else 
                return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
        }
        
        // Affichage du formulaire
        return $this->render($this->render.'edit.html.twig', [
            "useheader"         => true,
            "usesidebar"        => false,
            "usemonocolor"      => true,  
            "maxwidth"          => true,
            $this->data         => $data,
            "week"              => $request->get("week"),
            "access"            => $access,
            "mode"              => "update",
            'form'              => $form->createView()
        ]);
    } 

    
    public function userdelete($id,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->find($id);

        // Pas normal = on ne peut supprimer un enregistrement inexistant
        if(!$data) return $this->redirectToRoute("app_tallyday_userlist");
        
        // Pas normal = un user ne peut supprimer que ses propres données
        if($data->getUser()!=$this->getUser()) return $this->redirectToRoute("app_tallyday_userlist");

        // Pas normal = un user ne peut supprimer une données validées
        if($data->getValidateuser()||$data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_userlist");

        return $this->delete($data,"user",$request);
    } 
    
    public function masterdelete($id,Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->find($id);

        // Pas normal = on ne peut supprimer un enregistrement inexistant
        if(!$data) return $this->redirectToRoute("app_tallyday_masterlist");

        // Pas normal = un master ne peut modifier une données validées
        if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_masterlist");

        return $this->delete($data,"master",$request);
    } 

    public function delete($data,$access,Request $request)
    {
        $em = $this->getDoctrine()->getManager();

        // Récupérer la premier validation master
        $firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$data->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
        
        // Pas normal = on ne peut supprimer une donnée antérieur à la première validation master
        if($firstvalidate && $firstvalidate->getDateof() > $data->getDateof()) return $this->redirectToRoute("app_tallyday_".$mode."list");

        $em->remove($data);
        $em->flush();

        // Retour à la liste
        if($access=="master") 
            return $this->redirectToRoute("app_tallyday_masterlist");
        else 
            return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
        
    }

    public function uservalidate($dateof, Request $request) {
        $em = $this->getDoctrine()->getManager();
        $dateof=new \DateTime($dateof);

        // récupérer la premier validation master
        $firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
        
        // Pas normal
        if($firstvalidate && $firstvalidate->getDateof() > $dateof) return $this->redirectToRoute("app_tallyday");

        // Récupérer les créneaux
        $datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$dateof);

        // Si aucun enregistrement on initialise le pointage sur la journée à vide
        if(!$datas) {
            $data = new Entity();
            $data->setUser($this->getUser());

            $data->setDateof($dateof);  
            $data->setValidateuser(true);
            $data->setValidatemaster(false);
            $data->setIsbreakday(false);

            $em->persist($data);
            $em->flush();                       
        }
        
        foreach($datas as $data) {
            if($data->getDatestart()&&!$data->getDateend()) {
                if($request->get("from")=="list")
                    return $this->redirectToRoute("app_tallyday_userlist",["message"=>"Impossible de valider, il vous manque des dates de fin"]);
                else 
                    return $this->redirectToRoute("app_tallyday",["message"=>"Impossible de valider, il vous manque des dates de fin"]);          
            }
            
            // Validation
            $data->setValidateuser(true);
            $em->persist($data);
            $em->flush(); 
        }

        if($request->get("from")=="list")
            return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
        else 
            return $this->redirectToRoute("app_tallyday");
    }

    public function mastervalidate($userid, $weekday, Request $request) {
        $em = $this->getDoctrine()->getManager();
        $user=$em->getRepository("App:User")->find($userid);

        // Pas normal
        if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");

        // Premiere passe de controle
        $datenow=new \DateTime($weekday);
        $dateend=clone $datenow;
        $dateend->modify("next sunday");
        
        while($datenow<=$dateend) {
            $datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);
            
            // Si aucun enregistrement on initialise le pointage sur la journée à vide
            if(!$datas) {
                $data = new Entity();
                $data->setUser($this->getUser());

                $data->setDateof($datenow);  
                $data->setValidateuser(false);
                $data->setValidatemaster(true);
                $data->setIsbreakday(false);

                $em->persist($data);
                $em->flush();                       
            }

            foreach($datas as $data) {
                if($data->getDatestart()&&!$data->getDateend()) {
                    return new JsonResponse([
                        'success' => false,
                        'message' => "Impossible de valider, il manque des dates de fin",
                    ]);
                }
            }
                        
            $datenow->add(new \DateInterval('P1D'));
        }  
       
        // Seconde passe de validation
        $datenow=new \DateTime($weekday);
        $dateend=clone $datenow;
        $dateend->modify("next sunday");
        
        while($datenow<=$dateend) {
            $datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);

            // Validation
            foreach($datas as $data) {
                $data->setValidatemaster(true);
                $em->persist($data);
            }

            $datenow->add(new \DateInterval('P1D'));
        }  

        $em->flush();  
        return new JsonResponse(['success' => true]);
    }

    public function userdevalidate($dateof, Request $request) {
        $em = $this->getDoctrine()->getManager();
        $dateof=new \DateTime($dateof);

        $em = $this->getDoctrine()->getManager();
        $datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$dateof);

        // Pas normal = on ne peut pas dévalider qqchose qui n'existe pas
        if(!$datas) return $this->redirectToRoute("app_tallyday");
        
        // Pas normal = l'utilisateur ne peut pas dévalider une validation master
        foreach($datas as $data) {
            if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday");
        }

        foreach($datas as $data) {
            if($data->getDatestart()&&$data->getDateend()) {
                // Dévalidation
                $data->setValidateuser(false);
                $em->persist($data);
                $em->flush(); 
            }
            else {
                $em->remove($data);
                $em->flush();                
            }
        }

        if($request->get("from")=="list")
            return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
        else 
            return $this->redirectToRoute("app_tallyday");
    }   
    
    public function masterdevalidate($userid, $weekday, Request $request) {
        $em = $this->getDoctrine()->getManager();
        $user=$em->getRepository("App:User")->find($userid);


        // Pas normal = on ne peut dévalider un utilisateur qui n'existe pas
        if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");

        // On recherche le dernier pointage validé
        $tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"DESC"]);

        // Pas normal = on ne peut dévalider qq qui n'existe pas
        if(!$tallyday) return $this->redirectToRoute("app_tallyday_masterlist");

        $datenow=new \DateTime($weekday);
        $dateend=clone $datenow;
        $dateend->modify("next sunday");

        // Pas normal = on peut dévalider que la dernière validation
        if($datenow!=$tallyday->getDateof()->modify("previous monday"))  return $this->redirectToRoute("app_tallyday_masterlist");

        while($datenow<=$dateend) {
            $datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);
            foreach($datas as $data) {
                if($data->getDatestart()&&$data->getDateend()) {
                    // Dévalidation
                    $data->setValidatemaster(false);
                    $em->persist($data);
                    $em->flush(); 
                }
                else {
                    $em->remove($data);
                    $em->flush();                
                }
            }

            $datenow->add(new \DateInterval('P1D'));
        }            
        $em->flush();
                
        return $this->redirectToRoute("app_tallyday_masterlist");
    }     

    public function start() {
        $em = $this->getDoctrine()->getManager();

        $datenow=new \DateTime("now");
        $datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );


        $data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"datestart"=>$datenow]);
        if(!$data) {
            $data = new Entity();
            $data->setDateof(new \DateTime("now"));
            $data->setUser($this->getUser());
            $data->setValidateuser(false);
            $data->setValidatemaster(false);
            $data->setIsbreakday(false);
            $data->setDatestart($datenow);
        }

        // Pas normal = Vérifier qu'il n'y ait pas de chevauchement de créneaux
        if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
            return $this->redirectToRoute("app_tallyday",["message"=>"Incohérance dans votre pointage"]);
        }
        
        $em->persist($data);
        $em->flush();             

        return $this->redirectToRoute("app_tallyday");

    }

    public function end() {
        $em = $this->getDoctrine()->getManager();

        // On recherche le dernier pointage de la journée
        $datenow=new \DateTime("now");
        $datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
        $data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$datenow],["datestart"=>"DESC"]);

        // Pas normal = on devrait avoir au minimum un tally si on veut faire un pointage de fin
        if(!$data)
            return $this->redirectToRoute("app_tallyday");

        // Pas normal = si on pointe la fin il faut forcement que le dernier pointage soit sans date de fin et avec une date de début
        if($data->getDateend()||!$data->getDatestart())
            return $this->redirectToRoute("app_tallyday");

        // Pas normal = Vérifier qu'il n'y ait pas de chevauchement de créneaux
        if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
            return $this->redirectToRoute("app_tallyday",["message"=>"Incohérance dans votre pointage"]);
        }            

        $data->setDateend($datenow);
        $em->persist($data);
        $em->flush(); 

        return $this->redirectToRoute("app_tallyday");
    }

    public function startpm() {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->findTallyday($this->getUser(),new \DateTime("now"));

        // Pas normal
        if(!$data)
            return $this->redirectToRoute("app_tallyday");
        
        $datenow=new \DateTime("now");
        $datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
        $data->setDatestartpm($datenow);
        $em->persist($data);
        $em->flush(); 
        return $this->redirectToRoute("app_tallyday");
    }

    public function endpm() {
        $em = $this->getDoctrine()->getManager();
        $data = $em->getRepository($this->entity)->findTallyday($this->getUser(),new \DateTime("now"));

        // Pas normal
        if(!$data)
            return $this->redirectToRoute("app_tallyday");
        
        $datenow=new \DateTime("now");
        $datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
        $data->setDateendpm($datenow);
        $em->persist($data);
        $em->flush(); 
        return $this->redirectToRoute("app_tallyday");
    }
    
    protected function getErrorForm($id,$form,$request,$data,$mode) {
        $em = $this->getDoctrine()->getManager();

        if ($form->get('submit')->isClicked()) {
            // date début < date fin
            if($data->getDatestart()&&$data->getDateend()) {
                if($data->getDatestart()>$data->getDateend())
                    $form->addError(new FormError("Date de début de matin doit être inférieure à la date de fin de matin"));          
            }

            // Vérifier qu'il n'y ait pas de chevauchement de créneaux
            if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
                $form->addError(new FormError("Votre créneau est incohérant par rapport aux autre créneaux"));
            }
        }

        if ($form->get('submit')->isClicked() && !$form->isValid()) {
            $this->get('session')->getFlashBag()->clear();

            $errors = $form->getErrors();
            foreach( $errors as $error ) {
                $request->getSession()->getFlashBag()->add("error", $error->getMessage());
            }
        }
    }      
    
}