<?php

namespace Medienreaktor\Courses\Task;


use Doctrine\DBAL\FetchMode;
use Medienreaktor\Courses\Domain\Model\Profession;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Database\Query\QueryBuilder;
use TYPO3\CMS\Core\DataHandling\SlugHelper;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
use TYPO3\CMS\Scheduler\Task\AbstractTask;
use Medienreaktor\Courses\Service\ApiService;
use Medienreaktor\Courses\Domain\Model\Course;
use Medienreaktor\Courses\Domain\Model\Subject;
use Medienreaktor\Courses\Domain\Model\Workshop;
use Medienreaktor\Courses\Domain\Repository\CourseRepository;
use Medienreaktor\Courses\Domain\Repository\SubjectRepository;
use Medienreaktor\Courses\Domain\Repository\WorkshopRepository;
use Medienreaktor\Courses\Domain\Repository\ProfessionRepository;
use Medienreaktor\Courses\Service\SlugService;

class CourseImportTask extends AbstractTask
{
    /** @var ObjectManager */
    private $objectManager = null;

    /** @var ApiService */
    private $apiService = null;

    /** @var SlugService */
    private $slugService = null;

    /**
     * courseRepository
     *
     * @var \Medienreaktor\Courses\Domain\Repository\CourseRepository
     */
    protected $courseRepository = null;

    /**
     *
     * subjectRepository
     *
     * @var \Medienreaktor\Courses\Domain\Repository\SubjectRepository
     */
    protected $subjectRepository = null;

    /**
     *
     * professionRepository
     *
     * @var \Medienreaktor\Courses\Domain\Repository\ProfessionRepository
     */
    protected $professionRepository = null;

    /**
     *
     * courseRepository
     *
     * @var \Medienreaktor\Courses\Domain\Repository\WorkshopRepository
     */
    protected $workshopRepository = null;

