from flask import Flask, request, jsonify
import re

app = Flask(__name__)


import json
import os
import requests
from apscheduler.schedulers.background import BackgroundScheduler
from pytz import timezone

LABOS_JSON_URL = "https://vence-pharmacieposte.fr/modules/ajaxsmartsearch/export_labos.php"

# Déclenche la génération du fichier labos.json côté PrestaShop
def update_labos_json():
    try:
        resp = requests.get(LABOS_JSON_URL, timeout=30)
        if resp.status_code == 200:
            print(f"[NLP DEBUG] Mise à jour labos.json côté PrestaShop : OK ({resp.json()['count']} labos)")
        else:
            print(f"[NLP DEBUG] Erreur lors de la mise à jour labos.json : {resp.status_code}")
    except Exception as e:
        print(f"[NLP DEBUG] Exception lors de la mise à jour labos.json : {e}")

def schedule_labos_update():
    scheduler = BackgroundScheduler(timezone=timezone('Europe/Paris'))
    # Tous les jours à minuit heure française
    scheduler.add_job(update_labos_json, 'cron', hour=0, minute=0)
    scheduler.start()

# Appelle cette fonction au démarrage du service Python
schedule_labos_update()

def load_labos():
    # Chemin à adapter selon l'endroit où PrestaShop génère le fichier
    path = os.path.join(os.path.dirname(__file__), 'labos.json')
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return [l.lower() for l in json.load(f)]
    except Exception as e:
        print(f"[NLP DEBUG] Impossible de charger la liste des labos: {e}")
        return []

def normalize(text):
    # Supprime les accents et met en minuscule
    return ''.join(
        c for c in unicodedata.normalize('NFD', text)
        if unicodedata.category(c) != 'Mn'
    ).lower()

def parse_query(query):
    query = query.lower()
    price_min, price_max, labo = None, None, None
    labos_dyn = load_labos()
    # Créé un mapping normalisé -> labo original
    normalized_labos = {normalize(l): l for l in labos_dyn}
    tokens = query.split()
    labo = None
    name_tokens = []
    # Cherche si un token correspond à un labo (sans accent/casse)
    for token in tokens:
        n_token = normalize(token)
        if n_token in normalized_labos:
            labo = normalized_labos[n_token]
        else:
            name_tokens.append(token)
    # Extraction prix max
    m = re.search(r'(moins de|inférieur à|<)\s*([0-9]+)', query)
    if not m:
        m = re.search(r'moins de\s*([0-9]+)', query)
    if m:
        price_max = float(m.group(2) if len(m.groups()) > 1 else m.group(1))
    # Extraction prix min
    m = re.search(r'(plus de|supérieur à|>)\s*([0-9]+)', query)
    if not m:
        m = re.search(r'plus de\s*([0-9]+)', query)
    if m:
        price_min = float(m.group(2) if len(m.groups()) > 1 else m.group(1))
    name = ' '.join(name_tokens).strip()
                break
    # Nettoyage des stopwords et verbes courants
    stopwords = [
        r'\bje veux\b', r'\bje cherche\b', r'\btrouver\b', r'\btrouvez\b', r'\bcherche\b', r'\brecherche\b',
        r'\bj\'aimerais\b', r'\bj\'aimerai\b', r'\bmontre\b', r'\bmontrez\b', r'\baffiche\b', r'\bafficher\b',
        r'\bmontre moi\b', r'\bmontrez moi\b', r'\baffiche moi\b', r'\bafficher moi\b',
        r'\bdu\b', r'\bde la\b', r'\bdes\b', r'\ble\b', r'\bla\b', r'\bl\''
    ]
    query_clean = query
    for sw in stopwords:
        query_clean = re.sub(sw, '', query_clean)
    query_clean = query_clean.strip()

    # Extraire le nom AVANT de retirer la partie prix
    # On coupe dès qu'on trouve une indication de prix
    name = re.split(r'(moins de|inférieur à|plus de|supérieur à|entre|et|[0-9]+\s*€?|euros?)', query_clean, 1)[0].strip()
    # Nettoyer le nom extrait des connecteurs
    if name:
        name = re.split(r'\b(à|de|chez|pour|au prix de|à partir de|à moins de|à plus de|€|euros?)\b', name, 1)[0].strip()

    # Fallback : si aucun nom extrait, prendre le dernier mot (utile pour "je veux du dolipranne")
    if not name:
        words = query_clean.strip().split()
        if words:
            name = words[-1]

    # Si le nom est trop court, le vider pour éviter une recherche inutile sur "du", "le", etc.
    if len(name) < 3:
        name = ''
    print(f"[NLP DEBUG] Résultat NLP: name='{name}', labo='{labo}', price_min={price_min}, price_max={price_max}")
    # Retourne un résultat si au moins name ou labo est présent
    if not name and not labo:
        return None
    return {
        'name': name,
        'labo': labo,
        'price_min': price_min,
        'price_max': price_max
    }

@app.route('/')
def index():
    return 'API NLP OK!'

@app.route('/parse', methods=['POST'])
def parse():
    data = request.get_json()
    query = data.get('query', '')
    result = parse_query(query)
    return jsonify(result)