<?php

namespace App\Controller;

use App\Entity\Amount;
use App\Entity\Institution;
use App\Entity\Participant;
use App\Entity\PhotoCource;
use App\Entity\PhotoInstitution;
use App\Entity\Rating;
use App\Entity\User;
use App\Entity\Buy;
use App\Entity\Panier;
use App\Form\UserType;
use App\Repository\BuyRepository;
use App\Repository\InstitutionRepository;
use App\Repository\ParticipantRepository;
use App\Repository\PanierRepository;
use App\Repository\RatingRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use App\Entity\Cource;
use App\Repository\CourceRepository;
use Symfony\Component\HttpFoundation\JsonResponse;

class RestController extends ApiController
{

    /**
     * @Route("/get/courses", name="allcourse")
     */
    public function index(CourceRepository $courceRepository)
    {
        $courses= $courceRepository->findAllArray();
        $allcourses=array();
        foreach ($courses as $index => $cours) {
            $cours[0]['country']=$cours['country'];
            $cours=$cours[0];
            $cours['Institution']=array(
                'id'=>$cours['Institution']['id'],
                'institutionName'=>$cours['Institution']['institutionName'],
                'description'=>$cours['Institution']['description'],
                'photos'=>$cours['Institution']['photos'],
            );
            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);
            $ratings= $this->getDoctrine()
                ->getRepository(Rating::class)
                ->findBy(['Institution' =>$cours['Institution']['id']]);
            $total=0;
            $number=0;
            foreach ($ratings as $index => $rating) {
                $number=$number+1;
                $total+=$rating->getNote();
            }
            if (($cours['limiteVal']-count($buys)) > 0)
                $cours['resetQuantity']=$cours['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;
            if($number==0)
                $cours['Institution']['totalrate']=$total;
            else
                $cours['Institution']['totalrate']=$total/$number;
            if(!empty($buys))
                $cours['nomber_achat']=count($buys);
            else
                $cours['nomber_achat']=0;

            $allcourses[]=$cours;

        }
        return $this->response($allcourses);
    }
    /**
     * @Route("/api/coursesbylimit/{start}/{limit}", name="coursesbylimit")
     */
    public function coursesbylimit($start,$limit,CourceRepository $courceRepository)
    {
        $course= $courceRepository->findAllArraycoursesbylimit($start,$limit);
        return $this->response($course);
    }
    /**
     * @Route("/get/course/{id}", name="getcourse")
     */
    public function cource($id,CourceRepository $courceRepository)
    {
        $course= $this->getDoctrine()
            ->getRepository(Cource::class)
            ->find($id);
        $ratings= $this->getDoctrine()
            ->getRepository(Rating::class)
            ->findBy(['Institution' =>$course->getInstitution()]);
        $total=0;
        $number=0;
        foreach ($ratings as $index => $rating) {
            $number=$number+1;
            $total+=$rating->getNote();
        }

        $course= $courceRepository->findArray($id);
        $course=$course[0];
        $course[0]['country']=$course['country'];
        $course=$course[0];
        $course['Institution']=array(
            'id'=>$course['Institution']['id'],
            'institutionName'=>$course['Institution']['institutionName'],
            'description'=>$course['Institution']['description'],
            'photos'=>$course['Institution']['photos'],
        );

        $buys= $this->getDoctrine()
            ->getRepository(Buy::class)
            ->findBy(['Cource' =>$course['id']]);

        if (($course['limiteVal']-count($buys)) > 0)
            $course['resetQuantity']=$course['limiteVal']-count($buys);
        else
            $course['resetQuantity']=0;

        if($number==0)
            $course['Institution']['totalrate']=$total;
        else
            $course['Institution']['totalrate']=$total/$number;
        if(!empty($buys))
            $course['nomber_achat']=count($buys);
        else
            $course['nomber_achat']=0;

        return $this->response($course);
    }
    /**
     * @Route("/api/rating/{id}/{note}", name="rating")
     */
    public function rating($id,$note,CourceRepository $courceRepository)
    {
        $institut= $this->getDoctrine()
            ->getRepository(Institution::class)
            ->find($id);
        if(empty($institut) or $note > 5 or $note < 0 )
            return $this->respondValidationError("Error params");
        $em = $this->getDoctrine()->getManager();
        $user=$this->getUser();
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $institut= $this->getDoctrine()
            ->getRepository(Institution::class)
            ->find($id);
        $rating=new Rating();
        $rating->setInstitution($institut);
        $rating->setParticipant($partipant);
        $rating->setNote($note);
        $em->persist($rating);
        $em->flush();
        return $this->response($rating);

    }
    /**
     * @Route("/api/ratingmoyen/{id}", name="ratingmoyen")
     */
    public function ratingmoyen($id,RatingRepository $ratingRepository)
    {
        $institut= $this->getDoctrine()
            ->getRepository(Institution::class)
            ->find($id);

        $ratings= $this->getDoctrine()
            ->getRepository(Rating::class)
            ->findBy(['Institution' =>$institut]);
        $total=0;
        $number=0;
        foreach ($ratings as $index => $rating) {
            $number=$number+1;
            $total+=$rating->getNote();
        }
        return $this->response(array('total'=>($total/$number),'users'=>$number));

    }
    /**
     * @Route("/get/institution/{name}", name="institution")
     */
    public function institution($name,InstitutionRepository $institutionRepository,CourceRepository $courceRepository)
    {

        $institution= $institutionRepository->findbyname($name);
        $institution=$institution[0];
        $ratings= $this->getDoctrine()
            ->getRepository(Rating::class)
            ->findBy(['Institution' =>$institution['id']]);
        $total=0;
        $number=0;
        foreach ($ratings as $index => $rating) {
            $number=$number+1;
            $total+=$rating->getNote();
        }
        if($number==0)
            $institution['totalrate']=$total;
        else
            $institution['totalrate']=$total/$number;

        $courses= $courceRepository->findAllArraybyinstitution($institution['id']);
        $dataall=array(
            'id'=>$institution['id'],
            'institutionName'=>$institution['institutionName'],
            'description'=>$institution['description'],
            'photos'=>$institution['photos'],
            'totalrate'=>$institution['totalrate'],
            "courses"=>$courses

        );

        foreach ($dataall["courses"] as $index => &$cours) {

            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);

            if (($cours['limiteVal']-count($buys)) > 0)
                $cours['resetQuantity']=$cours['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;
            if(!empty($buys))
                $cours['nomber_achat']=count($buys);
            else
                $cours['nomber_achat']=0;

            $cours['Institution']=array(
                'id'=>$institution['id'],
                'institutionName'=>$institution['institutionName'],
                'description'=>$institution['description'],
                'photos'=>$institution['photos'],
                'totalrate'=>$institution['totalrate'],
            );

        }


        return $this->response($dataall);
    }
    /**
     * @Route("/api/category/{name}", name="category")
     */
    public function category($name,CourceRepository $courceRepository)
    {
        $courses= $courceRepository->findArraycategory($name);
        $allcourses=array();
        foreach ($courses as $index => $cours) {

            $cours['Institution']=array(
                'id'=>$cours['Institution']['id'],
                'institutionName'=>$cours['Institution']['institutionName'],
                'description'=>$cours['Institution']['description'],
                'photos'=>$cours['Institution']['photos'],
            );
            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);
            $ratings= $this->getDoctrine()
                ->getRepository(Rating::class)
                ->findBy(['Institution' =>$cours['Institution']['id']]);
            $total=0;
            $number=0;
            foreach ($ratings as $index => $rating) {
                $number=$number+1;
                $total+=$rating->getNote();
            }
            if (($cours['limiteVal']-count($buys)) > 0)
                $cours['resetQuantity']=$cours['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;

            if($number==0)
                $cours['Institution']['totalrate']=$total;
            else
                $cours['Institution']['totalrate']=$total/$number;
            if(!empty($buys))
                $cours['nomber_achat']=count($buys);
            else
                $cours['nomber_achat']=0;

            $allcourses[]=$cours;

        }

        return $this->response($allcourses);
    }
    /**
     * @Route("/get/country/{name}", name="country")
     */
    public function country($name,CourceRepository $courceRepository)
    {
        $courses= $courceRepository->findArraycountry($name);
        $allcourses=array();
        foreach ($courses as $index => $cours) {

            $cours['Institution']=array(
                'id'=>$cours['Institution']['id'],
                'institutionName'=>$cours['Institution']['institutionName'],
                'description'=>$cours['Institution']['description'],
                'photos'=>$cours['Institution']['photos'],
            );
            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);
            $ratings= $this->getDoctrine()
                ->getRepository(Rating::class)
                ->findBy(['Institution' =>$cours['Institution']['id']]);
            $total=0;
            $number=0;
            foreach ($ratings as $index => $rating) {
                $number=$number+1;
                $total+=$rating->getNote();
            }
            if (($cours['limiteVal']-count($buys)) > 0)
                $cours['resetQuantity']=$cours['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;

            if($number==0)
                $cours['Institution']['totalrate']=$total;
            else
                $cours['Institution']['totalrate']=$total/$number;
            if(!empty($buys))
                $cours['nomber_achat']=count($buys);
            else
                $cours['nomber_achat']=0;

            $allcourses[]=$cours;

        }

        return $this->response($allcourses);
    }
    /**
     * @Route("/api/panier/{id}", name="paniercourse")
     */
    public function panier($id,PanierRepository $panierRepository)
    {
        $em = $this->getDoctrine()->getManager();
        $user=$this->getUser();
        $course = $this->getDoctrine()
            ->getRepository(Cource::class)
            ->find($id);
        $institution = $this->getDoctrine()
            ->getRepository(Institution::class)
            ->find($course->getInstitution());
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $panier=new Panier();

        $panier->setParticipant($partipant);
        $panier->setCource($course);
        $em->persist($panier);
        $em->flush();
        $panier= $panierRepository->findbyparticipant($partipant);
        return $this->response($panier);
    }
    /**
     * @Route("/api/getpanier", name="getpanier")
     */
    public function getpanier(PanierRepository $panierRepository)
    {
        $em = $this->getDoctrine()->getManager();
        $user=$this->getUser();
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $panier= $panierRepository->findbyparticipant($partipant);
        return $this->response($panier);
    }
    /**
     * @Route("/api/deletepanier/{id}", name="deletepanier")
     */
    public function deletepanier($id, PanierRepository $panierRepository)
    {
        $user=$this->getUser();
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $paniers= $this->getDoctrine()
            ->getRepository(Panier::class)
            ->findOneBy(['Participant' =>$partipant]);
        $entityManager = $this->getDoctrine()->getManager();
        $entityManager->remove($paniers);
        $entityManager->flush();
        $panier= $panierRepository->findbyparticipant($partipant);
        return $this->response($panier);
    }
    /**
     * @Route("/api/paiment/{id}", name="buycourse")
     */
    public function buy($id,BuyRepository $buyRepository, \Swift_Mailer $mailer)
    {
        $em = $this->getDoctrine()->getManager();
        $user=$this->getUser();
        $course = $this->getDoctrine()
            ->getRepository(Cource::class)
            ->find($id);
        if(empty($course))
            return $this->respondValidationError("Course not exist");

        $institution = $this->getDoctrine()
            ->getRepository(Institution::class)
            ->find($course->getInstitution());
        $amount = $this->getDoctrine()
            ->getRepository(Amount::class)
            ->find(1);
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $priceowner=(int) ($course->getPrice()*$amount->getPourcentage())/100;
        $buys= $this->getDoctrine()
            ->getRepository(Buy::class)
            ->findBy(['Cource' =>$course]);
		if( $course->getLimite() == true){
			if($buys && (int)$course->getLimiteVal() <= count($buys))
				return $this->respondValidationError("No Quantity");
		}
        $buyParticipant= $this->getDoctrine()
            ->getRepository(Buy::class)
            ->findBy(['Cource' =>$course->getId(),'Participant'=>$partipant]);
        if (!empty($buyParticipant))
            return $this->respondValidationError("Course already buying by this user");
        if($course->getDiscount()==true)
            $price=(int)$course->getPrice()-(((int) $course->getPrice()*$course->getDiscountVal())/100);
        else
            $price=$course->getPrice();
        $amount->setTotal($amount->getTotal()+$price);
        $amount->setEarnings($amount->getEarnings()+$priceowner);
        $em->persist($amount);
        $em->flush();
        $institution->setWallet($institution->getWallet()+($price - $priceowner));
        $em->persist($institution);
        $em->flush();
        $buy=new Buy();
        $random = sha1(random_bytes(120));
        $buy->setCle($random);
        $buy->setCource($course);
        $buy->setPrice((int)$price);
        $buy->setStatut(0);
        $buy->setParticipant($partipant);
        $em->persist($buy);
        $em->flush();
        $message = (new \Swift_Message('Drooob bill'))
            ->setFrom("contact@drooob.net")
            ->setTo($user->getEmail())
            ->setBody(
                $this->renderView(
                // templates/emails/registration.html.twig
                    'email/buy.html.twig',
                    ['token' => $random,'price'=>$price,'course'=>$course,'Institution'=>$institution,'buy'=>$buy]
                )

                ,"text/html")
        ;
        // Send the message
        $mailer->send($message);
        $course= $buyRepository->findAllArrayachat($buy->getId());
        return $this->response($course);

    }
    /**
     * @Route("/api/facture/{id}", name="facture")
     */
    public function facture($id,BuyRepository $buyRepository, \Swift_Mailer $mailer)
    {
        $user=$this->getUser();
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);
        $buy= $this->getDoctrine()
            ->getRepository(Buy::class)
            ->findOneBy(['Cource' =>$id,"Participant"=>$partipant]);
        if(empty($buy))
            return $this->respondValidationError("No bill found");
        $message = (new \Swift_Message('Drooob bill'))
            ->setFrom("contact@drooob.net")
            ->setTo($user->getEmail())
            ->setBody(
                $this->renderView(
                // templates/emails/registration.html.twig
                    'email/buy.html.twig',
                    ['token' => $buy->getCle(),'price'=>$buy->getPrice(),'course'=>$buy->getCource(),'Institution'=>$buy->getCource()->getInstitution(),'buy'=>$buy]
                )

                ,"text/html")
        ;
        $mailer->send($message);
        return $this->response($buy);

    }

    /**
     * @Route("/api/buys", name="buys")
     */
    public function buys(BuyRepository $buyRepository)
    {
        $allcourses=array();
        $user=$this->getUser();
        $partipant= $this->getDoctrine()
            ->getRepository(Participant::class)
            ->findOneBy(['user' =>$user]);

        $courses= $buyRepository->findAllArray($partipant);
        foreach ($courses as $index => $cours) {

            $cours['Cource']['Institution']=array(
                'id'=>$cours['Cource']['Institution']['id'],
                'institutionName'=>$cours['Cource']['Institution']['institutionName'],
                'description'=>$cours['Cource']['Institution']['description'],
                'photos'=>$cours['Cource']['Institution']['photos'],
            );
            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);
            $ratings= $this->getDoctrine()
                ->getRepository(Rating::class)
                ->findBy(['Institution' =>$cours['Cource']['Institution']['id']]);
            $total=0;
            $number=0;
            foreach ($ratings as $index => $rating) {
                $number=$number+1;
                $total+=$rating->getNote();
            }
            if (($cours['Cource']['limiteVal']-count($buys)) > 0)
                $cours['Cource']['resetQuantity']=$cours['Cource']['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;

            if($number==0)
                $cours['Cource']['Institution']['totalrate']=$total;
            else
                $cours['Cource']['Institution']['totalrate']=$total/$number;
            if(!empty($buys))
                $cours['Cource']['nomber_achat']=count($buys);
            else
                $cours['Cource']['nomber_achat']=0;

            $allcourses[]=$cours;

        }
        return $this->response($allcourses);
    }
    /**
     * @Route("/api/profile", name="profile")
     */
    public function profile(ParticipantRepository $participantRepository)
    {
        $user=$this->getUser();
        $participant= $participantRepository->findAllArray($user);
        return $this->response($participant);
    }
    /**
     * @Route("/api/course/photo/{id}", name="photocource")
     */
    public function photocource($id)
    {
        $photoCource= $this->getDoctrine()
            ->getRepository(PhotoCource::class)->find($id);
        return $this->response(array("photo"=>"http://blog.test/uploads/files/".$photoCource->getPath()));
    }
    /**
     * @Route("/api/institution/photo/{id}", name="photoinstitution")
     */
    public function photoinstitution($id)
    {
        $photoCource= $this->getDoctrine()
            ->getRepository(PhotoInstitution::class)->find($id);
        return $this->response(array("photo"=>"http://blog.test/uploads/files/".$photoCource->getPath()));
    }
    /**
     * @Route("/get/institutioninfo/{id}", name="institutioninfo")
     */
    public function institutioninfo($id,InstitutionRepository $institutionRepository,CourceRepository $courceRepository)
    {
        $institution= $institutionRepository->findInstitution($id);
        $institution=$institution[0];
        $ratings= $this->getDoctrine()
            ->getRepository(Rating::class)
            ->findBy(['Institution' =>$institution['id']]);
        $total=0;
        $number=0;
        foreach ($ratings as $index => $rating) {
            $number=$number+1;
            $total+=$rating->getNote();
        }
        if($number==0)
            $institution['totalrate']=$total;
        else
            $institution['totalrate']=$total/$number;

        $courses= $courceRepository->findAllArraybyinstitution($id);
        $dataall=array(
            'id'=>$institution['id'],
            'institutionName'=>$institution['institutionName'],
            'description'=>$institution['description'],
            'photos'=>$institution['photos'],
            'totalrate'=>$institution['totalrate'],
            "courses"=>$courses

        );

        foreach ($dataall["courses"] as $index => &$cours) {
            $buys= $this->getDoctrine()
                ->getRepository(Buy::class)
                ->findBy(['Cource' =>$cours['id']]);

            if (($cours['limiteVal']-count($buys)) > 0)
                $cours['resetQuantity']=$cours['limiteVal']-count($buys);
            else
                $cours['resetQuantity']=0;
            if(!empty($buys))
                $cours['nomber_achat']=count($buys);
            else
                $cours['nomber_achat']=0;

            $cours['Institution']=array(
                'id'=>$institution['id'],
                'institutionName'=>$institution['institutionName'],
                'description'=>$institution['description'],
                'photos'=>$institution['photos'],
                'totalrate'=>$institution['totalrate'],
            );

        }

        return $this->response($dataall);
    }
    /**
     * @Route("/get/getallinstitution ", name="getallinstitution")
     */
    public function getallinstitution (InstitutionRepository $institutionRepository,CourceRepository $courceRepository)
    {
        $allinstitution=array();

        $institutions= $institutionRepository->findAllInstitution();
        foreach ($institutions as $index => $institution) {

            $ratings= $this->getDoctrine()
                ->getRepository(Rating::class)
                ->findBy(['Institution' =>$institution['id']]);
            $total=0;
            $number=0;
            foreach ($ratings as $index => $rating) {
                $number=$number+1;
                $total+=$rating->getNote();
            }
            if($number==0)
                $institution['totalrate']=$total;
            else
                $institution['totalrate']=$total/$number;

            $courses= $courceRepository->findAllArraybyinstitution($institution['id']);


            $data=array(
                    'id'=>$institution['id'],
                    'institutionName'=>$institution['institutionName'],
                    'description'=>$institution['description'],
                    'photos'=>$institution['photos'],
                    'totalrate'=>$institution['totalrate'],
                    'courses'=>$courses,
        );
            $allinstitution[]=$data;
        }

        return $this->response($allinstitution);
    }

    /**
     * Returns a JSON response
     *
     * @param array $data
     * @param $status
     * @param array $headers
     * @return JsonResponse
     */
    public function response($data, $status = 200, $headers = [])
    {
        return new JsonResponse($data, $status, $headers);
    }

}