# lead-engine/trading_twins/manager.py
from email.mime.text import MIMEText
import base64
import requests
import json
import os
import time
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
from threading import Thread, Lock
import uvicorn
from fastapi import FastAPI, Response
import msal

# --- Zeitzonen-Konfiguration ---
TZ_BERLIN = ZoneInfo("Europe/Berlin")

# --- Konfiguration ---
TEAMS_WEBHOOK_URL = os.getenv("TEAMS_WEBHOOK_URL", "https://wacklergroup.webhook.office.com/webhookb2/fe728cde-790c-4190-b1d3-be393ca0f9bd@6d85a9ef-3878-420b-8f43-38d6cb12b665/IncomingWebhook/e9a8ee6157594a6cab96048cf2ea2232/d26033cd-a81f-41a6-8cd2-b4a3ba0b5a01/V2WFmjcbkMzSU4f6lDSdUOM9VNm7F7n1Th4YDiu3fLZ_Y1")
# Öffentliche URL für Feedback-Links
FEEDBACK_SERVER_BASE_URL = os.getenv("FEEDBACK_SERVER_BASE_URL", "https://floke-ai.duckdns.org/feedback")
DEFAULT_WAIT_MINUTES = 5
SENDER_EMAIL = os.getenv("SENDER_EMAIL", "info@robo-planet.de")
TEST_RECEIVER_EMAIL = "floke.com@gmail.com" # Für E2E Tests
SIGNATURE_FILE_PATH = "/app/trading_twins/signature.html"

# Credentials für die Haupt-App (E-Mail & Kalender info@)
AZURE_CLIENT_ID = os.getenv("INFO_Application_ID")
AZURE_CLIENT_SECRET = os.getenv("INFO_Secret")
AZURE_TENANT_ID = os.getenv("INFO_Tenant_ID")

# Credentials für die Kalender-Lese-App (e.melcer)
CAL_APPID = os.getenv("CAL_APPID")
CAL_SECRET = os.getenv("CAL_SECRET")
CAL_TENNANT_ID = os.getenv("CAL_TENNANT_ID")

GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0"

# --- In-Memory-Speicher ---
# Wir speichern hier Details zu jeder Anfrage, um beim Klick auf den Slot reagieren zu können.
request_status_storage = {}
_lock = Lock()

# --- Auth Helper ---
def get_access_token(client_id, client_secret, tenant_id):
    if not all([client_id, client_secret, tenant_id]):
        return None
    authority = f"https://login.microsoftonline.com/{tenant_id}"
    app = msal.ConfidentialClientApplication(client_id=client_id, authority=authority, client_credential=client_secret)
    result = app.acquire_token_silent(["https://graph.microsoft.com/.default"], account=None)
    if not result:
        result = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
    return result.get('access_token')

# --- KALENDER LOGIK ---

def get_availability(target_email: str, app_creds: tuple) -> tuple:
    """Holt die Verfügbarkeit für eine E-Mail über die angegebene App."""
    token = get_access_token(*app_creds)
    if not token: return None
    
    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json", "Prefer": 'outlook.timezone="Europe/Berlin"'}
    
    # Basis: Heute 00:00 Uhr
    start_time = datetime.now(TZ_BERLIN).replace(hour=0, minute=0, second=0, microsecond=0)
    end_time = start_time + timedelta(days=3) # 3 Tage Vorschau
    
    payload = {
        "schedules": [target_email],
        "startTime": {"dateTime": start_time.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "Europe/Berlin"},
        "endTime": {"dateTime": end_time.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "Europe/Berlin"},
        "availabilityViewInterval": 60
    }
    try:
        response = requests.post(f"{GRAPH_API_ENDPOINT}/users/{target_email}/calendar/getSchedule", headers=headers, json=payload)
        if response.status_code == 200:
            view = response.json()['value'][0].get('availabilityView', '')
            # start_time ist wichtig für die Berechnung in find_slots
            return start_time, view, 60
    except: pass
    return None

