<?php

namespace App\Form;

use App\Entity\Action;
use App\Entity\Ministry;
use App\Entity\Commune;
use App\Entity\Programm;
use App\Repository\MinistryRepository;
use App\Repository\CommuneRepository;
use App\Repository\ProgrammRepository;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bridge\Doctrine\Form\Type\EntityType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\OptionsResolver\OptionsResolver;

class ActionType extends AbstractType
{
    private $year;
    private $entityManager;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $this->year = $options['sessionYear']; 
        $builder
            ->add('code', TextType::class, [
                'label' => 'basics.code'
            ])
            ->add('name', TextType::class, [
                'label' => 'basics.name'
            ]);
        if($options['sessionMinistry']==null && $options['sessionCommune']==null){
            $builder->add('type', ChoiceType::class, [
                'choices' => [
                    'Ministère' => 'ministere',
                    'Commune' => 'commune',
                ],
                'placeholder' => 'Sélectionnez une structure',
                'mapped' => false,
                'required' => true,
                'label' => 'Type Structure',
                'data' => $options['defaultType'],
                'disabled' => $options['defaultType'] ? true : false,
            ]);
            

            $builder->get('type')->addEventListener(
                FormEvents::POST_SUBMIT,
                function (FormEvent $event) use($options) {
                    $form = $event->getForm();
                    $this->addEntiteField($form->getParent(), $form->getData(),$options);
                }
            );
        }

        $builder->addEventListener(
            FormEvents::PRE_SUBMIT,
            function (FormEvent $event) use ($options) {
                $data = $event->getData();
                $form = $event->getForm();
                if($options['sessionMinistry']==null && $options['sessionCommune']==null){
                    if (isset($data['type']) && $data['type']!=""  && isset($data['entite']) && $data['entite']!="") {
                        if ($data['type'] === 'ministere') {
                            $ministry = $this->entityManager->getRepository(Ministry::class)->find($data['entite']);
                            $this->addProgrammField($form, $ministry, null);
                        }elseif ($data['type'] === 'commune') {
                            $commune = $this->entityManager->getRepository(Commune::class)->find($data['entite']);
                            $this->addProgrammField($form, null, $commune);
                        }
                    }
                }
            }
        );

        $builder->addEventListener(
            FormEvents::POST_SET_DATA,
            function (FormEvent $event) use($options) {
                $form = $event->getForm();
                $data = $event->getData();

                $programm = $data->getProgramm();
                if ($programm) {
                    $ministry = $programm->getMinistry();
                    $commune = $programm->getCommune();
                    $this->addProgrammField($form, $ministry,$commune);

                    if($options['sessionMinistry']==null && $options['sessionCommune']==null){
                        $type = $form->has('type') ? $form->get('type')->getData() : null;
                        $this->addEntiteField($form, $type, $options);
                    }
                    $this->addProgrammField($form, $ministry,$commune);
                }else{
                    if($options['sessionMinistry']==null && $options['sessionCommune']==null){
                        $this->addEntiteField($form, null, $options);
                    }
                    if($options['sessionMinistry']){
                        $this->addProgrammField($form, $options['sessionMinistry'],null);
                    }else if($options['sessionCommune']){
                        $this->addProgrammField($form, null, $options['sessionCommune']);
                    }else{
                        $this->addProgrammField($form, null, null);
                    }
                }
                
            }
        );
    }
    
    private function addProgrammField(FormInterface $form, ?Ministry $ministry, ?Commune $commune)
    { 
        $form->add('programm', EntityType::class, [
            'label' => 'basics.programm',
            'class' => Programm::class,
            'choice_label' => 'name',
            'placeholder' => ($ministry || $commune) ? 'basics.programm.placeholder' : 'Sélectionnez d\'abord un ministère ou une commune',
            'query_builder' => function (ProgrammRepository $repository) use($ministry, $commune) {
                return $repository->findProgrammByYear('%'.$this->year.'%', $ministry, $commune);
            },
        ]);
    }

    private function addEntiteField(FormInterface $form,  $type, $options)
    {
        if($type){
            if($type=='commune'){
                $form->add('entite', EntityType::class, [
                    'class' => Commune::class,
                    'placeholder' => 'Sélectionnez une commune',
                    'required' => true,
                    'mapped' => false,
                    'choice_label' => 'name', 
                    'data' => $options['defaultEntite'],
                    'disabled' => $options['defaultEntite'] ? true : false,
                    'label' => 'Liste des Communes',
                    'query_builder' => function (CommuneRepository $er) {
                        return $er->createQueryBuilder('m')
                                ->orderBy('m.name', 'ASC'); // Tri par nom en ordre croissant
                    },
                    
                ]);
            }else if($type=='ministere'){
                $form->add('entite', EntityType::class, [
                    'class' => Ministry::class, // Classe par défaut, ajustée dynamiquement
                    'placeholder' => 'Sélectionnez un ministère',
                    'required' => true,
                    'mapped' => false,
                    'choice_label' => 'name', 
                    'data' => $options['defaultEntite'],
                    'disabled' => $options['defaultEntite'] ? true : false,
                    'label' => 'Liste des Ministères',
                    'query_builder' => function(MinistryRepository $repository)  {
                        return $repository->findMinistryByYear(
                            '%'.$this->year.'%', null
                        );
                    },
                ]);
            }
        }else{
            $form->add('entite', EntityType::class, [
                'label' => 'Ministères/Communes',
                'class' => Ministry::class,
                'required' => true,
                'mapped' => false,
                'placeholder' => 'Sélectionnez d\'abord un type d\'entité',
                'choices' => [],
            ]);
        }
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => Action::class,
            'sessionYear' => null,
            'sessionMinistry' => null,
            'sessionCommune' => null,
            'defaultType' => null,
            'defaultEntite' => null,
        ));
    }
}