import gradio as gr
import requests
import os
import json
from typing import List, Dict
from datetime import datetime

# Groq API Configuration
API_URL = "https://api.groq.com/openai/v1/chat/completions"
API_KEY = os.getenv("GROQ_API_KEY")

print(f"🔑 API Key Found: {'Yes' if API_KEY else 'No'}")

# In-memory chat history storage
chat_history: List[Dict[str, str]] = []

def groq_with_memory(message: str, topic: str = "general", summarize: bool = False, max_history: int =10) -> str:
    """Groq API call with chat history and optional summarization"""
    
    if not API_KEY:
        return "❌ No API Key found"
    
    if not message.strip():
        return "❌ Empty message"
    
    try:
        headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }
        
        # Add current message to history with timestamp and topic
        chat_history.append({
            "role": "user",
            "content": message.strip(),
            "topic": topic,
            "timestamp": datetime.now().isoformat()
        })
        
        # Limit history to max_history messages
        recent_history = chat_history[-max_history:]
        
        # Prepare messages for API call
        messages = [{"role": msg["role"], "content": msg["content"]} for msg in recent_history]
        
        if summarize:
            summary_prompt = f"Summarize this conversation about '{topic}':\n\n"
            summary_prompt += "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_history])
            messages.append({"role": "user", "content": summary_prompt})
        
        payload = {
            "model": "gemma2-9b-it",
            "messages": messages,
            "max_tokens":2000,
            "temperature":0.9
        }
        
        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
        
        if response.status_code ==200:
            result = response.json()
            if "choices" in result and result["choices"]:
                response_content = result["choices"][0]["message"]["content"]
                chat_history.append({
                    "role": "assistant",
                    "content": response_content,
                    "topic": topic,
                    "timestamp": datetime.now().isoformat()
                })
                return response_content
            return f"❌ No choices in response: {result}"
        return f"❌ HTTP {response.status_code}: {response.text}"
            
    except Exception as e:
        return f"❌ Error: {str(e)}"

def clear_history():
    """Clear the chat history"""
    global chat_history
    chat_history.clear()
    return "✅ Chat history cleared", ""

def view_history(topic: str = None):
    """View chat history with optional topic filter"""
    if not chat_history:
        return "❌ No chat history available"
    
    filtered = [msg for msg in chat_history if topic is None or msg.get("topic") == topic]
    return "\n".join(
        f"[{msg['timestamp']}] {msg['role'].capitalize()}: {msg['content']}"
        for msg in filtered
    )

# Gradio Interface
with gr.Blocks(title="Groq Chat Interface", theme=gr.themes.Soft(), css="""
    .gradio-container {
        max-width:100% !important;
        padding-left:0px !important;
        padding-right:0px !important;
    }
    .main {
        max-width:100% !important;
        padding:0px !important;
    }
    .block {
        max-width:100% !important;
    }
""") as demo:
    gr.Markdown("## 💬 Groq API Chat Interface")
    
    with gr.Tab("💬 Chat"):
        # Response area at top
        response_output = gr.Textbox(
            label="🤖 AI Response", 
            lines=15,
            interactive=False,
            placeholder="AI responses will appear here...",
            show_copy_button=True
        )
        
        gr.Markdown("---")
        
        # Input area at bottom
        with gr.Row():
            with gr.Column(scale=4):
                msg_input = gr.Textbox(
                    label="✍️ Your Message", 
                    placeholder="Type your message here...",
                    lines=3,
                    max_lines=10
                )
                    
            with gr.Column(scale=1):
                topic_input = gr.Textbox(
                    label="🏷️ Topic", 
                    value="general",
                    placeholder="conversation topic"
                )
                summarize_cb = gr.Checkbox(
                    label="📋 Summarize conversation",
                    value=False
                )
                send_btn = gr.Button("📤 Send Message", variant="primary")
        
        with gr.Row():
            clear_btn = gr.Button("🗑️ Clear Response", variant="secondary")
            history_btn = gr.Button("📚 View History", variant="secondary")
            history_output = gr.Textbox(
                label="📚 Chat History", 
                lines=15,
                interactive=False,
                placeholder="Chat history will appear here..."
            )
        
        # Event handlers - Fixed indentation
        send_btn.click(
            lambda message, topic, summarize: groq_with_memory(message, topic, summarize),
            inputs=[msg_input, topic_input, summarize_cb],
            outputs=[response_output]
        )
        
        msg_input.submit(
            lambda message, topic, summarize: groq_with_memory(message, topic, summarize),
            inputs=[msg_input, topic_input, summarize_cb],
            outputs=[response_output]
        )
        
        clear_btn.click(
            lambda: ("", ""),
            outputs=[response_output, msg_input]
        )
        
        history_btn.click(
            lambda topic: view_history(topic),
            inputs=[topic_input],
            outputs=[history_output]
        )
  

# Launch message
print("🚀 Starting Groq Chat Interface...")
print(f"🌐 Access at: http://localhost:7860")
if API_KEY:
    print("✅ API Key detected - Ready to chat!")
else:
    print("⚠️ No API Key found - Please set GROQ_API_KEY environment variable")

if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0", 
        server_port=7860,
        show_error=True
    )