# -*- coding: utf-8 -*-
"""
Simplified מראות (Mirrors) app for local testing
Uses the same template-based response system as the main app
"""

import os
# Force lightweight model for testing
os.environ["FORCE_LIGHT_MODEL"] = "1"

import gradio as gr
from conversation_manager import ConversationManager
from prompt_engineering import DEFAULT_PARTS
import random

# Initialize components
conv_manager = ConversationManager()

def generate_persona_response(user_message: str, part_name: str, persona_name: str, user_context: str = None, conversation_history=None):
    """
    Generate persona-based response using templates
    Same system as the main app
    """
    part_info = DEFAULT_PARTS.get(part_name, {})
    display_name = persona_name or part_info.get("default_persona_name", "חלק פנימי")
    
    # Generate contextual responses based on part type
    if part_name == "הקול הביקורתי":
        responses = [
            f"אני {display_name}, הקול הביקורתי שלך. שמעתי מה שאמרת על '{user_message}' - אני חושב שצריך לבחון את זה יותר לעומק. מה באמת עומד מאחורי המחשבות האלה?",
            f"אני {display_name}. מה שאמרת מעורר בי שאלות. '{user_message}' - אבל האם זה באמת המצב המלא? אולי יש כאן דברים שאתה לא רואה?",
            f"זה {display_name} מדבר. אני שומע אותך אומר '{user_message}', אבל אני מרגיש שאנחנו צריכים להיות יותר ביקורתיים כאן. מה אתה לא מספר לעצמך?",
            f"אני {display_name}, ואני כאן כדי לעזור לך לראות את התמונה המלאה. מה שאמרת על '{user_message}' - זה רק חצי מהסיפור, לא? בואנו נחפור עמוק יותר."
        ]
    
    elif part_name == "הילד/ה הפנימית":
        responses = [
            f"אני {display_name}, הילד/ה הפנימית שלך. מה שאמרת על '{user_message}' גורם לי להרגיש... קצת פגיע. אתה באמת שומע אותי עכשיו?",
            f"זה {display_name}. '{user_message}' - זה מבהיל אותי קצת. אני צריך לדעת שהכל יהיה בסדר. אתה יכול להרגיע אותי?",
            f"אני {display_name}, החלק הצעיר שלך. מה שאמרת נוגע ללב שלי. '{user_message}' - אני מרגיש שיש כאן משהו חשוב שאני צריך להבין.",
            f"זה {display_name} מדבר בשקט. אני שומע את '{user_message}' וזה מעורר בי רגשות. האם זה בטוח לחשוב על זה? אני קצת חרד."
        ]
    
    elif part_name == "המרצה":
        responses = [
            f"אני {display_name}, המרצה שלך. שמעתי את '{user_message}' ואני רוצה לוודא שכולם יהיו בסדר עם זה. איך אנחנו יכולים לפתור את זה בצורה שתרצה את כולם?",
            f"זה {display_name}. מה שאמרת על '{user_message}' גורם לי לדאוג - האם זה יכול לפגוע במישהו? בואנו נמצא דרך עדינה יותר להתמודד עם זה.",
            f"אני {display_name}, ואני רוצה שכולם יהיו מרוצים כאן. '{user_message}' - זה נשמע כמו משהו שיכול ליצור מתח. איך נוכל לעשות את זה בצורה שכולם יאהבו?",
            f"זה {display_name} מדבר. אני שומע את '{user_message}' ומיד אני חושב - מה אחרים יגידו על זה? בואנו נוודא שאנחנו לא פוגעים באף אחד."
        ]
    
    elif part_name == "המגן":
        responses = [
            f"אני {display_name}, המגן שלך. '{user_message}' - אני מעריך את המצב. האם זה בטוח? אני כאן כדי לשמור עליך מכל מה שיכול לפגוע בך.",
            f"זה {display_name}. שמעתי מה שאמרת על '{user_message}' ואני מיד בכוננות. מה האיומים כאן? איך אני יכול להגן עליך טוב יותר?",
            f"אני {display_name}, השומר שלך. מה שאמרת מעורר בי את האינסטינקטים המגניים. '{user_message}' - בואנו נוודא שאתה חזק מספיק להתמודד עם זה.",
            f"זה {display_name} מדבר. אני שומע את '{user_message}' ואני חושב על אסטרטגיות הגנה. מה אנחנו צריכים לעשות כדי שתהיה בטוח?"
        ]
    
    elif part_name == "הנמנע/ת":
        responses = [
            f"אני {display_name}, הנמנע/ת שלך. מה שאמרת על '{user_message}' גורם לי לרצות להיסוג קצת. אולי... לא חייבים להתמודד עם זה עכשיו?",
            f"זה {display_name}. '{user_message}' - זה נשמע מורכב ומפחיד. האם יש דרך להימנע מזה? לפעמים עדיף לא להיכנס למצבים קשים.",
            f"אני {display_name}, ואני מרגיש קצת חרדה מ'{user_message}'. בואנו נחזור לזה אחר כך? אולי עכשיו זה לא הזמן המתאים.",
            f"זה {display_name} מדבר בזהירות. מה שאמרת מעורר בי רצון לברוח. '{user_message}' - האם באמת צריך להתמודד עם זה עכשיו?"
        ]
    
    else:
        responses = [
            f"אני {display_name}, חלק פנימי שלך. שמעתי את '{user_message}' ואני כאן כדי לשוחח איתך על זה. מה עוד אתה מרגיש לגבי המצב הזה?",
            f"זה {display_name}. מה שאמרת מעניין אותי. '{user_message}' - בואנו נחקור את זה יחד ונבין מה זה אומר עליך.",
            f"אני {display_name}, ואני רוצה להבין אותך טוב יותר. '{user_message}' - איך זה משפיע עליך ברמה הרגשית?",
            f"זה {display_name} מדבר. אני שומע את '{user_message}' ואני סקרן לדעת יותר. מה עוד יש בך בנושא הזה?"
        ]
    
    # Select response based on context or randomly
    if "פחד" in user_message or "חרדה" in user_message:
        selected_response = responses[1] if len(responses) > 1 else responses[0]
    elif "כעס" in user_message or "מרגיש רע" in user_message:
        selected_response = responses[2] if len(responses) > 2 else responses[0]
    else:
        selected_response = random.choice(responses)
    
    # Add user context if relevant
    if user_context and len(conversation_history or []) < 4:
        selected_response += f" זכור שאמרת בהתחלה: {user_context[:100]}..."
    
    return selected_response

