import os, threading, hmac
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
from flask import Flask, render_template, request, jsonify, Response
from flask_socketio import SocketIO
from dotenv import load_dotenv
from services.audio import listen_once, speak_async, tts_backend_detect
from services.wakeword import WakeWordListener
from services import admin_console  # ALFRED_ADMIN_PAGES_V1
from services.hermes_client import ask_hermes
from services import alfred_features  # ALFRED_FEATURES_V45
from services import audio_settings  # ALFRED_AUDIO_SETTINGS_V1
from services.camera import video_stream
from services import ha_views, alfred_views_controller
from services import camera_settings, ha_weather, weather_outfits

load_dotenv()

load_dotenv(os.path.join(os.path.dirname(__file__), "config", "control_center.env"), override=True)  # ALFRED_ADMIN_PAGES_V1
##
from services.audio import get_vosk_model
print("[ALFRED] Préchargement des modèles vocaux...", flush=True)
get_vosk_model(os.environ["WAKE_VOSK_MODEL_PATH"])
get_vosk_model(os.environ["VOSK_MODEL_PATH"])
print("[ALFRED] Modèles vocaux prêts.", flush=True)
##
app=Flask(__name__); socketio=SocketIO(app,cors_allowed_origins="*")
STATE={"mode":"idle","title":"Alfred","content":{"type":"text","text":"À votre écoute."},"partial":""}
STATE_LOCK = threading.RLock()
IMAGE_REVISION = 0  # Incrémenté à chaque image envoyée par ComfyUI.
conversation_lock=threading.Lock()
mic_stop_event=threading.Event()
audio_settings.initialize()
audio_settings.update_settings({"mic_gain": 30})
# Recharge les réglages V4L2 enregistrés, sans interrompre Alfred si la webcam est absente.
camera_settings.restore_saved_settings()

def emit_state(mode=None, **extra):
    with STATE_LOCK:
        if mode: STATE["mode"] = mode
        STATE.update(extra)
        socketio.emit("alfred_state", dict(STATE))

def audio_level(level): socketio.emit("audio_level",{"level":max(0,min(float(level),1))})

def conversation(score=1.0):
    if not conversation_lock.acquire(blocking=False):
        return

    try:
        emit_state("listening", partial="", transcript="", wake_score=score)

        print("[ALFRED] Début écoute STT", flush=True)

        r = listen_once(
            stop_event=mic_stop_event,
            on_partial=lambda p: emit_state("listening", partial=p),
            on_level=audio_level
        )

        print(f"[ALFRED] Résultat STT : {r.text!r}, erreur : {r.error!r}", flush=True)

        if audio_settings.mic_muted():
            emit_state("idle", partial="")
            return

        if r.error:
            emit_state(
                "error",
                content={"type": "text", "text": r.error}
            )
            return

        if not r.text:
            emit_state("idle", partial="")
            return

        emit_state(
            "thinking",
            partial="",
            transcript=r.text,
            content={"type": "text", "text": r.text}
        )

        # Vue dynamique : commandes déterministes exécutées sans faire
        # dépendre l'affichage des capacités ou sessions Hermes.
        visual = None
        try:
            visual = alfred_views_controller.route(r.text, (STATE.get('content') or {}).get('type'))
        except (ha_views.HAError, ValueError) as exc:
            print(f"[ALFRED] Vue indisponible : {exc}", flush=True)
            visual = ({"type":"text", "text":str(exc)}, str(exc))

        if visual is not None:
            content, speech = visual
            with STATE_LOCK:
                STATE["content"] = content
                socketio.emit("alfred_render", content)
            if speech and not audio_settings.speaker_muted():
                emit_state("speaking")
                done = threading.Event()
                speak_async(speech, on_end=done.set)
                done.wait(timeout=120)
            emit_state("idle", partial="")
            return

        print("[ALFRED] Envoi à Hermes", flush=True)
        # ComfyUI publie l'image pendant cet appel Hermes.
        with STATE_LOCK:
            image_revision_before = IMAGE_REVISION
        # ALFRED_FEATURES_V45 voice opt-in background mode
        if alfred_features.should_run_in_background(r.text):
            try:
                alfred_features.submit(r.text, source='voice')
                emit_state('idle', partial='', content={
                    'type': 'text',
                    'text': 'Hermes travaille sur la demande. Le résultat apparaîtra dans les cartes.'
                })
            except ValueError as exc:
                emit_state('error', content={'type': 'text', 'text': str(exc)})
            return
        answer = ask_hermes(r.text)
        print(f"[ALFRED] Réponse Hermes : {answer!r}", flush=True)
        if isinstance(answer, dict):
            speech = str(answer.get("speech") or answer.get("text") or "")
            display = answer.get("display") or {
                "type": "text",
                "text": speech
            }
        else:
            speech = str(answer or "")
            display = {"type": "text", "text": speech}

        # Si le MCP ComfyUI a affiché une image pendant la requête,
        # ne pas l'écraser par la réponse textuelle d'Hermes.
        with STATE_LOCK:
            if IMAGE_REVISION == image_revision_before:
                STATE["content"] = display
                alfred_features.publish_voice_display(display)
                socketio.emit("alfred_render", display)
            else:
                print("[ALFRED] Image ComfyUI conservée à l'écran", flush=True)

        if speech and not audio_settings.speaker_muted():
            emit_state("speaking")
            done = threading.Event()
            speak_async(speech, on_end=done.set)
            done.wait(timeout=120)

        emit_state("idle", partial="")

    except Exception as exc:
        print(f"[ALFRED] Erreur conversation : {exc}", flush=True)
        emit_state(
            "error",
            content={"type": "text", "text": str(exc)}
        )

    finally:
        conversation_lock.release()
        if not audio_settings.mic_muted():
            wake.resume()
            print("[ALFRED] Wake word réactivé", flush=True)