def round_to_next_quarter_hour(dt: datetime) -> datetime:
    """Rundet eine Zeit auf die nächste volle Viertelstunde auf."""
    minutes = (dt.minute // 15 + 1) * 15
    rounded = dt.replace(minute=0, second=0, microsecond=0) + timedelta(minutes=minutes)
    return rounded

def find_slots(start_time_base: datetime, view: str, interval: int) -> list:
    """
    Findet zwei intelligente Slots basierend auf der Verfügbarkeit.
    start_time_base: Der Beginn der availabilityView (meist 00:00 Uhr heute)
    """
    suggestions = []
    now = datetime.now(TZ_BERLIN)
    
    # Frühestmöglicher Termin: Jetzt + 15 Min Puffer, gerundet auf Viertelstunde
    earliest_possible = round_to_next_quarter_hour(now + timedelta(minutes=15))
    
    def is_slot_free(dt: datetime):
        """Prüft, ob der 60-Minuten-Block, der diesen Zeitpunkt enthält, frei ist."""
        # Index in der View berechnen
        offset = dt - start_time_base
        hours_offset = int(offset.total_seconds() // 3600)
        
        if 0 <= hours_offset < len(view):
            return view[hours_offset] == '0' # '0' bedeutet Free
        return False

    # 1. Slot 1: Nächstmöglicher freier Termin
    current_search = earliest_possible
    while len(suggestions) < 1 and (current_search - now).days < 3:
        # Nur Werktags (Mo-Fr), zwischen 09:00 und 17:00
        if current_search.weekday() < 5 and 9 <= current_search.hour < 17:
            if is_slot_free(current_search):
                suggestions.append(current_search)
                break
        
        # Weiterspringen
        current_search += timedelta(minutes=15)
        # Wenn wir 17 Uhr erreichen, springe zum nächsten Tag 09:00
        if current_search.hour >= 17:
            current_search += timedelta(days=1)
            current_search = current_search.replace(hour=9, minute=0)

    if not suggestions:
        return []

    first_slot = suggestions[0]

    # 2. Slot 2: Alternative (Nachmittag oder Folgetag)
    # Ziel: 2-3 Stunden später
    target_slot_2 = first_slot + timedelta(hours=2.5)
    target_slot_2 = round_to_next_quarter_hour(target_slot_2)
    
    # Suchstart für Slot 2
    current_search = target_slot_2
    
    while len(suggestions) < 2 and (current_search - now).days < 4:
        # Kriterien für Slot 2:
        # - Muss frei sein
        # - Muss Werktag sein
        # - Bevorzugt Nachmittag (13:00 - 16:30), außer wir sind schon am Folgetag, dann ab 9:00
        
        is_working_hours = 9 <= current_search.hour < 17
        is_afternoon = 13 <= current_search.hour < 17
        is_next_day = current_search.date() > first_slot.date()
        
        # Wir nehmen den Slot, wenn:
        # a) Er am selben Tag nachmittags ist
        # b) ODER er am nächsten Tag zu einer vernünftigen Zeit ist (falls wir heute zu spät sind)
        valid_time = (current_search.date() == first_slot.date() and is_afternoon) or (is_next_day and is_working_hours)

        if current_search.weekday() < 5 and valid_time:
             if is_slot_free(current_search):
                suggestions.append(current_search)
                break
        
        current_search += timedelta(minutes=15)
        if current_search.hour >= 17:
            current_search += timedelta(days=1)
            current_search = current_search.replace(hour=9, minute=0)

    return suggestions

def create_calendar_invite(lead_email: str, company_name: str, start_time: datetime):
    """Sendet eine echte Outlook-Kalendereinladung aus dem info@-Kalender."""
    # Wir erstellen den Termin bei info@ (SENDER_EMAIL), da wir dort Schreibrechte haben sollten.
    target_organizer = SENDER_EMAIL
    print(f"INFO: Creating calendar invite for {lead_email} in {target_organizer}'s calendar")
    
    token = get_access_token(AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID)
    if not token: return False

    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
    end_time = start_time + timedelta(minutes=15)
    
    event_payload = {
        "subject": f"Kennenlerngespräch RoboPlanet <> {company_name}",
        "body": {"contentType": "HTML", "content": f"Hallo, <br><br>vielen Dank für die Terminbuchung über unsere Lead-Engine. Wir freuen uns auf das Gespräch!<br><br>Beste Grüße,<br>RoboPlanet Team"},
        "start": {"dateTime": start_time.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "Europe/Berlin"},
        "end": {"dateTime": end_time.strftime("%Y-%m-%dT%H:%M:%S"), "timeZone": "Europe/Berlin"},
        "location": {"displayName": "Microsoft Teams Meeting"},
        "attendees": [
            {"emailAddress": {"address": lead_email, "name": "Interessent"}, "type": "required"},
            {"emailAddress": {"address": "e.melcer@robo-planet.de", "name": "Elizabeta Melcer"}, "type": "required"}
        ],
        "isOnlineMeeting": True,
        "onlineMeetingProvider": "teamsForBusiness"
    }
    
    # URL zeigt auf info@ Kalender
    url = f"{GRAPH_API_ENDPOINT}/users/{target_organizer}/calendar/events"
    try:
        resp = requests.post(url, headers=headers, json=event_payload)
        if resp.status_code in [200, 201]:
            print(f"SUCCESS: Calendar event created for {target_organizer}.")
            return True
        else:
            print(f"ERROR: Failed to create event. HTTP {resp.status_code}: {resp.text}")
            return False
    except Exception as e:
        print(f"EXCEPTION during event creation: {e}")
        return False

# --- E-MAIL & WEB LOGIK ---

def generate_booking_html(request_id: str, suggestions: list) -> str:
    html = "<p>Bitte wählen Sie einen passenden Termin für ein 15-minütiges Kennenlerngespräch:</p><ul>"
    for slot in suggestions:
        ts = int(slot.timestamp())
        # Link zu unserem eigenen Bestätigungs-Endpunkt
        link = f"{FEEDBACK_SERVER_BASE_URL}/book_slot/{request_id}/{ts}"
        html += f'<li><a href="{link}" style="font-weight: bold; color: #0078d4;">{slot.strftime("%d.%m. um %H:%M Uhr")}</a></li>'
    html += "</ul><p>Mit Klick auf einen Termin wird automatisch eine Kalendereinladung an Sie versendet.</p>"
    return html

# --- Server & API ---
app = FastAPI()

@app.get("/stop/{request_id}")
async def stop(request_id: str):
    with _lock:
        if request_id in request_status_storage:
            request_status_storage[request_id]["status"] = "cancelled"
            return Response("<html><body><h1>Versand gestoppt.</h1></body></html>", media_type="text/html")
    return Response("Ungültig.", status_code=404)

@app.get("/send_now/{request_id}")
async def send_now(request_id: str):
    with _lock:
        if request_id in request_status_storage:
            request_status_storage[request_id]["status"] = "send_now"
            return Response("<html><body><h1>E-Mail wird sofort versendet.</h1></body></html>", media_type="text/html")
    return Response("Ungültig.", status_code=404)

@app.get("/book_slot/{request_id}/{ts}")
async def book_slot(request_id: str, ts: int):
    slot_time = datetime.fromtimestamp(ts, tz=TZ_BERLIN)
    with _lock:
        data = request_status_storage.get(request_id)
        if not data: return Response("Anfrage nicht gefunden.", status_code=404)
        if data.get("booked"): return Response("<html><body><h1>Termin wurde bereits bestätigt.</h1></body></html>", media_type="text/html")
        data["booked"] = True
    
    # Einladung senden
    success = create_calendar_invite(data['receiver'], data['company'], slot_time)
    if success:
        return Response(f"<html><body><h1>Vielen Dank!</h1><p>Die Einladung für den <b>{slot_time.strftime('%d.%m. um %H:%M')}</b> wurde an {data['receiver']} versendet.</p></body></html>", media_type="text/html")
    return Response("Fehler beim Erstellen des Termins.", status_code=500)

# --- Haupt Workflow ---

def send_email(subject, body, to_email, signature):
    token = get_access_token(AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID)
    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
    payload = {"message": {"subject": subject, "body": {"contentType": "HTML", "content": body + signature}, "toRecipients": [{"emailAddress": {"address": to_email}}]}, "saveToSentItems": "true"}
    requests.post(f"{GRAPH_API_ENDPOINT}/users/{SENDER_EMAIL}/sendMail", headers=headers, json=payload)

def process_lead(request_id: str, company: str, opener: str, receiver: str):
    # 1. Freie Slots finden (Check bei e.melcer UND info)
    print(f"INFO: Searching slots for {company}...")
    # Wir nehmen hier e.melcer als Referenz für die Zeit
    cal_data = get_availability("e.melcer@robo-planet.de", (CAL_APPID, CAL_SECRET, CAL_TENNANT_ID))
    suggestions = find_slots(*cal_data) if cal_data else []
    
    with _lock:
        request_status_storage[request_id] = {"status": "pending", "company": company, "receiver": receiver, "slots": suggestions}

    # 2. Teams Notification
    send_time = datetime.now(TZ_BERLIN) + timedelta(minutes=DEFAULT_WAIT_MINUTES)
    card = {
        "type": "message", "attachments": [{"contentType": "application/vnd.microsoft.card.adaptive", "content": {
            "type": "AdaptiveCard", "version": "1.4", "body": [
                {"type": "TextBlock", "text": f"🤖 E-Mail an {company} ({receiver}) geplant für {send_time.strftime('%H:%M')}", "weight": "Bolder"},
                {"type": "TextBlock", "text": f"Vorgeschlagene Slots: {', '.join([s.strftime('%H:%M') for s in suggestions])}", "isSubtle": True}
            ],
            "actions": [
                {"type": "Action.OpenUrl", "title": "❌ STOP", "url": f"{FEEDBACK_SERVER_BASE_URL}/stop/{request_id}"},
                {"type": "Action.OpenUrl", "title": "✅ JETZT", "url": f"{FEEDBACK_SERVER_BASE_URL}/send_now/{request_id}"}
            ]
        }}]
    }
    requests.post(TEAMS_WEBHOOK_URL, json=card)
    
    # 3. Warten
    while datetime.now(TZ_BERLIN) < send_time:
        with _lock:
            if request_status_storage[request_id]["status"] in ["cancelled", "send_now"]:
                break
        time.sleep(5)
    
    # 4. Senden
    with _lock:
        if request_status_storage[request_id]["status"] == "cancelled": return
    
    print(f"INFO: Sending lead email to {receiver}...")
    booking_html = generate_booking_html(request_id, suggestions)
    with open(SIGNATURE_FILE_PATH, 'r') as f: sig = f.read()
    body = f"<p>Sehr geehrte Damen und Herren,</p><p>{opener}</p>{booking_html}"
    send_email(f"Ihr Kontakt mit RoboPlanet - {company}", body, receiver, sig)

if __name__ == "__main__":
    # Starte den API-Server im Hintergrund
    Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=8004), daemon=True).start()
    print("INFO: Trading Twins Feedback Server started on port 8004.")
    time.sleep(2)

    # Optional: E2E Test Lead auslösen
    if os.getenv("RUN_TEST_LEAD") == "true":
        print("\n--- Running E2E Test Lead ---")
        process_lead(f"req_{int(time.time())}", "Testfirma GmbH", "Wir haben Ihre Anfrage erhalten.", TEST_RECEIVER_EMAIL)
    
    print("\n[PROD] Manager is active and waiting for leads via import or API.")
    try:
        while True: time.sleep(1)
    except KeyboardInterrupt:
        print("Shutting down.")