    protected const STORAGE_PID = 909;
    public function execute()
    {
        $this->slugService = GeneralUtility::makeInstance(SlugService::class);
        $this->apiService = GeneralUtility::makeInstance(ApiService::class);
        $this->courseRepository = GeneralUtility::makeInstance(CourseRepository::class);
        $this->subjectRepository = GeneralUtility::makeInstance(SubjectRepository::class);
        $this->professionRepository = GeneralUtility::makeInstance(ProfessionRepository::class);

        $courses = $this->apiService->getCourses();


        if($courses != NULL){
            $this->lastImportCheckCoursesDeletions($courses);
            $this->lastImportCheckWorkshopDeletions($courses);
            $this->deleteImportedData(false, false,false, false);
            $this->populateSubjects($courses);
            $this->populateProfessions($courses);
            $this->populateWorkshops($courses);


            foreach ($courses as $importCourse){

                $availableCourse = $this->courseRepository->findByImportId($importCourse["Id"]);

                if($availableCourse[0]){
                    $course = $availableCourse[0];
                } else{
                    $course = new Course();
                }

                $course->setPid(self::STORAGE_PID);
                $course->setCourseId($importCourse["Id"]);
                $course->setTitle($importCourse["Bezeichnung"]);
                $course->setShortTitle($importCourse["Kurzbezeichnung"]);
                $course->setContents($importCourse["Inhalte"]);
                $course->setRequirements($importCourse["Voraussetzungen"]);
                $course->setLanguage($importCourse["Sprache"]);
                $course->setImageUri($importCourse["PhotoUrl"]);
                $course->setPrice($importCourse["Kosten"]);
                $course->setCourseType($importCourse["SeminarTyp"]);
                $course->setGoals($importCourse["Ziele"]);
                $course->setPerspectives($importCourse["Perspektive"]);
                $course->setTargetGroup($importCourse["Zielgruppe"]);
                $course->setDuration($importCourse["Dauer"]);
                $course->setAgencySupported($importCourse["IstArgenturGefoerdert"]);
                $course->setIhkCertified($importCourse["HatIHKZertifikat"]);
                $course->setIndividualAppointments($importCourse["HatIndividualTermine"]);
                $course->setPathSegment($this->slugService->createTitleSlug($importCourse["Bezeichnung"],$importCourse["Id"]));

                if(!$course->getSeoImage()){
                    $course->setSeoImage(0);
                }
                if(!$course->getHighlight()){
                    $course->setHighlight(false);
                }

                if($course->getSeoDescription() == ""){
                    $course->setSeoDescription($importCourse["Ziele"]);
                }
                if($course->getSeoTitle() == ""){
                    $course->setSeoTitle($importCourse["Bezeichnung"]);
                }

                if($importCourse["Fachbereiche"]){
                    foreach ($importCourse["Fachbereiche"] as $importSubject){
                        $res = $this->subjectRepository->findByImportId($importSubject["Id"]);
                        $course->addSubject($res[0]);
                    }
                }
                if($importCourse["Berufsgruppen"]){
                    foreach ($importCourse["Berufsgruppen"] as $importProfession){
                        $res = $this->professionRepository->findByName($importProfession["Beruf"]);
                        if($res[0]){
                            $course->addProfession($res[0]);
                        }
                    }
                }
                if($importCourse["Instanzen"]){
                    foreach ($importCourse["Instanzen"] as $importWorkshop){
                        $res = $this->workshopRepository->findByImportId($importWorkshop["Id"]);
                        if($res[0]){
                            $course->addWorkshop($res[0]);
                        }
                    }

                }

                if($availableCourse[0]){
                    $this->courseRepository->update($course);
                } else{
                    $this->courseRepository->add($course);
                }

            }

            Generalutility::makeInstance(PersistenceManager::class)->persistAll();

            return true;

        } else{

            return false;

        }


    }
    public function populateWorkshops(array $courses){

        $this->workshopRepository = Generalutility::makeInstance(WorkshopRepository::class);

        $workshops = [];

        foreach ($courses as $course){
            if($course["Instanzen"]){
                foreach ($course["Instanzen"] as $importWorkshop){
                    $workshops[$importWorkshop["Id"]] = $importWorkshop;
                }
            }
        }

        foreach ($workshops as $key => $value){
            $availableWorkshop = $this->workshopRepository->findByImportId($key);

            if($availableWorkshop[0]){
                $workshop = $availableWorkshop[0];
            } else{
                $workshop = new Workshop();
            }

            $workshop->setPid(self::STORAGE_PID);
            $workshop->setWorkshopId($key);
            $workshop->setHighlight($value["IstHighlight"]);
            $workshop->setZip($value["PLZ"]);
            $workshop->setLocation($value["Ort"]);
            $workshop->setStreet($value["Strasse"]);
            $workshop->setCountry($value["Land"]);
            $workshop->setLocationDescription($value["Ortsbezeichnung"]);
            $workshop->setRoom($value["Raum"]);
            $workshop->setStartTime(strtotime($value["Start"]));
            $workshop->setEndTime(strtotime($value["Ende"]));

            if($availableWorkshop[0]){
                $this->workshopRepository->update($workshop);
            } else{
                $this->workshopRepository->add($workshop);
            }

        }

        return Generalutility::makeInstance(PersistenceManager::class)->persistAll();
    }
    public function populateSubjects(array $courses){

        $this->subjectRepository = GeneralUtility::makeInstance(SubjectRepository::class);
        $subjects = [];

        foreach ($courses as $course){
            if($course["Fachbereiche"]){
                foreach ($course["Fachbereiche"] as $importSubject){
                    $subjects[$importSubject["Id"]] = $importSubject["Fachbereich"];
                }
            }
        }

        foreach ($subjects as $key => $value){
            $availableSubject = $this->subjectRepository->findByImportId($key);

            if($availableSubject[0]){
                $subject = $availableSubject[0];
            } else{
                $subject = new Subject();
            }

            $subject->setPid(self::STORAGE_PID);
            $subject->setSubjectId($key);
            $subject->setTitle($value);

            if($availableSubject[0]){
                $this->subjectRepository->update($subject);
            } else{
                $this->subjectRepository->add($subject);
            }

        }

        return GeneralUtility::makeInstance(PersistenceManager::class)->persistAll();
    }