def on_wake(score):
    if audio_settings.mic_muted():
        return
    socketio.emit("wake_detected",{"word":os.getenv("WAKE_WORD","alfred"),"score":score})
    threading.Thread(target=conversation,args=(score,),daemon=True).start()

wake=WakeWordListener(on_wake=on_wake,on_level=lambda l: audio_level(l if STATE["mode"]!="idle" else l*.18))

admin_console.register_admin_console(app, wake, audio_settings)  # ALFRED_ADMIN_PAGES_V1
@app.get('/api/audio/settings')
def get_audio_settings():
    return jsonify(audio_settings.get_settings())

@app.post('/api/audio/settings')
def set_audio_settings():
    data = request.get_json(silent=True)
    try:
        old = audio_settings.get_settings()
        new = audio_settings.update_settings(data)
    except ValueError as exc:
        return jsonify({'error': str(exc)}), 400
    except Exception as exc:
        return jsonify({'error': f'ALSA : {exc}'}), 500
    if new['mic_muted'] != old['mic_muted']:
        if new['mic_muted']:
            mic_stop_event.set()
            wake.pause()
        else:
            mic_stop_event.clear()
            if not conversation_lock.locked():
                wake.resume()
    socketio.emit('audio_settings', new)
    return jsonify(new)

@app.get('/api/camera/settings')
def get_camera_settings():
    try:
        return jsonify(camera_settings.get_settings())
    except camera_settings.CameraSettingsError as exc:
        return jsonify({'error': str(exc)}), 503

@app.post('/api/camera/settings')
def set_camera_settings():
    # Même garde-fou que les commandes calendrier existantes.
    if not _same_origin_json():
        return jsonify({'error': 'Requête non autorisée.'}), 403
    data = request.get_json(silent=True)
    if not isinstance(data, dict):
        return jsonify({'error': 'JSON invalide.'}), 400
    try:
        result = camera_settings.update_setting(data.get('control'), data.get('value'))
        socketio.emit('camera_settings', result)
        return jsonify(result)
    except ValueError as exc:
        return jsonify({'error': str(exc)}), 400
    except camera_settings.CameraSettingsError as exc:
        return jsonify({'error': str(exc)}), 503

@app.post('/api/camera/reset')
def reset_camera_settings():
    if not _same_origin_json():
        return jsonify({'error': 'Requête non autorisée.'}), 403
    try:
        result = camera_settings.reset_defaults()
        socketio.emit('camera_settings', result)
        return jsonify(result)
    except camera_settings.CameraSettingsError as exc:
        return jsonify({'error': str(exc)}), 503

@app.get('/api/camera/stream')
def camera_stream():
    # Flux MJPEG à la demande ; ne démarre jamais la webcam en arrière-plan.
    try:
        frames = video_stream(index=int(os.getenv('CAMERA_INDEX', '0')))
    except (ImportError, ValueError, RuntimeError, OSError) as exc:
        return jsonify({'error': str(exc)}), 503
    return Response(
        frames,
        mimetype='multipart/x-mixed-replace; boundary=frame',
        headers={'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff'}
    )

