# -*- coding: utf-8 -*-
import requests
import mysql.connector
from datetime import datetime, timedelta
import time
import sys
import os
import schedule

def connect_db():
    return mysql.connector.connect(
        host="54.36.188.119",
        user="michel",
        password="#SO2&1nf%mZ@jfh",
        database="Sondes"
    )

def envoi_etat_quotidien(cursor, site):
    token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
    chat_id = get_chat_id(cursor, site)
    etat_sondes(cursor, site, chat_id, token)
    print(f"[INFO] État des sondes envoyé pour le site {site}.")

def get_active_sondes(cursor, site):
    query = "SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Etat = 'On';"
    cursor.execute(query, (site,))
    result = cursor.fetchall()
    return {row[0]: float(row[1]) for row in result}


def check_temperature_limits(cursor, table_historique, sonde, limite, duree=30):
    temps_limite = datetime.now() - timedelta(minutes=duree)
    query = f"""
    SELECT Temperature 
    FROM {table_historique}
    WHERE Sonde = %s AND Date >= %s 
    ORDER BY Date DESC LIMIT 6;
    """
    cursor.execute(query, (sonde, temps_limite))
    result = cursor.fetchall()
    if len(result) == 6 and all(float(temp[0]) > limite for temp in result):
        return True, float(result[0][0])
    return False, None

def simulate_alert(db, cursor, site, sonde, chat_id, token):
    table_alertes = f"Alertes_{site}"
    print(f"[TEST] tentative d'insertion de sonde : {sonde} dans table {table_alertes}")

    try:
        query = f"""
        INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status)
        VALUES (%s, NOW(), 'test')
        ON DUPLICATE KEY UPDATE Debut_defaut = NOW(), Status = 'test';
        """
        cursor.execute(query, (sonde,))
        db.commit()
        print(f"[TEST] insertion ou mise à jour réussie pour {sonde}.")
    except Exception as e:
        print(f"[ERREUR] lors de l'insertion test : {e}")

    message = f"⚠️ TEST ALERTE : Simulation d'une alerte pour la sonde {sonde}."
    url = f"https://api.telegram.org/bot{token}/sendMessage"
    try:
        requests.get(url, params={'chat_id': chat_id, 'text': message})
    except Exception as e:
        print(f"[ERREUR] lors de l'envoi Telegram : {e}")

def create_alert(db, cursor, table_alertes, sonde, temperature):
    query = f"""
    INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) 
    VALUES (%s, NOW(), 'en cours');
    """
    cursor.execute(query, (sonde,))
    send_telegram_message(sonde, temperature)
    print(f"Alerte créée pour la sonde {sonde}")
    db.commit()

def resolve_alert(cursor, table_alertes, sonde):
    query = f"""
    UPDATE {table_alertes}
    SET Status = 'résolu' 
    WHERE Sonde = %s AND Status = 'en cours';
    """
    cursor.execute(query, (sonde,))
    print(f"Alerte résolue pour la sonde {sonde}")

def acquitter_alerte(cursor, site, sonde, chat_id, token):
    table_alertes = f"Alertes_{site}"
    query = f"""
    UPDATE {table_alertes}
    SET Status = 'acquittée'
    WHERE Sonde = %s AND Status IN ('en cours', 'test');
    """
    cursor.execute(query, (sonde,))
    lignes_modifiees = cursor.rowcount

    if lignes_modifiees > 0:
        message = f"✅ Alerte acquittée pour la sonde {sonde} par commande Telegram."
    else:
        message = f"ℹ️ Aucune alerte active à acquitter pour la sonde {sonde}."

    url = f"https://api.telegram.org/bot{token}/sendMessage"
    try:
        requests.get(url, params={'chat_id': chat_id, 'text': message})
    except Exception as e:
        print(f"[ERREUR] envoi message Telegram : {e}")

def send_telegram_message(sonde, temperature):
    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
    chat_id = "-1002442631825"
    message = f"⚠️ Alerte température : La sonde {sonde} dépasse la limite avec une température de {temperature}°C."
    url = f"https://api.telegram.org/bot{token}/sendMessage"
    params = {'chat_id': chat_id, 'text': message}
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            print(f"Message envoyé via Telegram pour la sonde {sonde}.")
        else:
            print(f"Erreur lors de l'envoi du message Telegram : {response.status_code}")
    except Exception as e:
        print(f"Erreur lors de l'envoi du message Telegram : {e}")


def get_chat_id(cursor, site):
    cursor.execute("SELECT Chat_ID FROM Sites WHERE Nom = %s;", (site,))
    result = cursor.fetchone()
    if result:
        return result[0]
    else:
        print(f"Aucun Chat_ID trouvé pour le site {site}")
        return None

def passer_en_maintenance(cursor, site, sonde, chat_id, token):
    try:
        query = """
        UPDATE Chambres_froides
        SET Etat = 'Off'
        WHERE Lieu = %s AND Sonde = %s;
        """
        cursor.execute(query, (site, sonde))
        lignes_modifiees = cursor.rowcount

        if lignes_modifiees > 0:
            message = f"🛠️ La sonde {sonde} a été passée en mode maintenance (OFF)."
        else:
            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."

        url = f"https://api.telegram.org/bot{token}/sendMessage"
        requests.get(url, params={'chat_id': chat_id, 'text': message})

    except Exception as e:
        print(f"[ERREUR] lors du passage en maintenance : {e}")