    public function populateProfessions(array $courses){

        $this->professionRepository = GeneralUtility::makeInstance(ProfessionRepository::class);
        $professions = [];

        foreach ($courses as $course){
            if($course["Fachbereiche"]){
                foreach ($course["Berufsgruppen"] as $importProfession){
//                    $professions[$importProfession["Id"]] = [
//                        "title" => $importProfession["Ausbildungsjahr"] == 0 ? $importProfession["Beruf"] : $importProfession["Beruf"]." ". $importProfession["Ausbildungsjahr"].". Lehrjahr",
//                        "year" => $importProfession["Ausbildungsjahr"],
//                        ];
                    $professions[$importProfession["Beruf"]] = $importProfession["Beruf"];
                }
            }
        }

        foreach ($professions as $key => $value){
            $availableProfession = $this->professionRepository->findByName($value);

            if($availableProfession[0]){
                $profession = $availableProfession[0];
            } else{
                $profession = new Profession();
            }

            $profession->setPid(self::STORAGE_PID);
//            $profession->setProfessionId($key);
            $profession->setTitle($value);
//            $profession->setProfessionYear($value["year"]);

            if($availableProfession[0]){
                $this->professionRepository->update($profession);
            } else{
                $this->professionRepository->add($profession);
            }

        }

        return GeneralUtility::makeInstance(PersistenceManager::class)->persistAll();
    }

    public function deleteImportedData(bool $courses = false, bool $subjects = false, bool $workshops = false, bool $professions = false){
        $this->courseRepository = GeneralUtility::makeInstance(CourseRepository::class);
        $this->subjectRepository = GeneralUtility::makeInstance(SubjectRepository::class);
        $this->workshopRepository = GeneralUtility::makeInstance(WorkshopRepository::class);
        $this->professionRepository = GeneralUtility::makeInstance(ProfessionRepository::class);

        if($courses){
            $this->courseRepository->removeImportedEntities();
        }
        if($subjects){
            $this->subjectRepository->removeImportedEntities();
        }
        if($workshops){
            $this->workshopRepository->removeImportedEntities();
        }
        if($professions){
            $this->professionRepository->removeImportedEntities();
        }

        return true;
    }

    public function lastImportCheckCoursesDeletions(array $courses){
        $this->courseRepository = GeneralUtility::makeInstance(CourseRepository::class);
        $importedCourses = $this->courseRepository->findAllForScheduler();

       if(count($importedCourses) > 0){
           foreach ($courses as $ckey => $cval){
               foreach ($importedCourses as $key => $val){
                   if($cval["Id"] == $val["course_id"]){
                       if($val["hidden"] == 1){
                           $this->courseRepository->setHiddenByUid($val["uid"], 0);
                       }
                       unset($importedCourses[$key]);
                   }
               }
           }

           foreach ($importedCourses as $deletedCourses){
               $this->courseRepository->setHiddenByUid($deletedCourses["uid"], 1);
           }
       }

        return true;

    }
    public function lastImportCheckWorkshopDeletions(array $courses){

        $this->workshopRepository = GeneralUtility::makeInstance(WorkshopRepository::class);
        $importedWorkshops = $this->workshopRepository->findAllForScheduler();

        if(count($importedWorkshops) > 0){
            foreach ($courses as $course){
                foreach ($course["Instanzen"] as $instance){
                    foreach ($importedWorkshops as $key => $val){
                        if($instance["Id"] == $val["workshop_id"]){
                            if($val["hidden"] == 1){
                                $this->workshopRepository->setHiddenByUid($val["uid"], 0);
                            }
                            unset($importedWorkshops[$key]);
                        }
                    }
                }
            }

            foreach ($importedWorkshops as $deletedWorkshops){
                $this->workshopRepository->setHiddenByUid($deletedWorkshops["uid"], 1);
            }
        }
        return true;
    }
}