# ALFRED_FEATURES_V45 init
alfred_features.init_app(app, ask_hermes, socketio=socketio)

@app.get("/")
def index(): return render_template("index.html",name=os.getenv("ALFRED_NAME","Alfred"))
@app.get("/api/state")
def state():
    with STATE_LOCK:
        snapshot = dict(STATE)
    return jsonify({**snapshot, "wake": wake.status(), "tts": tts_backend_detect()})

@app.post("/api/state")
def set_state():
    data = request.get_json(force=True)
    with STATE_LOCK:
        STATE.update(data)
        socketio.emit("alfred_state", dict(STATE))
    return jsonify({"ok": True})
@app.post("/api/render")
def render_payload():
    global IMAGE_REVISION
    token = os.getenv("ALFRED_RENDER_TOKEN", "").strip()
    if token and not hmac.compare_digest(
        request.headers.get("X-Alfred-Render-Token", ""), token
    ):
        return jsonify({"ok": False, "error": "Non autorisé"}), 401

    data = request.get_json(silent=True)
    if not isinstance(data, dict):
        return jsonify({"ok": False, "error": "JSON objet attendu"}), 400
    if data.get("type") == "image":
        image_url = data.get("url")
        if not isinstance(image_url, str) or not (
            image_url.startswith(("http://", "https://", "/"))
            and not image_url.startswith("//")
        ):
            return jsonify({"ok": False, "error": "URL image invalide"}), 400

    with STATE_LOCK:
        if data.get("type") == "image":
            IMAGE_REVISION += 1
        STATE["content"] = data
        socketio.emit("alfred_render", data)
        return jsonify({"ok": True, "image_revision": IMAGE_REVISION})
# --- Agenda / capteurs / caméras Home Assistant ---
def _calendar_range():
    tz = ZoneInfo(os.getenv('ALFRED_TIMEZONE', 'Europe/Paris'))
    now = datetime.now(tz)
    def parse(name, default):
        raw = request.args.get(name)
        if not raw:return default
        value = datetime.fromisoformat(raw.replace('Z','+00:00'))
        if value.tzinfo is None: value = value.replace(tzinfo=tz)
        return value.astimezone(tz)
    start = parse('start',now.replace(hour=0,minute=0,second=0,microsecond=0))
    end = parse('end',start+timedelta(days=7))
    return start,end

def _json_error(exc):
    code = 400 if isinstance(exc,ValueError) else 502
    return jsonify({'error':str(exc)}),code

def _writes_enabled():
    return os.getenv('ALFRED_ALLOW_CALENDAR_WRITES','false').lower() in ('1','true','yes')

def _same_origin_json():
    # POSTs require a custom header and same-origin browser requests.
    if request.headers.get('X-Alfred-Request') != '1':return False
    origin=request.headers.get('Origin')
    if origin and origin.rstrip('/') != request.host_url.rstrip('/'):return False
    return True

@app.get('/api/calendar/calendars')
def calendars_list():
    try:return jsonify({'calendars':ha_views.list_calendars(),'writes_enabled':_writes_enabled()})
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.get('/api/calendar/events')
def calendar_events():
    try:
        start,end=_calendar_range()
        selected=request.args.getlist('calendar_id')
        return jsonify(ha_views.get_events(start,end,selected or None))
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.post('/api/calendar/create')
def calendar_create():
    if not _same_origin_json():return jsonify({'error':'Requête non autorisée.'}),403
    if not _writes_enabled():return jsonify({'error':'Écriture calendrier désactivée (ALFRED_ALLOW_CALENDAR_WRITES).'}),403
    data=request.get_json(silent=True)
    if not isinstance(data,dict):return jsonify({'error':'JSON invalide.'}),400
    try:
        tz=ZoneInfo(os.getenv('ALFRED_TIMEZONE','Europe/Paris'))
        def read_dt(key):
            dt=datetime.fromisoformat(str(data[key]).replace('Z','+00:00'))
            return dt.replace(tzinfo=tz) if dt.tzinfo is None else dt.astimezone(tz)
        result=ha_views.create_event(str(data.get('calendar_id','')),str(data.get('title','')),
            read_dt('start'),read_dt('end'),str(data.get('description') or ''),
            str(data.get('location') or ''),bool(data.get('all_day',False)))
        from services import alfred_intents
        alfred_intents.clear_create()
        socketio.emit('calendar_changed', {'type':'created'})
        return jsonify(result)
    except (ha_views.HAError,ValueError,KeyError) as exc:return _json_error(exc)

