<?php

namespace App\Controller\Poll;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use App\Entity\LecturerApprovedActivities;
use App\Entity\TmmvLecturer;
use App\Entity\MeovLecturer;
use App\Entity\KtvLecturer;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
use App\Entity\Poll\PollGroup;
use Symfony\Component\HttpFoundation\Request;
use App\Entity\Poll\AnswerRow;
use App\Entity\Poll\AnswerField;
use App\Entity\Poll\Answer;
use App\Entity\Poll\Poll;
use App\Entity\Poll\Summary;
use App\Entity\Lecturer;
use App\Service\ProcessDatesValidation;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Doctrine\ORM\EntityManagerInterface;
use App\Service\DbDataFilter;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;

/**
* SurveyController controller.
*
* @Security("is_granted('ROLE_LECTURER')
   or is_granted('ROLE_DEPARTMENT_HEAD')
   or is_granted('ROLE_ACADEMIC_UNIT_PROHEAD')
  ")
*/
#[Route(path: 'poll')]
class SurveyController extends AbstractController
{
    public function __construct(
        private readonly ProcessDatesValidation $dateValidator,
        private readonly EntityManagerInterface $em,
        private readonly DbDataFilter $dbDataFilter,
        private readonly AuthorizationCheckerInterface $authorizationChecker,
    ) {
        if (!$this->dateValidator->isActiveLecturerPoll()) {
            throw new AccessDeniedHttpException("Jūs negalite pasiekti šio turinio");
        }

        if ($this->authorizationChecker->isGranted('ROLE_ACADEMIC_UNIT_PROHEAD')) {
            $this->dbDataFilter->enableOnlyAcademicUnitFilter();
            return;
        }

        if ($this->authorizationChecker->isGranted('ROLE_DEPARTMENT_HEAD')) {
            $this->dbDataFilter->enableOnlyDepartmentFilter();
            return;
        }

        if ($this->authorizationChecker->isGranted('ROLE_LECTURER')) {
            $this->dbDataFilter->enableOnlyLecturerFilter();
            return;
        }

        throw new AccessDeniedHttpException("Jūsų naudotojas negali pasiekti šio turinio");
    }

    /**
     * Lists all academicGroup entities.
     *
     * @Method("GET")
     */
    #[Route(path: '/', name: 'poll_lecturer_index')]
    public function indexAction()
    {


        $lecturerTmmv = $this->em->getRepository(TmmvLecturer::class)->getLecturerTmmvPlanHoursGroupByLecturer();
        $lecturerMeov = $this->em->getRepository(MeovLecturer::class)->getLecturerMeovPlanHoursGroupByLecturer();
        $lecturerKtv = $this->em->getRepository(KtvLecturer::class)->getLecturerKtvPlanHoursGroupByLecturer();

        $lectApprovals = $this->em->getRepository(LecturerApprovedActivities::class)->getListByLecturerId();

        return $this->render('poll/index.html.twig', [
            'lecturers' => $this->em->getRepository(Lecturer::class)->findAll(),
            'lecturerStatuses' => $this->em->getRepository(Summary::class)->findAllByLecturer(),
            'lecturerTmmv' => $lecturerTmmv,
            'lecturerMeov' => $lecturerMeov,
            'lecturerKtv' => $lecturerKtv,
            'lectApprovals' => $lectApprovals,
        ]);
    }

