<?php

namespace App\Controller;

use Doctrine\DBAL\Exception;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use App\Entity\LecturerApprovedActivities;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
use App\Entity\Lecturer;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\Form;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use App\Service\FileUploader;
use App\Entity\LecturerPosition;
use App\Entity\Department;
use App\Entity\User;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;

/**
 * Lecturer controller.
 *
 * @Security("is_granted('ROLE_PERSONAL_DEPARTMENT')")
 */
#[Route(path: 'lecturer')]
class LecturerController extends AbstractController
{
    public function __construct(
        private readonly EntityManagerInterface $em,
    ) {
        if ($this->em->getFilters()->isEnabled('active_lecturer')) {
            $this->em->getFilters()->disable('active_lecturer');
        }
    }

    #[Route(path: '/', name: 'lecturer_index')]
    public function indexAction()
    {
        $lecturers = $this->em->getRepository(Lecturer::class)->findAll();

        return $this->render('lecturer/index.html.twig', array(
            'lecturers' => $lecturers,
        ));
    }

    #[Route(path: '/createUser/{lecturer}', name: 'lecturer_create_user')]
    public function createUserAction(Lecturer $lecturer, UserPasswordHasherInterface $encoder)
    {
        $user = $this->em->getRepository(User::class)->loadUserByUsername($lecturer->getEmail());
        if (empty($user)) {
            $user = new User();
            $user->setIsActive(true);
            $user->setUsername($lecturer->getEmail());
            $user->setEmail($lecturer->getEmail());
            $user->setRole('ROLE_LECTURER');
            $user->setRoles(['ROLE_LECTURER']);
            $user->setPassword($encoder->hashPassword($user, $user->getPassword()));
            $this->em->persist($user);
            $this->em->flush();
        }


        return $this->redirect($this->generateUrl('lecturer_index'));
    }

    #[Route(path: '/new', name: 'lecturer_new')]
    public function newAction(Request $request)
    {
        $lecturer = new Lecturer();
        $form = $this->createForm('App\Form\LecturerType', $lecturer);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $this->em->persist($lecturer);
            $this->em->flush();

            return $this->redirectToRoute('lecturer_index', array('id' => $lecturer->getId()));
        }