@app.post('/api/calendar/delete')
def calendar_delete():
    if not _same_origin_json():return jsonify({'error':'Requête non autorisée.'}),403
    if not _writes_enabled():return jsonify({'error':'Écriture calendrier désactivée.'}),403
    data=request.get_json(silent=True)
    if not isinstance(data,dict):return jsonify({'error':'JSON invalide.'}),400
    try:
        eid=str(data.get('calendar_id',''));uid=str(data.get('uid',''))
        start=datetime.fromisoformat(str(data['start']))
        end=datetime.fromisoformat(str(data['end']))
        if start.tzinfo is None or end.tzinfo is None:raise ValueError('Date avec fuseau requise.')
        matches=ha_views.get_events(start-timedelta(days=1),end+timedelta(days=1),[eid])['events']
        rid=str(data.get('recurrence_id') or '')
        if not any(e['id']==uid and e['start']==start.isoformat() and e['recurrence_id']==rid for e in matches):
            return jsonify({'error':'Événement introuvable ou modifié ; actualise le planning.'}),409
        result=ha_views.delete_event(eid,uid,rid or None)
        from services import alfred_intents
        alfred_intents.clear_delete()
        socketio.emit('calendar_changed',{'type':'deleted'})
        return jsonify(result)
    except (ha_views.HAError,ValueError,KeyError) as exc:return _json_error(exc)

@app.get('/api/ha/weather')
def ha_weather_data():
    # Read-only route, token always stays on the Alfred server.
    try:
        q = request.args.get('q', '')
        return jsonify(ha_weather.get_weather(q))
    except (ha_views.HAError, ValueError) as exc:
        return _json_error(exc)

@app.get('/api/ha/weather/outfits')
def ha_weather_outfits_data():
    try:
        q = request.args.get('q', '')
        refresh = request.args.get('refresh_illustration', '').lower() in ('1','true','yes','on')
        return jsonify(weather_outfits.build_payload(q=q, date=request.args.get('date', ''), label=request.args.get('label', ''), refresh=refresh))
    except (ha_views.HAError, ValueError, RuntimeError) as exc:
        return _json_error(exc)

@app.get('/api/ha/temperatures')
def ha_temperatures():
    try:return jsonify({'items':ha_views.get_temperatures()})
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.get('/api/ha/temperature/history')
def ha_temperature_history():
    try:
        eid=request.args.get('entity_id','')
        hours=int(request.args.get('hours','24'))
        return jsonify({'items':ha_views.temperature_history(eid,hours)})
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.get('/api/ha/cameras')
def ha_cameras():
    try:return jsonify({'items':ha_views.list_cameras()})
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.get('/api/ha/camera/<path:entity_id>/snapshot')
def ha_camera_snapshot(entity_id):
    try:
        binary,mime=ha_views.camera_snapshot(entity_id)
        return Response(binary,mimetype=mime,headers={'Cache-Control':'no-store','X-Content-Type-Options':'nosniff'})
    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)

@app.post('/api/ui/home')
def ui_home():
    with STATE_LOCK:
        STATE['content']={'type':'home','text':'À ton écoute.'}
        socketio.emit('alfred_render',STATE['content'])
    return jsonify({'ok':True})

@app.post("/api/audio-level")
def api_audio_level(): audio_level((request.get_json(force=True) or {}).get("level",0)); return jsonify({"ok":True})
@app.get("/api/wake/status")
def wake_status(): return jsonify(wake.status())
@app.post("/api/wake/start")
def wake_start(): wake.start(); return jsonify({"ok":True,**wake.status()})
@app.post("/api/wake/stop")
def wake_stop(): wake.stop(); return jsonify({"ok":True,**wake.status()})
@app.post("/api/tts/say")
def tts_say():
    text=(request.get_json(silent=True) or {}).get("text",""); return jsonify({"ok":speak_async(text)})

if __name__ == "__main__":
    if os.getenv("WAKE_ENABLED","true").lower() in ("1","true","yes","on") and not audio_settings.mic_muted(): wake.start()
    socketio.run(app,host=os.getenv("FLASK_HOST","0.0.0.0"),port=int(os.getenv("FLASK_PORT","54321")),allow_unsafe_werkzeug=True)