# File: app.py
# Purpose: Streamlit demo dashboard with real Bland AI call trigger

import streamlit as st
import json
import os
import sys
import requests
from pathlib import Path
from dotenv import load_dotenv

load_dotenv(override=True)

BASE_DIR = Path(__file__).resolve().parent
sys.path.insert(0, str(BASE_DIR))

from config import OUTPUTS_DIR

BLAND_API_KEY = os.getenv("BLAND_API_KEY", "")
DEFAULT_PHONE = os.getenv("PHONE_NUMBER", "")
WEBHOOK_URL = os.getenv("WEBHOOK_URL", "")

st.set_page_config(
    page_title="Hallucination-Safe AI Calling Agent",
    page_icon="🏥",
    layout="wide",
)

st.title("🏥 Hallucination-Safe AI Hospital Calling Agent")
st.caption("Every response is verified by the backend before being communicated to the patient.")

# Sidebar
with st.sidebar:
    st.header("Pipeline Components")
    st.markdown("""
- **Voice**: Bland AI
- **STT**: OpenAI Whisper
- **Agent**: Llama 3.3 70B (Groq)
- **Verification**: In-process booking engine
- **Response**: Template-only (no LLM hallucination)
    """)
    st.divider()
    st.markdown("**System Status**")
    if BLAND_API_KEY:
        st.success("Bland AI key loaded")
    else:
        st.error("BLAND_API_KEY not set in .env")
    if os.getenv("GROQ_API_KEY"):
        st.success("Groq key loaded")
    else:
        st.error("GROQ_API_KEY not set in .env")
    if WEBHOOK_URL:
        st.success("Webhook ready")
    else:
        st.error("WEBHOOK_URL not set in .env")

# Tabs
tab1, tab2, tab3, tab4 = st.tabs(["📞 Call Me", "💬 Text Demo", "📋 Booking Log", "ℹ️ How It Works"])

# Tab 1: Real Call
with tab1:
    st.subheader("Trigger a Real AI Call")

    phone_number = st.text_input(
        "Phone Number",
        value=DEFAULT_PHONE,
        placeholder="+919345521041",
        help="Enter your phone number with country code. e.g. +919345521041",
    )

    st.info(f"Bland AI will call **{phone_number}** and book a hospital appointment through a live conversation.")

    st.markdown("#### The AI will ask you:")
    st.markdown("""
1. Your name
2. Which department you need
3. Preferred date and time slot
    """)

    col1, col2 = st.columns([1, 2])
    with col1:
        if st.button("📞 Call Me Now", type="primary", use_container_width=True):
            if not BLAND_API_KEY:
                st.error("BLAND_API_KEY not set in .env")
                st.stop()
            if not phone_number.strip():
                st.error("Please enter a phone number.")
                st.stop()

            with st.spinner("Initiating call via Bland AI..."):
                try:
                    payload = {
                        "phone_number": phone_number.strip(),
                        "task": (
                            "You are a hospital appointment booking assistant. "
                            "Greet the patient warmly and collect: their full name, "
                            "which department they need (Cardiology, Neurology, Orthopedics, "
                            "Dermatology, General Medicine, Pediatrics, or Psychiatry), "
                            "preferred date, and preferred time slot (9:00 AM, 10:00 AM, "
                            "11:00 AM, 2:00 PM, 3:00 PM, or 4:00 PM). "
                            "Once collected, confirm all details back to the patient and "
                            "tell them the booking is being processed. Be polite and professional."
                        ),
                        "voice": "maya",
                        "wait_for_greeting": True,
                        "record": True,
                        "webhook": WEBHOOK_URL,
                        "max_duration": 5,
                        "answered_by_enabled": True,
                    }

                    response = requests.post(
                        "https://api.bland.ai/v1/calls",
                        headers={
                            "authorization": BLAND_API_KEY,
                            "Content-Type": "application/json",
                        },
                        json=payload,
                        timeout=15,
                    )
                    response.raise_for_status()
                    data = response.json()
                    call_id = data.get("call_id", "unknown")

                    st.success(f"Call initiated! Call ID: `{call_id}`")
                    st.info(f"Your phone ({phone_number}) will ring shortly.")

                    if "call_log" not in st.session_state:
                        st.session_state["call_log"] = []
                    st.session_state["call_log"].append({
                        "call_id": call_id,
                        "phone": phone_number,
                        "status": "initiated",
                    })

                except requests.HTTPError as e:
                    st.error(f"Bland AI error: {e.response.text}")
                except Exception as e:
                    st.error(f"Error: {e}")

    with col2:
        st.markdown("#### What happens after the call:")
        st.code("""
Your phone rings (Bland AI)
     ↓
You speak your request
     ↓
Bland AI sends transcript to webhook
     ↓
Groq extracts booking intent
     ↓
Verification engine checks booking
     ↓
Confirmed appointment_id → Response spoken back
""", language="text")

    st.divider()
    st.markdown("#### Recent Calls")
    call_log = st.session_state.get("call_log", [])
    if call_log:
        import pandas as pd
        st.dataframe(pd.DataFrame(call_log), use_container_width=True)
    else:
        st.info("No calls made yet in this session.")

