import re
import gradio as gr
import time
from typing import List, Dict

# Mock backend responses
class MockBackend:
    def generate_response(self, prompt: str, model: str) -> str:
        # Simulate some processing time
        time.sleep(1)
        
        # Mock responses for different types of queries
        if "binary search" in prompt.lower():
            return """
def binary_search(arr: list, target: int) -> int:
    '''
    Implements binary search algorithm
    Args:
        arr: Sorted list of numbers
        target: Number to find
    Returns:
        Index of target if found, -1 otherwise
    '''
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

# Example usage:
numbers = [1, 3, 5, 7, 9, 11, 13, 15]
result = binary_search(numbers, 7)
print(f"Found 7 at index: {result}")  # Output: Found 7 at index: 3
"""
        elif "machine learning" in prompt.lower():
            return "Machine Learning is a subset of artificial intelligence that enables systems to learn and improve from experience without being explicitly programmed. It uses statistical techniques to allow computers to 'learn' from data."
        else:
            return f"Mock response for query: {prompt}"

# Initialize mock backend and query list
mock_backend = MockBackend()
queries_list = []

# Model name mappings
llm_name2id = {
    "Llama-3.1-70B-Versatile": "llama-3.1-70b-versatile",
    "Llama-3-70B-8192": "llama3-70b-8192",
    "Llama-3-8B-8192": "llama3-8b-8192"
}

# Default values
DEFAULT_TEMP = 0.2
DEFAULT_MODEL = "Llama-3-70B-8192"
DEFAULT_USE_RAG = True

def clear_queries():
    global queries_list
    queries_list = []
    return "", DEFAULT_MODEL, DEFAULT_TEMP, DEFAULT_USE_RAG, "", ""

def add_to_list(query_txt: str, model: str, temperature: float, use_rag: bool) -> tuple:
    global queries_list
    
    if len(query_txt.strip()) > 0:
        queries_list.append({
            "prompt": query_txt.strip(),
            "temperature": str(temperature),
            "model": llm_name2id[model],
            "use_rag": str(use_rag),
        })
    
    return "", generate_queries_str(queries_list)

def submit(query_txt: str, model: str, temperature: float, use_rag: bool) -> tuple:
    global queries_list
    
    if len(query_txt.strip()) > 0:
        _, queries = add_to_list(query_txt, model, temperature, use_rag)
    else:
        queries = generate_queries_str(queries_list)
    
    if len(queries_list) > 0:
        # Use mock backend instead of HTTP requests
        answers = []
        for query in queries_list:
            response = mock_backend.generate_response(query["prompt"], query["model"])
            answers.append({"answer": response})
        
        answers_str = generate_answers_str(answers)
        queries_list = []
    else:
        answers_str = "No queries submitted yet."
    
    return "", queries, answers_str

def generate_queries_str(queries: List[Dict]) -> str:
    delimiter = f"\n{'-' * 120}\n"
    return delimiter.join([f"Query: {q['prompt']}" for q in queries])

def generate_answers_str(answers: List[Dict]) -> str:
    delimiter = f"\n{'-' * 120}\n"
    return delimiter.join([clean(a["answer"]) for a in answers])

def clean(answer_str: str) -> str:
    answer_str = re.sub('^\s*:', '', answer_str)
    
    garbages = [
        "Here is the generated paragraph:",
        "Let me know if this meets your requirements!",
    ]
    for g in garbages:
        answer_str = answer_str.replace(g, "")
    return answer_str.strip()

if __name__ == "__main__":
    with gr.Blocks(theme=gr.themes.Default()) as demo:
        gr.Markdown("""
        # Multilingual LLM Interface (Mock Version)
        Enter your query in any language. This is a mock version for testing - responses are simulated.
        
        Test queries:
        1. Ask about "binary search" to get a code implementation
        2. Ask about "machine learning" to get an explanation
        3. Try any other query to see mock responses
        """)
        
        with gr.Row():
            with gr.Column(scale=2):
                query_txt = gr.Textbox(
                    placeholder="Enter your query here...",
                    label="Query",
                    lines=3
                )
            with gr.Column(scale=1):
                model = gr.Radio(
                    choices=[
                        "Llama-3-8B-8192",
                        "Llama-3-70B-8192",
                        "Llama-3.1-70B-Versatile",
                    ],
                    value=DEFAULT_MODEL,
                    label="Select Model"
                )
                use_rag = gr.Checkbox(
                    value=DEFAULT_USE_RAG,
                    label="Enable RAG (Retrieval-Augmented Generation)"
                )
                temperature = gr.Slider(
                    minimum=0,
                    maximum=1,
                    value=DEFAULT_TEMP,
                    step=0.1,
                    label="Temperature (Creativity)"
                )
        
        with gr.Row():
            clear_btn = gr.Button("Clear All", variant="stop")
            add_btn = gr.Button("Add Query", variant="secondary")
            submit_btn = gr.Button("Submit All", variant="primary")
        
        with gr.Row():
            with gr.Column():
                queries_box = gr.Textbox(
                    placeholder="Your queries will appear here...",
                    label="Submitted Queries",
                    interactive=False,
                    lines=5
                )
            with gr.Column():
                answers_box = gr.Textbox(
                    placeholder="Model responses will appear here...",
                    label="Model Responses",
                    interactive=False,
                    lines=5
                )
        
        clear_btn.click(
            fn=clear_queries,
            inputs=[],
            outputs=[query_txt, model, temperature, use_rag, queries_box, answers_box]
        )
        add_btn.click(
            fn=add_to_list,
            inputs=[query_txt, model, temperature, use_rag],
            outputs=[query_txt, queries_box]
        )
        submit_btn.click(
            fn=submit,
            inputs=[query_txt, model, temperature, use_rag],
            outputs=[query_txt, queries_box, answers_box]
        )

    demo.launch()