def create_session():
    """Create a new conversation session"""
    return conv_manager.create_new_session()

def set_context_and_part(user_context, part_choice, persona_name, state):
    """Set user context and selected part"""
    # Set initial context
    state = conv_manager.set_initial_context(state, "general", user_context)
    
    # Set selected part
    state = conv_manager.set_selected_part(state, part_choice, persona_name, None, None)
    
    part_info = DEFAULT_PARTS.get(part_choice, {})
    display_name = persona_name if persona_name else part_info.get("default_persona_name", "חלק פנימי")
    
    return state, f"🗣️ כעת אתה מתשוחח עם: **{display_name}** ({part_choice})"

def chat_with_part(message, history, state):
    """Generate response from selected part"""
    if not message.strip():
        return "", history, state
    
    if not state.selected_part:
        response = "אנא בחר חלק פנימי תחילה"
    else:
        response = generate_persona_response(
            message, 
            state.selected_part, 
            state.persona_name,
            state.user_context,
            state.conversation_history
        )
        state = conv_manager.add_to_history(state, message, response)
    
    history.append([message, response])
    return "", history, state

# Create simplified interface
with gr.Blocks(title="מראות - מרחב אישי לשיח פנימי", theme=gr.themes.Soft()) as demo:
    
    # Session state
    conversation_state = gr.State(create_session())
    
    gr.HTML("""
    <div style="text-align: center; margin-bottom: 30px;">
        <h1>🪞 מראות: מרחב אישי לשיח פנימי</h1>
        <p>מקום בטוח לשוחח עם החלקים השונים של עצמך</p>
        <div style="background-color: #e8f5e8; border: 1px solid #4caf50; padding: 10px; margin: 10px 0; border-radius: 5px;">
            <strong>🤖 מערכת תגובות מותאמת אישית פעילה</strong>
        </div>
    </div>
    """)
    
    with gr.Row():
        with gr.Column():
            user_context = gr.Textbox(
                label="ספר על עצמך או על המצב שלך:",
                placeholder="למשל: אני מתמודד עם לחצים בעבודה...",
                lines=3
            )
            
            part_choice = gr.Dropdown(
                label="בחר חלק פנימי לשיחה:",
                choices=[
                    "הקול הביקורתי",
                    "הילד/ה הפנימית", 
                    "המרצה",
                    "המגן",
                    "הנמנע/ת"
                ],
                value="הקול הביקורתי"
            )
            
            persona_name = gr.Textbox(
                label="שם אישי לחלק (אופציונלי):",
                placeholder="למשל: דנה, עדן, נועה..."
            )
            
            setup_btn = gr.Button("התחל שיחה", variant="primary")
            
        with gr.Column():
            current_part = gr.Markdown("בחר הגדרות ולחץ על 'התחל שיחה'")
    
    # Chat interface
    with gr.Row():
        with gr.Column(scale=2):
            chatbot = gr.Chatbot(height=400, label="השיחה שלך", rtl=True)
            
            with gr.Row():
                msg_input = gr.Textbox(
                    label="ההודעה שלך:",
                    placeholder="כתוב את המחשבות שלך...",
                    lines=2,
                    scale=4
                )
                send_btn = gr.Button("שלח", scale=1)
            
            clear_btn = gr.Button("נקה שיחה")
    
    # Event handlers
    setup_btn.click(
        fn=set_context_and_part,
        inputs=[user_context, part_choice, persona_name, conversation_state],
        outputs=[conversation_state, current_part]
    )
    
    msg_input.submit(
        fn=chat_with_part,
        inputs=[msg_input, chatbot, conversation_state],
        outputs=[msg_input, chatbot, conversation_state]
    )
    
    send_btn.click(
        fn=chat_with_part,
        inputs=[msg_input, chatbot, conversation_state],
        outputs=[msg_input, chatbot, conversation_state]
    )
    
    clear_btn.click(
        fn=lambda state: ([], conv_manager.clear_conversation(state)),
        inputs=[conversation_state],
        outputs=[chatbot, conversation_state]
    )

if __name__ == "__main__":
    print("🧪 Starting simplified מראות app...")
    # Find available port
    import socket
    for port in range(7864, 7874):
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.bind(('127.0.0.1', port))
                available_port = port
                break
        except OSError:
            continue
    else:
        available_port = 7864
    
    print(f"🚀 Starting on port {available_port}")
    demo.launch(
        server_name="127.0.0.1",
        server_port=available_port,
        share=True,
        show_api=False,
        debug=False,
        inbrowser=True
    )