def reactiver_sonde(cursor, site, sonde, chat_id, token):
    try:
        query = """
        UPDATE Chambres_froides
        SET Etat = 'On'
        WHERE Lieu = %s AND Sonde = %s;
        """
        cursor.execute(query, (site, sonde))
        lignes_modifiees = cursor.rowcount

        if lignes_modifiees > 0:
            message = f"✅ La sonde {sonde} a été réactivée (ON)."
        else:
            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."

        url = f"https://api.telegram.org/bot{token}/sendMessage"
        requests.get(url, params={'chat_id': chat_id, 'text': message})

    except Exception as e:
        print(f"[ERREUR] lors de la réactivation : {e}")

def etat_sondes(cursor, site, chat_id, token):
    query = "SELECT Sonde, Etat FROM Chambres_froides WHERE Lieu = %s ORDER BY Sonde;"
    cursor.execute(query, (site,))
    result = cursor.fetchall()

    message = f"📊 État des sondes - {site} :\n"
    for sonde, etat in result:
        symbole = "🟢" if etat.upper() == "ON" else "🔴"
        message += f"{symbole} {sonde} ({etat.upper()})\n"

    url = f"https://api.telegram.org/bot{token}/sendMessage"
    requests.get(url, params={'chat_id': chat_id, 'text': message})

def monitor_temperatures_simple(site, db, cursor):
    table_historique = site
    table_alertes = f"Alertes_{site}"
    sondes = get_active_sondes(cursor, site)
    print(f"[MONITORING] Sondes actives pour {site} : {sondes}")

    for sonde, limite in sondes.items():
        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
        if alert_needed:
            create_alert(db, cursor, table_alertes, sonde, temperature)
        else:
            resolve_alert(cursor, table_alertes, sonde)

    db.commit()
    print("[MONITORING] Vérification des sondes terminée.")

def monitor_temperatures(site):
    db = connect_db()
    cursor = db.cursor()

    table_historique = site  # Ex: Saclay
    table_alertes = f"Alertes_{site}"  # Ex: Alertes_Saclay

    sondes = get_active_sondes(cursor, site)
    print(f"Sondes actives pour le site {site} :", sondes)

    for sonde, limite in sondes.items():
        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
        if alert_needed:
            create_alert(db, cursor, table_alertes, sonde, temperature)
        else:
            resolve_alert(cursor, table_alertes, sonde)

    db.commit()
    listen_for_commands(db, cursor, site)
    cursor.close()
    db.close()

def listen_for_commands(db, cursor, site):
    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
    chat_id = get_chat_id(cursor, site)
    offset_file = os.path.join(os.path.dirname(__file__), f"last_update_id_{site}.txt")

    try:
        with open(offset_file, 'r') as f:
            last_update_id = int(f.read().strip())
    except FileNotFoundError:
        last_update_id = None

    url = f"https://api.telegram.org/bot{token}/getUpdates"
    if last_update_id is not None:
        url += f"?offset={last_update_id + 1}"

    try:
        response = requests.get(url)
        data = response.json()

        if "result" in data:
            for update in data["result"]:
                update_id = update["update_id"]

                if "message" in update:
                    message = update["message"]["text"]
                    print(f"[CMD] Message reçu : {message}")

                    if message.lower().startswith("/etat"):
                        etat_sondes(cursor, site, chat_id, token)

                    elif message.lower().startswith("/acquitter"):
                        parts = message.strip().split(" ", 1)
                        if len(parts) == 2 and parts[1].strip():
                            sonde = parts[1].strip()
                            acquitter_alerte(cursor, site, sonde, chat_id, token)
                            db.commit()
                        else:
                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /acquitter <nom_sonde>"
                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
                                         params={'chat_id': chat_id, 'text': erreur_msg})
                    elif message.lower().startswith("/maintenance"):
                        parts = message.strip().split(" ", 1)
                        if len(parts) == 2 and parts[1].strip():
                            sonde = parts[1].strip()
                            passer_en_maintenance(cursor, site, sonde, chat_id, token)
                            db.commit()
                        else:
                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /maintenance <nom_sonde>"
                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
                                         params={'chat_id': chat_id, 'text': erreur_msg})
                    elif message.lower().startswith("/reactiver"):
                        parts = message.strip().split(" ", 1)
                        if len(parts) == 2 and parts[1].strip():
                            sonde = parts[1].strip()
                            reactiver_sonde(cursor, site, sonde, chat_id, token)
                            db.commit()
                        else:
                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /reactiver <nom_sonde>"
                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
                                         params={'chat_id': chat_id, 'text': erreur_msg})
                    elif message.lower().startswith("/test"):
                        parts = message.strip().split(" ", 1)
                        if len(parts) == 2 and parts[1].strip():
                            sonde = parts[1].strip()
                            simulate_alert(db, cursor, site, sonde, chat_id, token)
                        else:
                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /test <nom_sonde>"
                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
                                         params={'chat_id': chat_id, 'text': erreur_msg})

                with open(offset_file, 'w') as f:
                    f.write(str(update_id))

    except Exception as e:
        print(f"Erreur lors de la lecture des commandes Telegram : {e}")


def main():
    site = sys.argv[1] if len(sys.argv) > 1 else "Saclay"
    db = connect_db()
    cursor = db.cursor()

    # ✅ Planification : tous les jours à 07:00 → état des sondes
    schedule.every().day.at("07:00").do(envoi_etat_quotidien, cursor=cursor, site=site)

    # ✅ Planification : toutes les 2m30 → surveillance
    schedule.every(2).minutes.do(monitor_temperatures_simple, site=site, db=db, cursor=cursor)

    try:
        while True:
            schedule.run_pending()
            listen_for_commands(db, cursor, site)
            time.sleep(2)  # petite pause pour ne pas surcharger Telegram
    finally:
        cursor.close()
        db.close()

if __name__ == "__main__":
    main()