# Tab 2: Text Demo
with tab2:
    st.subheader("Test Pipeline with Text Input")
    st.caption("Simulates what happens after Bland AI transcribes a call.")

    example = st.selectbox("Load an example transcript", [
        "Custom input...",
        "I'd like to book a cardiology appointment tomorrow at 2 PM. My name is Ranjith Kumar.",
        "Book a neurology slot on 2025-06-10 at 10 AM for Priya Sharma.",
        "Umm I need to see a doctor, maybe some day soon...",
        "Please schedule an orthopedics appointment for 2025-06-15 at 4 PM. Patient is Kavya Nair.",
    ])

    if example == "Custom input...":
        transcript = st.text_area("Enter patient transcript", height=100)
    else:
        transcript = st.text_area("Enter patient transcript", value=example, height=100)

    if st.button("Run Pipeline", type="primary"):
        if not transcript.strip():
            st.warning("Please enter a transcript.")
            st.stop()

        with st.spinner("Running pipeline..."):
            try:
                from src.pipeline import run_pipeline
                result = run_pipeline(transcript)
            except Exception as e:
                st.error(f"Pipeline error: {e}")
                st.stop()

        intent = result.get("intent", {})
        verification = result.get("verification")
        escalated = result.get("escalated", False)

        col1, col2, col3, col4 = st.columns(4)
        col1.metric("Confidence", f"{intent.get('confidence', 0):.0%}")
        col2.metric("Department", intent.get("department", "—"))
        if verification and verification.verified:
            col3.metric("Booking", "Confirmed")
        else:
            col3.metric("Booking", "Failed")
        col4.metric("Escalated", "Yes" if escalated else "No")

        col_left, col_right = st.columns(2)
        with col_left:
            st.subheader("Extracted Intent")
            st.json({
                "patient_name": intent.get("patient_name"),
                "department":   intent.get("department"),
                "date":         intent.get("date"),
                "slot":         intent.get("slot"),
                "confidence":   intent.get("confidence"),
                "missing_info": intent.get("missing_info", []),
            })
        with col_right:
            st.subheader("Verification Result")
            if verification:
                st.json({
                    "verified":       verification.verified,
                    "appointment_id": verification.appointment_id,
                    "doctor":         verification.doctor,
                    "failure_reason": verification.failure_reason,
                    "attempts":       verification.attempts,
                })
            else:
                st.info("Escalated before verification.")

        st.subheader("Patient-Facing Response")
        response = result["response"]
        if verification and verification.verified:
            st.success(f"🔊 {response}")
            st.balloons()
        elif escalated:
            st.warning(f"🔊 {response}")
        else:
            st.error(f"🔊 {response}")

        if "booking_log" not in st.session_state:
            st.session_state["booking_log"] = []
        st.session_state["booking_log"].append({
            "transcript": transcript[:80],
            "department": intent.get("department"),
            "slot": intent.get("slot"),
            "confidence": intent.get("confidence"),
            "verified": verification.verified if verification else None,
            "appointment_id": verification.appointment_id if verification else None,
            "escalated": escalated,
            "response": response[:100],
        })

# Tab 3: Booking Log
with tab3:
    st.subheader("Session Booking Log")
    log = st.session_state.get("booking_log", [])
    if log:
        import pandas as pd
        df = pd.DataFrame(log)
        st.dataframe(df, use_container_width=True)
        st.download_button(
            "Download Log (JSON)",
            data=json.dumps(log, indent=2),
            file_name="booking_log.json",
            mime="application/json",
        )
    else:
        st.info("No bookings yet.")

# Tab 4: How It Works
with tab4:
    st.subheader("Anti-Hallucination Architecture")

    col1, col2 = st.columns(2)
    with col1:
        st.markdown("#### Standard AI Caller (Hallucination Risk)")
        st.code("""
Patient Call
     ↓
  LLM Agent
     ↓
  Response <- LLM may invent confirmation
""", language="text")

    with col2:
        st.markdown("#### This System (Verified)")
        st.code("""
Patient Call (Bland AI)
     ↓
  Whisper STT
     ↓
  LLM Agent (Groq)
     ↓
  Booking Engine
     ↓
  Verification Gate
  appointment_id exists? YES -> Confirmed
                         NO  -> Failure + alternatives
""", language="text")

    st.divider()
    st.markdown("""
| File | Role |
|---|---|
| `src/agent.py` | Llama 3.3 70B via Groq - extracts intent as JSON |
| `src/verification_engine.py` | Anti-hallucination gate - verified=True only with confirmed appointment_id |
| `src/response_generator.py` | Template-only responses - zero LLM generation |
| `src/pipeline.py` | Orchestrates all stages end-to-end |
| `src/bland_webhook.py` | Receives Bland AI call transcript via webhook |
    """)