<?php

namespace App\Controller;

use App\Entity\Stats;
use App\Entity\Place;
use App\Service\Motocultrice;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use GuzzleHttp\Client;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mailer\MailerInterface;

class PublicController extends AbstractController
{

    private $hide_filled_inputs = true;

    public function __construct(
        private EntityManagerInterface $entityManager,
        private Motocultrice $motocultrice,
        private MailerInterface $mailer
    ) {
    }

    #[Route('/propose-email/{email}/{type}/{id}', name: 'app_public_propose_email')]
    public function proposeEmail(string $email, string $type, int $id): Response
    {


            $data = $this->motocultrice->get_osm_object_data($type, $id);
            // Récupérer le code postal depuis les tags, sinon mettre -1
            $zipCode = isset($data['tags_converted']['addr:postcode']) ? (int)$data['tags_converted']['addr:postcode'] : -1;
            $place_name = $data['tags_converted']['name'];

        // Vérifier si une Place existe déjà avec le même osm_kind et osmId
        $existingPlace = $this->entityManager->getRepository(Place::class)->findOneBy([
            'osm_kind' => $type,
            'osmId' => $id
        ]);

        if ($existingPlace) {
            // Mettre à jour l'email de la Place existante
            $existingPlace->setEmail($email)->setLastContactAttemptDate(new \DateTime());
            $this->entityManager->flush();

            $debug = '';
            if ($this->getParameter('kernel.environment') !== 'prod') {
                $debug = 'Bonjour, nous sommes des bénévoles d\'OpenStreetMap France et nous vous proposons de modifier les informations de votre commerce. Voici votre lien unique de modification: ' . $this->generateUrl('app_public_edit', [
                    'zipcode' => $zipCode,
                    'name' => $place_name,
                    'uuid' => $existingPlace->getUuidForUrl()
                ], true);
            }
            
            $this->addFlash('success', 'L\'email a été mis à jour. Un email vous sera envoyé avec le lien de modification. '.$debug);
        } else {


            // Créer une nouvelle entité Place
            $place = new Place();
            $place->setEmail($email)
            ->setOsmId($id)
            ->setOsmKind($type)
            ->setAskedHumainsSupport(false)
            ->setOptedOut(false)
            ->setDead(false)
            ->setNote('')
            ->setModifiedDate(new \DateTime())
            ->setZipCode($zipCode)
            ->setPlaceCount(0)

            ->setLastContactAttemptDate(new \DateTime())
            ->setUuidForUrl(uniqid());

            $this->entityManager->persist($place);
            $this->entityManager->flush();

            $debug = '';
            if ($this->getParameter('kernel.environment') !== 'prod') {
                $debug = 'Bonjour, nous sommes des bénévoles d\'OpenStreetMap France et nous vous proposons de modifier les informations de votre commerce. Voici votre lien unique de modification: ' . $this->generateUrl('app_public_edit', [
                    'zipcode' => $zipCode,
                    'name' => $place_name,
                    'uuid' => $place->getUuidForUrl()
                ], true);
            }
            $this->addFlash('success', 'Un email vous sera envoyé avec le lien de modification. '.$debug);
        }

        // Envoyer l'email
        $destinataire = $this->getParameter('kernel.environment') === 'prod' ? $email : 'contact+essai_osm_commerce@cipherbliss.com';

        $message = (new Email())
            ->from('contact@osm-commerce.fr')
            ->to($destinataire)
            ->subject('Votre lien de modification OpenStreetMap')
            ->text('Bonjour, nous sommes des bénévoles d\'OpenStreetMap France et nous vous proposons de modifier les informations de votre commerce. Voici votre lien unique de modification: ' . $this->generateUrl('app_public_edit', [
                'zipcode' => $zipCode,
                'name' => $place_name,
                'uuid' => $existingPlace ? $existingPlace->getUuidForUrl() : $place->getUuidForUrl()
            ], true));

        $this->mailer->send($message);

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

    #[Route('/', name: 'app_public_index')]
    public function index(): Response
    {
        
        return $this->render('public/home.html.twig', [
            'controller_name' => 'PublicController',
            
        ]);
    }

    #[Route('/edit/{zipcode}/{name}/{uuid}', name: 'app_public_edit')]
    public function edit_with_uuid($zipcode, $name, $uuid): Response
    {
        $place = $this->entityManager->getRepository(Place::class)->findOneBy(['uuid_for_url' => $uuid]);
        if (!$place) {
            $this->addFlash('warning', 'Ce lien de modification n\'existe pas.');
            return $this->redirectToRoute('app_public_index');
        }

        if ($place->getOsmKind() === 'relation') {
            $this->addFlash('warning', 'Les objets OSM de type "relation" ne sont pas gérés dans cet outil.');
            return $this->redirectToRoute('app_public_index');
        }

        // récupérer les tags de base
        $base_tags = $this->motocultrice->base_tags;
        $base_tags = array_fill_keys($base_tags, '');
            
        $commerce_overpass = $this->motocultrice->get_osm_object_data($place->getOsmKind(), $place->getOsmId());
        // Fusionner les tags de base avec les tags existants
         
            $commerce_overpass['tags_converted'] = array_merge($base_tags, $commerce_overpass['tags_converted']);
        
        // Trier les tags par ordre alphabétique des clés
        ksort($commerce_overpass['tags_converted']);
        
        return $this->render('public/edit.html.twig', [
            'commerce_overpass' => $commerce_overpass,
            'name' => $name,
            'commerce' => $place,
            'hide_filled_inputs' => $this->hide_filled_inputs,
            'excluded_tags_to_render' => $this->motocultrice->excluded_tags_to_render,
            'osm_kind' => $place->getOsmKind(),
            "mapbox_token" => $_ENV['MAPBOX_TOKEN'],
            "maptiler_token" => $_ENV['MAPTILER_TOKEN'],
        ]);
    }

    #[Route('/dashboard', name: 'app_public_dashboard')]
    public function dashboard(): Response
    {
        // get stats
        $stats = $this->entityManager->getRepository(Stats::class)->findAll();

        $places = $this->entityManager->getRepository(Place::class)->findBy([], ['zip_code' => 'ASC', 'name' => 'ASC']);
        return $this->render('public/dashboard.html.twig', [
            'controller_name' => 'PublicController',
            'stats' => $stats,
            'places' => $places,
        ]);
    }

    #[Route('/modify/{osm_object_id}/{version}/{changesetID}', name: 'app_public_submit')]
    public function submit($osm_object_id, $version, $changesetID): Response
    {
        // Récupérer les données POST
        $request = Request::createFromGlobals();
        
        // Vérifier si des données ont été soumises
        if ($request->isMethod('POST')) {
            $status = "non modifié";
            
            // Récupérer le type d'objet (node ou way)
            $osm_kind = $request->request->get('osm_kind', 'node');
            
            // Récupérer tous les tags du formulaire
            $tags = [];

            $request_post = $request->request->all();
 

            $request_post = $this->motocultrice->map_post_values($request_post);

            foreach ($request_post as $key => $value) {
              
                if (strpos($key, 'commerce_tag_value__') === 0) {
                    $tagKey = str_replace('commerce_tag_value__', '', $key);
                    if (!empty($value)) {
                        // Validation des données selon le type de tag
                        if ($tagKey === 'addr:postcode') {
                            // Vérifier que c'est bien un code postal français (5 chiffres)
                            if (!preg_match('/^\d{5}$/', $value)) {
                                $status = "Erreur : Le code postal doit être composé de 5 chiffres";
                                continue;
                            }
                        }
                        $tags[$tagKey] = trim($value);
                    }
                }
            }

            // Récupérer le token OSM depuis les variables d'environnement
            $osm_api_token = $_ENV['APP_OSM_BEARER'];


            $exception = false;
            $exception_message = "";
            try {
                $client = new Client();

                // 1. Créer un nouveau changeset
                $changesetXml = new \SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><osm version="0.6"></osm>');
                $changeset = $changesetXml->addChild('changeset');
                $tag = $changeset->addChild('tag');
                $tag->addAttribute('k', 'created_by');
                $tag->addAttribute('v', 'OSM Mon Commerce Web Editor');
                
                $tag = $changeset->addChild('tag');
                $tag->addAttribute('k', 'comment');
                $tag->addAttribute('v', 'Modification des tags via l\'interface web #MonCommerceOSM');

                $changesetResponse = $client->put('https://api.openstreetmap.org/api/0.6/changeset/create', [
                    'body' => $changesetXml->asXML(),
                    'headers' => [
                        'Authorization' => 'Bearer ' . $osm_api_token,
                        'Content-Type' => 'application/xml'
                    ]
                ]);

                $newChangesetId = $changesetResponse->getBody()->getContents();

                // Récupérer les données actuelles de l'objet
                $currentObjectData = $this->motocultrice->get_osm_object_data($osm_kind, $osm_object_id);
                
                // 2. Modifier l'objet avec le nouveau changeset
                $xml = new \SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><osm version="0.6"></osm>');
                $object = $xml->addChild($osm_kind);
                $object->addAttribute('id', $osm_object_id);
                $object->addAttribute('version', $version);
                $object->addAttribute('changeset', $newChangesetId);
                
                // Ajouter les coordonnées pour les nodes
                if ($osm_kind === 'node') {
                    if (!isset($currentObjectData['@attributes']['lat']) || !isset($currentObjectData['@attributes']['lon'])) {
                        throw new \Exception("Impossible de récupérer les coordonnées du nœud");
                    }
                    $object->addAttribute('lat', $currentObjectData['@attributes']['lat']);
                    $object->addAttribute('lon', $currentObjectData['@attributes']['lon']);
                }
                
                // Ajouter les tags
                foreach ($tags as $key => $value) {
                    if (!empty($key) && !empty($value)) {
                        $tag = $object->addChild('tag');
                        $tag->addAttribute('k', htmlspecialchars($key, ENT_XML1));
                        $tag->addAttribute('v', htmlspecialchars($value, ENT_XML1));
                    }
                }

                // Debug du XML généré
                $xmlString = $xml->asXML();
                // echo('xml : <br>'.$xmlString);

                $response = $client->put("https://api.openstreetmap.org/api/0.6/{$osm_kind}/" . $osm_object_id, [
                    'body' => $xmlString,
                    'headers' => [
                        'Authorization' => 'Bearer ' . $osm_api_token,
                        'Content-Type' => 'application/xml'
                    ]
                ]);

                // 3. Fermer le changeset
                $client->put('https://api.openstreetmap.org/api/0.6/changeset/' . $newChangesetId . '/close', [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $osm_api_token
                    ]
                ]);

                if ($response->getStatusCode() === 200) {
                    $status = "Les tags ont été mis à jour avec succès";
                } else {
                    $status = "Erreur lors de la mise à jour des tags";
                }
            } catch (\Exception $e) {
                $status = "Erreur lors de la communication avec l'API OSM: " . $e->getMessage();
                $exception = true;
                $exception_message = $e->getMessage();
                // Debug de la réponse en cas d'erreur
                if (method_exists($e, 'getResponse')) {
                    var_dump($e->getResponse()->getBody()->getContents());
                }
            }
        }
        
        // après envoi on récupère les données
        $commerce = $this->motocultrice->get_osm_object_data($osm_kind, $osm_object_id);

        
        return $this->render('public/view.html.twig', [
            'controller_name' => 'PublicController',
            'commerce' => $commerce,
            
            'status' => $status,
            'exception' => $exception,
            'exception_message' => $exception_message,
            'mapbox_token' => $_ENV['MAPBOX_TOKEN'],
            'maptiler_token' => $_ENV['MAPTILER_TOKEN'],
        ]);
    }