        return $this->render('lecturer/new.html.twig', array(
                    'lecturer' => $lecturer,
                    'form' => $form->createView(),
        ));
    }

    #[Route(path: '/{id}/edit', name: 'lecturer_edit')]
    public function editAction(Request $request, Lecturer $lecturer)
    {
        $deleteForm = $this->createDeleteForm($lecturer);
        $editForm = $this->createForm('App\Form\LecturerType', $lecturer);
        $editForm->handleRequest($request);

        $lecturerUser = empty($this->em->getRepository(User::class)->loadUserByUsername($lecturer->getEmail())) ? 0 : 1;

        if ($editForm->isSubmitted() && $editForm->isValid()) {
            $this->em->flush();

            return $this->redirectToRoute('lecturer_edit', array('id' => $lecturer->getId()));
        }

        return $this->render('lecturer/edit.html.twig', array(
                    'lecturerUser' => $lecturerUser,
                    'lecturer' => $lecturer,
                    'lecturerAgreements' => $lecturer->getLecturerAgreements(),
                    'edit_form' => $editForm->createView(),
                    'delete_form' => $deleteForm->createView(),
        ));
    }

    #[Route(path: '/{id}', name: 'lecturer_delete', requirements: ['id' => '\d+'])]
    public function deleteAction(Request $request, Lecturer $lecturer)
    {
        $form = $this->createDeleteForm($lecturer);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $lecturerApprovalRepo = $this->em->getRepository(LecturerApprovedActivities::class);
            $lectApprovals = $lecturerApprovalRepo->findBy(['lecturer' => $lecturer]);

            foreach ($lectApprovals as $approval) {
                $this->em->remove($approval);
            }

            $this->em->remove($lecturer);

            try {
                $this->em->flush();
            } catch (Exception $ex) {
                $this->addFlash('warning', "Ištrinti įrašo nepavyko! Jis gali turėti susijusių įrašų." . $ex->getMessage());
            }
        }

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

    /**
     * Creates a form to delete a lecturer entity.
     *
     * @param Lecturer $lecturer The lecturer entity
     *
     * @return Form The form
     */
    private function createDeleteForm(Lecturer $lecturer)
    {
        return $this->createFormBuilder()
            ->setAction($this->generateUrl('lecturer_delete', array('id' => $lecturer->getId())))
            ->setMethod('DELETE')
            ->getForm()
        ;
    }

    #[Route(path: '/import_view', name: 'lecturer_import_view')]
    public function showImportLecturerAction(Request $request, FileUploader $fileUploader, UserPasswordHasherInterface $encoder)
    {

        $file = $request->files->get('fileToUpload');
        $uploadedFilePath = '';
        $fileImportReturn = [];
        if (!empty($file)) {
            $uploadedFilePath = $fileUploader->getTargetDir() . DIRECTORY_SEPARATOR . $fileUploader->upload($file);
            $fileImportReturn = $this->importData($uploadedFilePath, $encoder);
            unlink($uploadedFilePath);
        }

        return $this->render('lecturer/import.html.twig', [
            'uploadedFilePath' => $uploadedFilePath,
            'importErrors' => $fileImportReturn,
        ]);
    }

    private function importData($filePath, UserPasswordHasherInterface $encoder)
    {
        $positions = $this->em->getRepository(LecturerPosition::class)->getAllByName();
        $departments = $this->em->getRepository(Department::class)->getAllByShortName();
        $lecturers = $this->em->getRepository(Lecturer::class)->getAllByEmail();

        $objExcel = IOFactory::load($filePath);

        $worksheet = $objExcel->setActiveSheetIndex(0);

        $errors = [];
        foreach ($worksheet->getRowIterator() as $row) {
            $rowNumber = $row->getRowIndex();

            //insert values
            if ($row->getRowIndex() > 1) {
                $cellIterator = $row->getCellIterator();
                $cellIterator->setIterateOnlyExistingCells(false); // Loop all cells, even if it is not set
                $excelIndex = trim($worksheet->getCell('M' . $row->getRowIndex())->getValue());

                $lecturer = $lecturers[$excelIndex] ?? new Lecturer();

                foreach ($cellIterator as $cell) {
                    if (!is_null($cell)) {
                        $column = $cell->getColumn();

                        switch ($cell->getColumn()) {
                            case 'A':/* req */
                                $lecturer->setName($cell->getCalculatedValue());
                                break;
                            case 'B':/* req */
                                $lecturer->setSurname($cell->getCalculatedValue());
                                break;
                            case 'C':
                                $cellValue = trim($cell->getCalculatedValue());
                                if (empty($cellValue)) {
                                    $lecturer->setScientificDegree(null);
                                } else {
                                    $lecturer->setScientificDegree($cellValue);
                                }
                                break;
                            case 'D':
                                $cellValue = trim($cell->getCalculatedValue());
                                if (empty($cellValue)) {
                                    $lecturer->setEducation(null);
                                } else {
                                    $lecturer->setEducation($cellValue);
                                }
                                break;
                            case 'E':
                                $isMain = trim($cell->getCalculatedValue());
                                $isMainWorkplace = true;
                                if ($isMain == "N" || empty($isMain)) {
                                    $isMainWorkplace = false;
                                }
                                $lecturer->setIsMainWorkplace($isMainWorkplace);
                                break;
                            case 'F':
                                $isMain = trim($cell->getCalculatedValue());
                                $isNotFullTime = false;
                                if ($isMain == "Y" || $isMain == "Taip") {
                                    $isNotFullTime = true;
                                }
                                $lecturer->setIsNotFullTime($isNotFullTime);
                                break;
                            case 'G':
                                $isMain = trim($cell->getCalculatedValue());
                                if (!empty($isMain)) {
                                    $lecturer->setPracticalWorkExperience((float) str_replace(',', '.', $isMain));
                                } else {
                                    $lecturer->setPracticalWorkExperience(null);
                                }
                                break;
                            case 'H':
                                $isMain = trim($cell->getCalculatedValue());
                                $isNotFullTime = null;
                                if ($isMain === "Y" || $isMain === "Taip") {
                                    $isNotFullTime = 1;
                                }
                                $lecturer->setFiveYearsExperienceInKauko($isNotFullTime);
                                break;
                            case 'I':
                                $isMain = trim($cell->getCalculatedValue());
                                $isNotFullTime = null;
                                if ($isMain === "Mokslo") {
                                    $isNotFullTime = 1;
                                }
                                if ($isMain == "Verslo") {
                                    $isNotFullTime = 2;
                                }
                                $lecturer->setWorkAgreementOutsideKauko($isNotFullTime);
                                break;
                            case 'K':
                                $isMain = trim($cell->getCalculatedValue());
                                $isNotFullTime = null;
                                if ($isMain === "Y" || $isMain === "Taip") {
                                    $isNotFullTime = 1;
                                }
                                $lecturer->setWeekendWork($isNotFullTime);
                                break;
                            case 'J':
                                $isMain = trim($cell->getCalculatedValue());
                                $isNotFullTime = null;
                                if ($isMain === "Y" || $isMain === "Taip") {
                                    $isNotFullTime = 1;
                                }
                                $lecturer->setWorkInKaukoAdministration($isNotFullTime);
                                break;
                            case 'L':
                                $cellValue = (float) trim($cell->getCalculatedValue());
                                if (empty($cellValue)) {
                                    $lecturer->setPostSize(null);
                                } else {
                                    $lecturer->setPostSize($cellValue);
                                }
                                break;
                            case 'M':/* req */
                                $excelCode = ucfirst(strtolower(trim($cell->getCalculatedValue())));
                                if (!isset($positions[$excelCode])) {
                                    $errors[] = $column . $rowNumber . ": Pareigybė nerasta! (" . $excelCode . ")";
                                } else {
                                    $lecturer->setLecturerPosition($positions[$excelCode]);
                                }
                                break;
                            case 'N':
                                (int) $cellValue = trim($cell->getCalculatedValue());
                                if (empty($cellValue)) {
                                    $lecturer->setContractFrom(null);
                                } else {
                                    $excelDataDate = Date::excelToDateTimeObject($cellValue);
                                    $lecturer->setContractFrom($excelDataDate);
                                }
                                break;
                            case 'O':
                                $cellValue = trim($cell->getCalculatedValue());
                                if (empty($cellValue)) {
                                    $lecturer->setContractTo(null);
                                } else {
                                    $excelDataDate = Date::excelToDateTimeObject($cellValue);
                                    $lecturer->setContractTo($excelDataDate);
                                }
                                break;
                            case 'P':/* req */
                                $excelCode = trim($cell->getCalculatedValue());
                                if (!isset($departments[$excelCode])) {
                                    $errors[] = $column . $rowNumber . ": Katedra/akademija/centras/skyrius nerasta! (" . $excelCode . ")";
                                } else {
                                    $lecturer->setDepartment($departments[$excelCode]);
                                }
                                break;
                            case 'Q':/* req */
                                $email = trim($cell->getCalculatedValue());
                                if (empty($email)) {
                                    $errors[] = $column . $rowNumber . ": El. pašto adresas neužpildytas!";
                                } else {
                                    $lecturer->setEmail($email);
                                }
                                break;
                            case 'R':
                                $userCreate = trim($cell->getCalculatedValue());
                                if ($userCreate == "T" || $userCreate == "Y" || $userCreate == "1") {
                                    $user = $this->em->getRepository(User::class)->loadUserByUsername($lecturer->getEmail());
                                    if (empty($user)) {
                                        $user = new User();
                                        $user->setIsActive(true);
                                        $user->setUsername($lecturer->getEmail());
                                        $user->setEmail($lecturer->getEmail());
                                        $user->setRole('ROLE_LECTURER');
                                        $user->setRoles(['ROLE_LECTURER']);
                                        $user->setPassword($encoder->hashPassword($user, md5($lecturer->getEmail() . rand(50000, 500000))));
                                    } else {
                                        $user->setIsActive(true);
                                    }
                                    $this->em->persist($user);
                                }

                                break;
                            default:
                                break;
                        }
                    }
                }

//                $v = $this->get('validator');
//                $valid = $v->validate($academicGroup);

                if (empty($errors)) {
                    if (empty($valid[0])) {
                        $this->em->persist($lecturer);
                    } else {
                        $errors[] = $column . $rowNumber . ": " . $valid[0]->getMessage();
                    }
                }
            }
        }

        if (empty($errors)) {
            try {
                $this->em->flush();
            } catch (UniqueConstraintViolationException $ex) {
//                $this->addFlash("warning", "Faile yra vienodų naujų įrašų. Prašome patikrinti duomenis! Detaliau: ".$ex->getPrevious()->getMessage());
                $errors[] = "Faile yra vienodų naujų įrašų. Prašome patikrinti duomenis! Detaliau: " . $ex->getPrevious()->getMessage();
            }
        }

        return $errors;
    }

    private function createUsersForLecturers(UserPasswordHasherInterface $encoder)
    {

        $lecturers = $this->em->getRepository(Lecturer::class)->getAllWithoutUser();

        foreach ($lecturers as $lecturer) {
            $user = new User();

            $user->setUsername($lecturer->getEmail());
            $user->setEmail($lecturer->getEmail());
            $user->setRole('ROLE_LECTURER');
            $user->setRoles(['ROLE_LECTURER']);
            $user->setPassword($encoder->hashPassword($user, $user->getPassword()));

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

        $this->em->flush();
    }
}