    /**
     * Lists all academicGroup entities.
     *
     * @Method("GET")
     */
    #[Route(path: '/poll/{lecturer}/{page}', name: 'poll_index')]
    public function indexPollAction(Lecturer $lecturer, $page = 1)
    {
        $isCompleted = false;
        $isCompletedReview = false;

        $pollGroups = $this->em->getRepository(PollGroup::class)->findByPage($page);

        $maxPage = $this->em->getRepository(PollGroup::class)->findMaxPage();
        $maxPage++;
        $pers = round(($page - 1) * 100 / ($maxPage));
//        if ($this->em->getFilters()->isEnabled('lecturer_filter')) {
////            $this->em->getFilters()->disable('lecturer_filter');
//        }
        $answerRowsByPoll = $this->em->getRepository(Poll::class)->findByLecturerPage($lecturer->getId(), $page);
        $suggestionsTmmvByPoll = $this->em->getRepository(Poll::class)->findTmmvByLecturerPage($lecturer->getId(), $page);
        $suggestionsMeovByPoll = $this->em->getRepository(Poll::class)->findMeovByLecturerPage($lecturer->getId(), $page);
        $suggestionsKtvByPoll = $this->em->getRepository(Poll::class)->findKtvByLecturerPage($lecturer->getId(), $page);
        $answersByRows = $this->em->getRepository(Answer::class)->findByLecturerPage($lecturer->getId(), $page);


//        dump($suggestionsMeovByPoll);
//dump($pollGroups); die;

        //can fill only user lecturer
        $userEmail = $this->getUser()->getEmail();
        if ($lecturer->getEmail() != $userEmail) {
            $isCompleted = true;
        }

        $summary = $this->em->getRepository(Summary::class)->findOneByLecturer($lecturer);

        if ($summary) {
            $dateCompleted = $summary->getDateCompleted();
            if ($dateCompleted) {
                $pers = 100;
                $isCompleted = true;
            }
            $dateCompletedReview = $summary->getDateCompletedReview();
            if ($dateCompletedReview) {
                $pers = 100;
                $isCompletedReview = true;
            }
        }

        return $this->render('poll/poll.html.twig', [
                    'page' => $page,
                    'maxPage' => $maxPage,
                    'proc' => $pers,
                    'pollGroups' => $pollGroups,
                    'lecturer' => $lecturer,
                    'answerRows' => $answerRowsByPoll,
                    'answersByRows' => json_encode($answersByRows),
                    'suggestionsTmmvByPoll' => $suggestionsTmmvByPoll,
                    'suggestionsMeovByPoll' => $suggestionsMeovByPoll,
                    'suggestionsKtvByPoll' => $suggestionsKtvByPoll,
                    'isCompleted' => false, // @todo change this
                    'isCompletedReview' => $isCompletedReview,
        ]);
    }

    /**
     * Creates entity.
     *
     * @Method({"POST"})
     */
    #[Route(path: '/save', name: 'poll_save')]
    public function savePollAnswerAction(Request $request)
    {

        $page = $request->request->get('page');
        $lecturerId = $request->request->get('lecturer_id');
        $pollId = $request->request->get('poll_id');
        $answerRowId = $request->request->get('answer_row_id_' . $pollId);
        $fieldValues = $request->request->all()['field'];
        $appendRowId = $request->request->get('append_row_id_' . $pollId);
        $appendType = $request->request->get('append_type_' . $pollId);



        $lecturer = $this->em->getRepository(Lecturer::class)->find($lecturerId);

        if ($request->request->has('delete')) {
            $answerRow = $this->em->getRepository(AnswerRow::class)->find($answerRowId);
            $answers = $this->em->getRepository(Answer::class)->findByAnswerRow($answerRow);
            foreach ($answers as $answer) {
                $this->em->remove($answer);
            }

            $this->em->remove($answerRow);
            $this->em->flush();
            return $this->redirectToRoute('poll_index', ['lecturer' => $lecturer->getId(), 'page' => $page]);
        }

        if (!empty($appendRowId) && !empty($appendType)) {
            if ($appendType === 'tmmv') {
                $appendObject = $this->em->getRepository(TmmvLecturer::class)->find($appendRowId);
            }
            if ($appendType === 'meov') {
                $appendObject = $this->em->getRepository(MeovLecturer::class)->find($appendRowId);
            }
            if ($appendType === 'ktv') {
                $appendObject = $this->em->getRepository(KtvLecturer::class)->find($appendRowId);
            }
        }

        $poll = $this->em->getRepository(Poll::class)->find($pollId);

        if (empty($answerRowId)) {
            $answerRow = new AnswerRow();
            $answerRow->setPoll($poll);
            $answerRow->setLecturer($lecturer);
            $this->em->persist($answerRow);

            foreach ($fieldValues as $answerFieldId => $answerValue) {
                $answer = new Answer();
                $answer->setAnswerRow($answerRow);

                $answerField = $this->em->getRepository(AnswerField::class)->find($answerFieldId);
                $answer->setAnswerField($answerField);
                $answer->setName($answerValue);

                $this->em->persist($answer);
            }
            if (!empty($appendObject)) {
                $appendObject->setPoll($pollId);
                $this->em->persist($appendObject);
            }
        } else {
            $answerRow = $this->em->getRepository(AnswerRow::class)->find($answerRowId);

            foreach ($fieldValues as $answerFieldId => $answerValue) {
                $answerField = $this->em->getRepository(AnswerField::class)->find($answerFieldId);
                $answer = $this->em->getRepository(Answer::class)->findOneBy(['answerField' => $answerField, 'answerRow' => $answerRow]);
                $answer->setName($answerValue);

                $this->em->persist($answer);
            }
        }

        $this->em->flush();

        return $this->redirectToRoute('poll_index', ['lecturer' => $lecturer->getId(), 'page' => $page]);
    }
}