    #[Route('/request_email_to_modify/{osm_object_id}', name: 'app_public_request_email')]
    public function request_email($osm_object_id): Response
    {
        if ($this->getRequest()->isMethod('POST')) {
            $email = $this->getRequest()->request->get('email');
            
            try {
                // TODO: Implémenter l'envoi réel du mail
                
                $this->addFlash(
                    'success',
                    'Un email vous a été envoyé avec les instructions pour modifier ce lieu.'
                );
            } catch (\Exception $e) {
                $this->addFlash(
                    'error', 
                    'Une erreur est survenue lors de l\'envoi de l\'email. Veuillez réessayer plus tard.'
                );
            }
            
            return $this->redirectToRoute('app_public_index');
        }
        // TODO envoyer un email
        return $this->render('public/request_email.html.twig', [
            'controller_name' => 'PublicController',
            'commerce_id' => $osm_object_id,
        ]);
    }

    #route pour signaler que le commerce est fermé
    #[Route('/closed_commerce/{osm_object_id}', name: 'app_public_closed_commerce')]
    public function closed_commerce($osm_object_id): Response
    {
        $place = $this->entityManager->getRepository(Place::class)->findOneBy(['osm_id' => $osm_object_id]);
        if (!$place) {
            $this->addFlash('warning', 'Ce commerce n\'existe pas.');
            return $this->redirectToRoute('app_public_index');
        }

        $place->setClosed(true);
        $this->entityManager->flush();
        
        return $this->render('public/closed_commerce.html.twig', [
            'controller_name' => 'PublicController',
        ]);
    }

    #[Route('/closed_commerces', name: 'app_public_closed_commerces')]
    public function closedCommerces(): Response
    {
        // Récupérer tous les commerces marqués comme fermés
        $closedPlaces = $this->entityManager->getRepository(Place::class)->findBy(['dead' => true]);

        return $this->render('public/closed_commerces.html.twig', [
            'controller_name' => 'PublicController',
            'closed_places' => $closedPlaces
        ]);
    }
}