import streamlit as st
import tempfile
import os
import logging
from pathlib import Path
from PIL import Image
import io
import numpy as np
import sys
import subprocess
import json
from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter
import base64
from transformers import pipeline
import torch
import re
import shutil
import time
from datetime import datetime, timedelta
import streamlit.components.v1 as components
import uuid
import platform
import pandas as pd
import plotly.express as px
import markdown
import zipfile
import contextlib
import threading
import traceback
from io import StringIO, BytesIO

# Set up enhanced logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Model configuration mapping for different API requirements and limits
MODEL_CONFIGS = {
    "DeepSeek-V3-0324": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "DeepSeek", "warning": None},
    "DeepSeek-R1": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "DeepSeek", "warning": None},
    "Llama-4-Scout-17B-16E-Instruct": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Meta", "warning": None},
    "Llama-4-Maverick-17B-128E-Instruct-FP8": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Meta", "warning": None},
    "gpt-4o-mini": {"max_tokens": 15000, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "gpt-4o": {"max_tokens": 16000, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "gpt-4.1": {"max_tokens": 32768, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "gpt-4.1-mini": {"max_tokens": 32768, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "gpt-4.1-nano": {"max_tokens": 32768, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "o4-mini": {"max_completion_tokens": 100000, "param_name": "max_completion_tokens", "api_version": "2024-12-01-preview", "category": "OpenAI", "warning": None},
    "o1": {"max_completion_tokens": 100000, "param_name": "max_completion_tokens", "api_version": "2024-12-01-preview", "category": "OpenAI", "warning": None},
    "o1-mini": {"max_completion_tokens": 66000, "param_name": "max_completion_tokens", "api_version": "2024-12-01-preview", "category": "OpenAI", "warning": None},
    "o1-preview": {"max_tokens": 33000, "param_name": "max_tokens", "api_version": None, "category": "OpenAI", "warning": None},
    "Phi-4-multimodal-instruct": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Microsoft", "warning": None},
    "Mistral-large-2407": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Mistral", "warning": None},
    "Codestral-2501": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Mistral", "warning": None},
    # Default configuration for other models
    "default": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "Other", "warning": None}
}

# Try to import Streamlit Ace
try:
    from streamlit_ace import st_ace
    ACE_EDITOR_AVAILABLE = True
except ImportError:
    ACE_EDITOR_AVAILABLE = False
    logger.warning("streamlit-ace not available, falling back to standard text editor")

def prepare_api_params(messages, model_name):
    """Create appropriate API parameters based on model configuration"""
    config = MODEL_CONFIGS.get(model_name, MODEL_CONFIGS["default"])
    api_params = {
        "messages": messages,
        "model": model_name
    }
    token_param = config["param_name"]
    api_params[token_param] = config.get(token_param)
    return api_params, config

def get_secret(env_var):
    """Retrieve a secret from environment variables"""
    val = os.environ.get(env_var)
    if not val:
        logger.warning(f"Secret '{env_var}' not found")
    return val

def check_password():
    """Verify password entered against secret"""
    correct = get_secret("password")
    if not correct:
        st.error("Admin password not configured")
        return False
    if "password_entered" not in st.session_state:
        st.session_state.password_entered = False
    if not st.session_state.password_entered:
        pwd = st.text_input("Enter password to access AI features", type="password")
        if pwd:
            if pwd == correct:
                st.session_state.password_entered = True
                return True
            else:
                st.error("Incorrect password")
                return False
        return False
    return True

def ensure_packages():
    required = {
        'manim': '0.17.3',
        'Pillow': '9.0.0',
        'numpy': '1.22.0',
        'transformers': '4.30.0',
        'torch': '2.0.0',
        'pygments': '2.15.1',
        'streamlit-ace': '0.1.1',
        'pydub': '0.25.1',
        'plotly': '5.14.0',
        'pandas': '2.0.0',
        'python-pptx': '0.6.21',
        'markdown': '3.4.3',
        'fpdf': '1.7.2',
        'matplotlib': '3.5.0',
        'seaborn': '0.11.2',
        'scipy': '1.7.3',
        'huggingface_hub': '0.16.0',
    }
    missing = {}
    for pkg, ver in required.items():
        try:
            __import__(pkg if pkg != 'Pillow' else 'PIL')
        except ImportError:
            missing[pkg] = ver
    if not missing:
        return True
    bar = st.progress(0)
    txt = st.empty()
    for i, (pkg, ver) in enumerate(missing.items()):
        bar.progress(i / len(missing))
        txt.text(f"Installing {pkg}...")
        res = subprocess.run([sys.executable, "-m", "pip", "install", f"{pkg}>={ver}"], capture_output=True, text=True)
        if res.returncode != 0:
            st.error(f"Failed to install {pkg}")
            return False
    bar.progress(1.0)
    txt.empty()
    return True

def install_custom_packages(pkgs):
    if not pkgs.strip():
        return True, "No packages specified"
    parts = [p.strip() for p in pkgs.split(",") if p.strip()]
    if not parts:
        return True, "No valid packages"
    sidebar_txt = st.sidebar.empty()
    bar = st.sidebar.progress(0)
    results = []
    success = True
    for i, p in enumerate(parts):
        bar.progress(i / len(parts))
        sidebar_txt.text(f"Installing {p}...")
        res = subprocess.run([sys.executable, "-m", "pip", "install", p], capture_output=True, text=True)
        if res.returncode != 0:
            results.append(f"Failed {p}: {res.stderr}")
            success = False
        else:
            results.append(f"Installed {p}")
    bar.progress(1.0)
    sidebar_txt.empty()
    return success, "\n".join(results)

@st.cache_resource(ttl=3600)
def init_ai_models_direct():
    token = get_secret("github_token_api")
    if not token:
        st.error("API token not configured")
        return None
    try:
        from azure.ai.inference import ChatCompletionsClient
        from azure.ai.inference.models import UserMessage
        from azure.core.credentials import AzureKeyCredential
        client = ChatCompletionsClient(
            endpoint="https://models.inference.ai.azure.com",
            credential=AzureKeyCredential(token)
        )
        return {"client": client, "model_name": "gpt-4o", "last_loaded": datetime.now().isoformat()}
    except ImportError as e:
        st.error("Azure AI SDK not installed")
        logger.error(str(e))
        return None

def generate_manim_preview(python_code):
    scene_objects = []
    if "Circle" in python_code: scene_objects.append("circle")
    if "Square" in python_code: scene_objects.append("square")
    if "MathTex" in python_code or "Tex" in python_code: scene_objects.append("equation")
    if "Text" in python_code: scene_objects.append("text")
    if "Axes" in python_code: scene_objects.append("graph")
    icons = {"circle":"⭕","square":"🔲","equation":"📊","text":"📝","graph":"📈"}
    icon_html = "".join(f'<span style="font-size:2rem;margin:0.3rem;">{icons[o]}</span>' for o in scene_objects if o in icons)
    html = f"""
    <div style="background:#000;color:#fff;padding:1rem;border-radius:10px;text-align:center;">
      <h3>Animation Preview</h3>
      <div>{icon_html or '🎬'}</div>
      <p>Contains: {', '.join(scene_objects) or 'none'}</p>
      <p style="opacity:0.7;">Full rendering required for accurate preview</p>
    </div>
    """
    return html

def extract_scene_class_name(python_code):
    names = re.findall(r'class\s+(\w+)\s*\([^)]*Scene', python_code)
    return names[0] if names else "MyScene"

def mp4_to_gif(mp4, out, fps=15):
    cmd = [
        "ffmpeg","-i",mp4,
        "-vf",f"fps={fps},scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
        "-loop","0",out
    ]
    r = subprocess.run(cmd, capture_output=True, text=True)
    return out if r.returncode==0 else None

def generate_manim_video(code, format_type, quality_preset, speed=1.0, audio_path=None):
    temp_dir = tempfile.mkdtemp(prefix="manim_")
    scene_class = extract_scene_class_name(code)
    file_py = os.path.join(temp_dir, "scene.py")
    with open(file_py, "w", encoding="utf-8") as f:
        f.write(code)
    quality_flags = {"480p":"-ql","720p":"-qm","1080p":"-qh","4K":"-qk","8K":"-qp"}
    qf = quality_flags.get(quality_preset, "-qm")
    fmt_arg = f"--format={format_type}"
    cmd = ["manim", file_py, scene_class, qf, fmt_arg]
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    output = []
    out_path = None
    mp4_path = None
    bar = st.empty()
    log = st.empty()
    while True:
        line = proc.stdout.readline()
        if not line and proc.poll() is not None:
            break
        if line:
            output.append(line)
            log.code("".join(output[-10:]))
            if "File ready at" in line:
                m = re.search(r'([\'"])?(.+?\.(?:mp4|gif|webm|svg))\1', line)
                if m:
                    out_path = m.group(2)
                    if out_path.endswith(".mp4"):
                        mp4_path = out_path
    proc.wait()
    time.sleep(1)
    data = None
    if format_type=="gif" and (not out_path or not os.path.exists(out_path)) and mp4_path and os.path.exists(mp4_path):
        gif = os.path.join(temp_dir, scene_class+"_conv.gif")
        conv = mp4_to_gif(mp4_path, gif)
        if conv and os.path.exists(conv):
            out_path = conv
    if out_path and os.path.exists(out_path):
        with open(out_path,"rb") as f: data = f.read()
    shutil.rmtree(temp_dir)
    if data:
        return data, f"✅ Generated successfully ({len(data)/(1024*1024):.1f} MB)"
    else:
        return None, "❌ No output generated. Check logs."

def detect_input_calls(code):
    calls = []
    for i, line in enumerate(code.split("\n"),1):
        if "input(" in line and not line.strip().startswith("#"):
            m = re.search(r'input\(["\'](.+?)["\']\)', line)
            prompt = m.group(1) if m else f"Input at line {i}"
            calls.append({"line":i,"prompt":prompt})
    return calls

def run_python_script(code, inputs=None, timeout=60):
    result = {"stdout":"","stderr":"","exception":None,"plots":[],"dataframes":[],"execution_time":0}
    mod = ""
    if inputs:
        mod = f"""
__INPUTS={inputs}
__IDX=0
def input(prompt=''):
    global __IDX
    print(prompt,end='')
    if __IDX<len(__INPUTS):
        val=__INPUTS[__IDX]; __IDX+=1
        print(val)
        return val
    print()
    return ''
"""
    code_full = mod + code
    with tempfile.TemporaryDirectory() as td:
        script = os.path.join(td,"script.py")
        with open(script,"w") as f: f.write(code_full)
        outf = os.path.join(td,"out.txt")
        errf = os.path.join(td,"err.txt")
        start=time.time()
        try:
            with open(outf,"w") as o, open(errf,"w") as e:
                proc=subprocess.Popen([sys.executable, script], stdout=o, stderr=e, cwd=td)
                proc.wait(timeout=timeout)
        except subprocess.TimeoutExpired:
            proc.kill()
            result["stderr"] += f"\nTimed out after {timeout}s"
            result["exception"] = "Timeout"
        result["execution_time"]=time.time()-start
        result["stdout"]=open(outf).read()
        result["stderr"]+=open(errf).read()
    return result

def display_python_script_results(res):
    st.info(f"Completed in {res['execution_time']:.2f}s")
    if res["exception"]:
        st.error(f"Exception: {res['exception']}")
    if res["stderr"]:
        st.error("Errors:")
        st.code(res["stderr"], language="bash")
    if res["plots"]:
        st.markdown("### Plots")
        cols = st.columns(min(3,len(res["plots"])))
        for i,p in enumerate(res["plots"]):
            cols[i%len(cols)].image(p,use_column_width=True)
    if res["dataframes"]:
        st.markdown("### DataFrames")
        for df in res["dataframes"]:
            with st.expander(f"{df['name']} ({df['shape'][0]}×{df['shape'][1]})"):
                st.markdown(df["preview_html"], unsafe_allow_html=True)
    if res["stdout"]:
        st.markdown("### Output")
        st.code(res["stdout"], language="bash")

# Main app
def main():
    if 'init' not in st.session_state:
        st.session_state.update({
            'init':True, 'video_data':None, 'status':None, 'ai_models':None,
            'generated_code':"", 'code':"", 'temp_code':"", 'editor_key':str(uuid.uuid4()),
            'packages_checked':False, 'latex_formula':"", 'audio_path':None,
            'image_paths':[], 'custom_library_result':"", 'python_script':"",
            'python_result':None, 'active_tab':0,
            'settings':{"quality":"720p","format_type":"mp4","animation_speed":"Normal"},
            'password_entered':False, 'custom_model':"gpt-4o", 'first_load_complete':False,
            'pending_tab_switch':None
        })
    st.set_page_config(page_title="Manim Animation Studio", page_icon="🎬", layout="wide")
    if not st.session_state.packages_checked:
        if ensure_packages():
            st.session_state.packages_checked=True
        else:
            st.error("Failed to install packages")
            return

    tab_names=["✨ Editor","🤖 AI Assistant","📚 LaTeX Formulas","🎨 Assets","🎞️ Timeline","🎓 Educational Export","🐍 Python Runner"]
    tabs = st.tabs(tab_names)

    # Editor Tab
    with tabs[0]:
        col1,col2 = st.columns([3,2])
        with col1:
            st.markdown("### 📝 Animation Editor")
            mode = st.radio("Code Input",["Type Code","Upload File"], key="editor_mode")
            if mode=="Upload File":
                up=st.file_uploader("Upload .py file", type=["py"])
                if up:
                    txt=up.getvalue().decode()
                    if txt.strip():
                        st.session_state.code=txt
                        st.session_state.temp_code=txt
            if ACE_EDITOR_AVAILABLE:
                st.session_state.temp_code = st_ace(value=st.session_state.code, language="python", theme="monokai", min_lines=20, key=f"ace_{st.session_state.editor_key}")
            else:
                st.session_state.temp_code = st.text_area("Code", st.session_state.code, height=400, key=f"ta_{st.session_state.editor_key}")
            if st.session_state.temp_code!=st.session_state.code:
                st.session_state.code=st.session_state.temp_code
            if st.button("🚀 Generate Animation"):
                if not st.session_state.code:
                    st.error("Enter code first")
                else:
                    vc,stt = generate_manim_video(
                        st.session_state.code,
                        st.session_state.settings["format_type"],
                        st.session_state.settings["quality"],
                        {"Slow":0.5,"Normal":1.0,"Fast":2.0,"Very Fast":3.0}[st.session_state.settings["animation_speed"]],
                        st.session_state.audio_path
                    )
                    st.session_state.video_data=vc
                    st.session_state.status=stt
        with col2:
            if st.session_state.code:
                st.markdown("<div style='border:1px solid #ccc;padding:1rem;border-radius:8px;'>", unsafe_allow_html=True)
                components.html(generate_manim_preview(st.session_state.code), height=250)
                st.markdown("</div>", unsafe_allow_html=True)
            if st.session_state.video_data:
                fmt=st.session_state.settings["format_type"]
                if fmt=="png_sequence":
                    st.download_button("⬇️ Download PNG ZIP", data=st.session_state.video_data, file_name=f"manim_pngs_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip", mime="application/zip")
                elif fmt=="svg":
                    try:
                        svg=st.session_state.video_data.decode('utf-8')
                        components.html(svg, height=400)
                    except:
                        st.error("Cannot display SVG")
                    st.download_button("⬇️ Download SVG", data=st.session_state.video_data, file_name="animation.svg", mime="image/svg+xml")
                else:
                    st.video(st.session_state.video_data, format=fmt)
                    st.download_button(f"⬇️ Download {fmt.upper()}", st.session_state.video_data, file_name=f"animation.{fmt}", mime=f"video/{fmt}" if fmt!="gif" else "image/gif")
            if st.session_state.status:
                if "Error" in st.session_state.status:
                    st.error(st.session_state.status)
                else:
                    st.success(st.session_state.status)

    # AI Assistant Tab
    with tabs[1]:
        st.markdown("### 🤖 AI Animation Assistant")
        if check_password():
            client_data = init_ai_models_direct()
            if client_data:
                if st.button("Test API Connection"):
                    with st.spinner("Testing..."):
                        from azure.ai.inference.models import UserMessage
                        api_params,_=prepare_api_params([UserMessage("Hello")], client_data["model_name"])
                        resp=client_data["client"].complete(**api_params)
                        if resp.choices:
                            st.success("✅ Connection successful!")
                            st.session_state.ai_models=client_data
                        else:
                            st.error("❌ No response")
                if st.session_state.ai_models:
                    st.info(f"Using model {st.session_state.ai_models['model_name']}")
                    prompt = st.text_area("Describe animation or paste partial code", height=150)
                    if st.button("Generate Animation Code"):
                        if prompt.strip():
                            from azure.ai.inference.models import UserMessage
                            api_params,_=prepare_api_params([UserMessage(f"Write a complete Manim scene for:\n{prompt}")], st.session_state.ai_models["model_name"])
                            resp=st.session_state.ai_models["client"].complete(**api_params)
                            if resp.choices:
                                code = resp.choices[0].message.content
                                if "```python" in code:
                                    code=code.split("```python")[1].split("```")[0]
                                st.session_state.generated_code=code
                            else:
                                st.error("No code generated")
                        else:
                            st.warning("Enter prompt first")
                    if st.session_state.generated_code:
                        st.code(st.session_state.generated_code, language="python")
                        if st.button("Use This Code"):
                            st.session_state.code=st.session_state.generated_code
                            st.session_state.temp_code=st.session_state.generated_code
                            st.session_state.pending_tab_switch=0
                            st.rerun()
        else:
            st.info("Enter password to access")

    # LaTeX Formulas Tab
    with tabs[2]:
        st.markdown("### 📚 LaTeX Formula Builder")
        col1,col2=st.columns([3,2])
        with col1:
            latex_input = st.text_area("LaTeX Formula", value=st.session_state.latex_formula, height=100, placeholder=r"e^{i\pi}+1=0")
            st.session_state.latex_formula=latex_input
            if latex_input:
                manim_latex_code = f"""
# LaTeX formula
formula = MathTex(r"{latex_input}")
self.play(Write(formula))
self.wait(2)
"""
                st.code(manim_latex_code, language="python")
                if st.button("Insert into Editor"):
                    if st.session_state.code:
                        if "def construct(self):" in st.session_state.code:
                            lines=st.session_state.code.split("\n")
                            idx=-1
                            for i,l in enumerate(lines):
                                if "def construct(self):" in l:
                                    idx=i; break
                            if idx>=0:
                                for j in range(idx+1,len(lines)):
                                    if lines[j].strip() and not lines[j].strip().startswith("#"):
                                        indent=re.match(r"(\s*)",lines[j]).group(1)
                                        new_block="\n".join(indent+ln for ln in manim_latex_code.strip().split("\n"))
                                        lines.insert(j,new_block)
                                        break
                            else:
                                lines.append("        "+ "\n        ".join(manim_latex_code.strip().split("\n")))
                            st.session_state.code="\n".join(lines)
                            st.session_state.temp_code=st.session_state.code
                            st.success("Inserted LaTeX into editor")
                            st.session_state.pending_tab_switch=0
                            st.rerun()
                        else:
                            st.warning("No construct() found")
                    else:
                        basic_scene = f"""from manim import *

class LatexScene(Scene):
    def construct(self):
        # LaTeX formula
        formula = MathTex(r"{latex_input}")
        self.play(Write(formula))
        self.wait(2)
"""
                        st.session_state.code=basic_scene
                        st.session_state.temp_code=basic_scene
                        st.success("Created new scene with LaTeX")
                        st.session_state.pending_tab_switch=0
                        st.rerun()
        with col2:
            components.html(render_latex_preview(latex_input), height=300)

    # Assets Tab
    with tabs[3]:
        st.markdown("### 🎨 Asset Management")
        c1,c2 = st.columns(2)
        with c1:
            imgs=st.file_uploader("Upload Images", type=["png","jpg","jpeg","svg"], accept_multiple_files=True)
            if imgs:
                img_dir=os.path.join(os.getcwd(),"manim_assets","images")
                os.makedirs(img_dir, exist_ok=True)
                for up in imgs:
                    ext=up.name.split(".")[-1]
                    fname=f"img_{int(time.time())}_{uuid.uuid4().hex[:6]}.{ext}"
                    path=os.path.join(img_dir,fname)
                    with open(path,"wb") as f: f.write(up.getvalue())
                    st.session_state.image_paths.append({"name":up.name,"path":path})
            if st.session_state.image_paths:
                for info in st.session_state.image_paths:
                    img=Image.open(info["path"])
                    st.image(img, caption=info["name"], width=100)
                    if st.button(f"Use {info['name']}"):
                        code_snippet=f"""
# Image asset
image = ImageMobject(r"{info['path']}")
image.scale(2)
self.play(FadeIn(image))
self.wait(1)
"""
                        st.session_state.code+=code_snippet
                        st.session_state.temp_code=st.session_state.code
                        st.success(f"Added {info['name']} to code")
                        st.session_state.pending_tab_switch=0
                        st.rerun()
        with c2:
            aud=st.file_uploader("Upload Audio", type=["mp3","wav","ogg"])
            if aud:
                adir=os.path.join(os.getcwd(),"manim_assets","audio")
                os.makedirs(adir,exist_ok=True)
                ext=aud.name.split(".")[-1]
                aname=f"audio_{int(time.time())}.{ext}"
                ap=os.path.join(adir,aname)
                with open(ap,"wb") as f: f.write(aud.getvalue())
                st.session_state.audio_path=ap
                st.audio(aud)
                st.success("Audio uploaded")

    # Timeline Tab
    with tabs[4]:
        st.markdown("### 🎞️ Timeline Editor")
        st.info("Drag and adjust steps in code directly for now.")

    # Educational Export Tab
    with tabs[5]:
        st.markdown("### 🎓 Educational Export")
        if not st.session_state.video_data:
            st.warning("Generate an animation first")
        else:
            title = st.text_input("Title", "Manim Animation")
            expl = st.text_area("Explanation (use ## to separate steps)", height=150)
            fmt = st.selectbox("Format", ["PowerPoint","HTML","PDF Sequence"])
            if st.button("Export"):
                # Simplified, reuse generate_manim_video logic or placeholder
                st.success(f"{fmt} export not yet implemented.")

    # Python Runner Tab
    with tabs[6]:
        st.markdown("### 🐍 Python Script Runner")
        examples = {
            "Select...":"",
            "Sine Plot":"""import matplotlib.pyplot as plt
import numpy as np
x=np.linspace(0,10,100)
y=np.sin(x)
plt.plot(x,y)
print("Done plotting")"""
        }
        sel=st.selectbox("Example", list(examples.keys()))
        code = examples.get(sel, st.session_state.python_script)
        if ACE_EDITOR_AVAILABLE:
            code = st_ace(value=code, language="python", theme="monokai", min_lines=15, key="pyace")
        else:
            code = st.text_area("Code", code, height=300, key="pyta")
        st.session_state.python_script=code
        inputs = detect_input_calls(code)
        vals=[]
        if inputs:
            st.info(f"{len(inputs)} input() calls detected")
            for i,c in enumerate(inputs):
                vals.append(st.text_input(f"{c['prompt']} (line {c['line']})", key=f"inp{i}"))
        timeout = st.slider("Timeout", 5,300,30)
        if st.button("▶️ Run"):
            res=run_python_script(code, inputs=vals, timeout=timeout)
            st.session_state.python_result=res
        if st.session_state.python_result:
            display_python_script_results(st.session_state.python_result)

    # Handle tab switch after actions
    if st.session_state.pending_tab_switch is not None:
        st.session_state.active_tab = st.session_state.pending_tab_switch
        st.session_state.pending_tab_switch=None

if __name__ == "__main__":
    main()