<?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 Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;

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";
    
    private $appKernel;
    private $knpSnappy;

    public function __construct(KernelInterface $appKernel,\Knp\Snappy\Pdf $knpSnappy)
    {
        $this->appKernel = $appKernel;
        $this->knpSnappy = $knpSnappy;
    }

    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($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($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),
                    "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 premier pointage non validé
                $tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>false],["dateof"=>"ASC"]);
                if($tallyday) 
                    $datenow= $tallyday->getDateof();
                else 
                    $datenow=new \DateTime("now");
                    

                $datenow->modify("monday this week");  
                $dateend=new \DateTime("now");
                $dateend->add(new \DateInterval("P14D"));  
                $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($user);

                $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 mastermonth($monthof, Request $request) {
        // On calcul le nombre de jour ouvrable dans le mois
        $datenow=new \DateTime($monthof."01");
        $dateend=clone $datenow;
        $dateend->modify("last day of this month");

        $nbopendays=0;
        while ($datenow <= $dateend) {
            // jour différent de samedi et dimanche
            if($datenow->format("w")!=0&&$datenow->format("w")!=6)
                $nbopendays++;

            $datenow->add(new \DateInterval('P1D'));
        }
        $timetowork=($nbopendays*7).":00";

        // Pour l'ensemble des utlisateurs
        $em = $this->getDoctrine()->getManager();
        $users = $em->getRepository("App:User")->findBy([],["firstname"=>"ASC","lastname"=>"ASC"]);
        $dates=[];

        foreach($users as $user) {
            if($user->hasRole("ROLE_USER")) {
                $dates[$user->getId()] = [
                    "id"=>$user->getId(),
                    "avatar"=>$user->getAvatar(),
                    "displayname"=>$user->getDisplayname(),
                    "timemonth"=>"00:00",
                    "validates"=>[],
                ];

                $datenow=new \DateTime($monthof."01");
                $dateend=clone $datenow;
                $dateend->modify("last day of this month");

                $nextmonth=clone $datenow;
                $nextmonth->modify("first day of next month");

                $prevmonth=clone $datenow;
                $prevmonth->modify("first day of previous month");

                $emonth = new  \DateTime('00:00');
                $fmonth = clone $emonth;

                while($datenow<=$dateend) {
                    $eday = new  \DateTime('00:00');
                    $fday = clone $eday;
        
                    $datas = $em->getRepository($this->entity)->findTallyday($user,$datenow);
                    foreach($datas as $data) {
                        $emonth->add($data->getTimeday());
                        $eday->add($data->getTimeday());
                    }
        
                    $interval = $fday->diff($eday);
                    $timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
                    
                    array_push($dates[$user->getId()]["validates"],[
                        "dateof"=>clone $datenow,
                        "timeday"=>$timeday,
                        "tallydays"=>$datas
                    ]);
            
                    $datenow->add(new \DateInterval('P1D'));
                }

                $interval = $fmonth->diff($emonth);
                $timemonth = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
                $dates[$user->getId()]["timemonth"]=$timemonth;
            }
        }

        if($request->get('type')=="pdf") {
            $rootdir = $this->appKernel->getProjectDir()."/uploads";
            $filename="Rapport-".$dateend->format("Ym").".pdf";
            $fileloc=$rootdir."/".$filename;

            $fs = new Filesystem();
            $fs->remove(array($fileloc));    

            $render = $this->renderView('Tallyday/month.html.twig',[
                "useheader"     => false,
                "usesidebar"    => false,
                "usemonocolor"  => false,
                "maxwidth"      => false,
                "monthof"       => $dateend,
                "nextmonth"     => $nextmonth->format("Ym"),
                "prevmonth"     => $prevmonth->format("Ym"),
                "timetowork"    => $timetowork,
                "dates"         => $dates,
                "fgprint"       => true,
                "message"       => $request->get("message"),
            ]);

            $appWeburl=$this->getParameter("appWeburl");
            $appAlias=$this->getParameter("appAlias");

            $render=str_replace("/$appAlias/","https://$appWeburl/$appAlias/",$render);
            //dump($render);

            $this->knpSnappy->generateFromHtml($render,$fileloc);
            return $this->file($fileloc); 
        }
        else {
            return $this->render('Tallyday/month.html.twig',[
                "useheader"     => true,
                "usesidebar"    => false,
                "usemonocolor"  => false,
                "maxwidth"      => false,
                "monthof"       => $dateend,
                "nextmonth"     => $nextmonth->format("Ym"),
                "prevmonth"     => $prevmonth->format("Ym"),
                "timetowork"    => $timetowork,
                "dates"         => $dates,
                "fgprint"       => false,
                "message"       => $request->get("message"),
            ]);
        }
    }

    public function masterexport() {
        $em = $this->getDoctrine()->getManager();
        $rootdir = $this->appKernel->getProjectDir()."/uploads";

        $dateof=new \DateTime();
        $filename="Export-".$dateof->format("Ymd").".csv";

        $fs = new Filesystem();
        $fs->mkdir($rootdir);
        $csvh = fopen($rootdir."/".$filename, 'w');
        $d = ';'; // this is the default but i like to be explicit
        $e = '"'; // this is the default but i like to be explicit

        $csvh = fopen($rootdir."/".$filename, 'w');

        $csv=["Utilisateur",utf8_decode("Début"),"Fin","Temps",utf8_decode("Libellé")];
        fputcsv($csvh, $csv, $d, $e);

        $datas = $em->getRepository($this->entity)->findBy([],["user"=>"ASC","dateof"=>"ASC"]);
        foreach($datas as $data) {
            if($data->getDatestart() || $data->getDateend()) {
                $csv=[
                    utf8_decode($data->getUser()->getDisplayname()),
                    $data->getDatestart()->format("d/m/Y H:i"),
                    ($data->getDateend()?$data->getDateend()->format("d/m/Y H:i"):""),
                    $data->getTimedayformatted(),
                    utf8_decode(($data->getName()?$data->getName():""))
                    
                ];
                fputcsv($csvh, $csv, $d, $e);
            }
        }

        $response = new BinaryFileResponse($rootdir."/".$filename);
        $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT);
        return $response;         
    }

    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 userrecalcul() {
        $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 );     
        $datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),clone $datenow);
        
        // Cumul des temps de la journée
        $e = new  \DateTime('00:00');
        $f = clone $e;
        foreach($datas as $data) {
            $e->add($data->getTimeday());
        }

        // On recherche le dernier pointage de la journée non terminé et on simule le créneau avec la date du moment
        $data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$datenow],["datestart"=>"DESC"]);
        if($data&&$data->getDatestart()&&!$data->getDateend()) {
            $interval2 = $datenow->diff($data->getDatestart());
            $e->add($interval2);
        }

        // Calcul de temps global de la journée = réel + simulé
        $interval = $e->diff($f);
        $timeday = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);

        // On récupère le capital
        $capital=$em->getRepository("App:Tallyday")->getCapitaltimeinterval($this->getUser());
        $e = new  \DateTime('00:00');
        

        // Si la journée n'est finalisé on ajoute le créneau simulé
        if($data&&$data->getDatestart()&&!$data->getDateend()) {
            $f = new  \DateTime('00:00');
            $f->add($interval);
            $f->sub(new \DateInterval('PT7H'));
            $f->add($capital);

            $interval = $e->diff($f);
            $newcapital = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);        
    
        }
        // Si la journée n'est pas encore validé : on ajoute la journée à la simulation
        else if($data && (!$data->getValidateuser()||!$data->getValidateuser())) {
            $interval=$em->getRepository("App:Tallyday")->getCapitaltimeinterval($this->getUser(),true);
            $newcapital = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);        
        }


        return new JsonResponse([
            'success' => true,
            'tosimulatetime' => ($data&&$data->getDatestart()&&!$data->getDateend()),
            'timeday' => $timeday,
            'tosimulatecapital' => ($data&&(!$data->getValidateuser()||!$data->getValidateuser())),
            'capital' => $newcapital,
        ]);
    }

    
    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());
            }
        }
    }      
    
}