import os
import sys
import gradio as gr

# Install required packages if not already installed
try:
    import sign_language_translator as slt
    import requests
except ImportError:
    print("Installing required packages...")
    os.system("pip install sign-language-translator requests --quiet")
    import sign_language_translator as slt
    import requests

TITLE = "English to Pakistan Sign Language Translator"
DESCRIPTION = """This app translates English text to Pakistan Sign Language by first converting English to Urdu (which may improve vocabulary coverage), then using the Urdu text to generate sign language videos.

**NOTE:**
- The initial translation to Urdu uses a simple API-based translation
- First-time loading may take a moment as the model downloads
- For best results, use simple sentences
"""

# Global model variable
model = None

def get_model():
    """Initialize the sign language translation model"""
    try:
        return slt.models.ConcatenativeSynthesis("ur", "pk-sl", "video")
    except Exception as e:
        print(f"Error initializing model: {str(e)}")
        return None

def initialize_model():
    """Ensure model is loaded"""
    global model
    if model is None:
        model = get_model()
    return model is not None

def english_to_urdu(text):
    """Translate English text to Urdu using a translation API"""
    if not text:
        return "", "Please enter text to translate"
    
    try:
        # Using MyMemory translation API (free and doesn't require auth)
        url = f"https://api.mymemory.translated.net/get?q={text}&langpair=en|ur"
        response = requests.get(url)
        data = response.json()
        
        if "responseData" in data and "translatedText" in data["responseData"]:
            urdu_text = data["responseData"]["translatedText"]
            return urdu_text, f"Translated to Urdu: {urdu_text}"
        else:
            return "", "Error: Could not translate to Urdu"
    
    except Exception as e:
        print(f"Translation API error: {str(e)}")
        return "", f"Error during Urdu translation: {str(e)}"

def urdu_to_sign(urdu_text, format_type):
    """Translate Urdu text to Pakistan Sign Language"""
    if not urdu_text:
        return None, "No Urdu text to translate"
    
    # Initialize model if not already done
    if not initialize_model():
        return None, "Failed to initialize the translation model"
    
    try:
        # Configure model
        model.text_language = "ur"  # Urdu
        model.sign_language = "pk-sl"  # Pakistan Sign Language
        model.sign_format = format_type
        
        if format_type == "landmarks":
            model.sign_embedding_model = "mediapipe-world"
        
        # Translate
        output_path = "output.mp4"
        sign = model.translate(urdu_text)
        
        # Save output
        if isinstance(sign, slt.Landmarks):
            # Position hands correctly
            sign.data[:, 33:54, :3] += -sign.data[:, 33:34, :3] + sign.data[:, 15:16, :3]
            sign.data[:, 54:, :3] += -sign.data[:, 54:55, :3] + sign.data[:, 16:17, :3]
            sign.save_animation(output_path, overwrite=True)
        else:
            sign.save(output_path, overwrite=True, codec="mp4v")
        
        return output_path, f"Successfully created sign language video"
    
    except Exception as e:
        error_msg = str(e)
        print(f"Sign generation error: {error_msg}")
        return None, f"Error generating signs: {error_msg}"

def translate_english_to_sign(english_text, format_type):
    """Complete translation pipeline: English → Urdu → Sign Language"""
    if not english_text:
        return None, ""
    
    # Step 1: Translate English to Urdu
    urdu_text, urdu_status = english_to_urdu(english_text)
    if not urdu_text:
        return None, urdu_status
    
    # Step 2: Translate Urdu to Sign Language
    video, sign_status = urdu_to_sign(urdu_text, format_type)
    
    # Combine status messages
    status = f"English: \"{english_text}\"\nUrdu: \"{urdu_text}\"\n{sign_status}"
    
    return video, status

# Create the Gradio interface
with gr.Blocks(title=TITLE) as demo:
    gr.Markdown(f"# {TITLE}")
    gr.Markdown(DESCRIPTION)
    
    with gr.Row():
        with gr.Column():
            # Input area
            english_input = gr.Textbox(
                lines=4,
                placeholder="Enter English text here...",
                label="English Text"
            )
            
            format_dropdown = gr.Dropdown(
                choices=["video", "landmarks"],
                value="video",
                label="Output Format"
            )
            
            with gr.Row():
                clear_btn = gr.Button("Clear")
                translate_btn = gr.Button("Translate", variant="primary")
            
            # Intermediate Urdu translation
            urdu_output = gr.Textbox(label="Urdu Translation", interactive=False)
            
            # Status area
            status_output = gr.Textbox(label="Status", interactive=False)
        
        with gr.Column():
            # Output video
            video_output = gr.Video(
                label="Sign Language Output",
                format="mp4",
                autoplay=True,
                show_download_button=True
            )
    
    # Examples
    gr.Examples(
        examples=[
            ["How are you?", "video"],
            ["My name is John.", "video"],
            ["Thank you for your help.", "video"],
            ["I want to learn sign language.", "video"]
        ],
        inputs=[english_input, format_dropdown],
        outputs=[video_output, urdu_output, status_output],
        fn=lambda text, fmt: (*translate_english_to_sign(text, fmt), english_to_urdu(text)[0])
    )
    
    # Event handlers
    def handle_translation(text, fmt):
        video, status = translate_english_to_sign(text, fmt)
        urdu = english_to_urdu(text)[0] if text else ""
        return video, urdu, status
    
    translate_btn.click(
        fn=handle_translation,
        inputs=[english_input, format_dropdown],
        outputs=[video_output, urdu_output, status_output]
    )
    
    clear_btn.click(
        fn=lambda: ("", "", "Input cleared"),
        inputs=None,
        outputs=[english_input, urdu_output, status_output]
    )

# Launch the app
if __name__ == "__main__":
    demo.launch()