app.py

import streamlit as st
import subprocess
import tempfile
import os
import sys
import time
import shutil
import zipfile
import base64
import io  # ← THIS WAS MISSING
from pathlib import Path
from datetime import datetime
import signal

# Page config
st.set_page_config(
    page_title="C++ Online IDE",
    page_icon="💻",
    layout="wide",
    initial_sidebar_state="collapsed"
)

# Custom CSS - Fixed IDE Theme
st.markdown("""
<style>
    [data-testid="stSidebar"] {position: fixed !important;}
    .ide-header {background: linear-gradient(135deg, #1e3a8a 0%, #3b82f6 100%); padding: 1.5rem; border-radius: 0 0 20px 20px; color: white; margin: -1.5rem -1.5rem 2rem -1.5rem;}
    .file-tab {background: #f8fafc; border: 1px solid #e2e8f0; border-radius: 8px 8px 0 0; padding: 8px 16px; margin-right: 4px; cursor: pointer; font-weight: 500;}
    .file-tab.active {background: #3b82f6; color: white;}
    .panel {background: #0f0f23; color: #e2e8f0; padding: 1.5rem; border-radius: 12px; height: 350px; overflow-y: auto; font-family: 'Monaco', monospace; border: 1px solid #334155;}
    .status-bar {background: #1e293b; padding: 12px; border-radius: 0 0 12px 12px; font-size: 14px; color: #94a3b8;}
    .control-btn {border-radius: 8px; padding: 10px 20px; font-weight: 600; border: none; margin: 2px;}
</style>
""", unsafe_allow_html=True)

# === STATE INITIALIZATION ===
@st.cache_data(ttl=300)
def init_state():
    return {
        'files': {
            "main.cpp": '''#include <iostream>
using namespace std;
int main() {
    cout << "🚀 C++ Online IDE - Hello World!" << endl;
    return 0;
}'''
        },
        'active_file': "main.cpp",
        'is_running': False,
        'compile_status': "idle",
        'output': "",
        'error': "",
        'compile_output': "",
        'exec_time': 0,
        'input_data': ""
    }

if 'state' not in st.session_state:
    st.session_state.state = init_state()

def get_state(key, default=None):
    return st.session_state.state.get(key, default)

def set_state(key, value):
    st.session_state.state[key] = value

# === SECURE COMPILER FUNCTIONS ===
def secure_compile(_files):
    """Compile multi-file C++ project"""
    try:
        with tempfile.TemporaryDirectory(prefix="cpp_ide_") as sandbox_path:
            sandbox_dir = Path(sandbox_path)
            
            # Write all files
            for filename, content in _files.items():
                file_path = sandbox_dir / filename
                file_path.parent.mkdir(parents=True, exist_ok=True)
                with open(file_path, 'w') as f:
                    f.write(content)
            
            # Compile command
            cmd = ["g++", "-std=c++17", "-Wall", "-Wextra", "-O2", "-o", "a.out"]
            cmd.extend([str(sandbox_dir / f) for f in _files.keys()])
            
            result = subprocess.run(
                cmd, cwd=sandbox_dir, capture_output=True, text=True, 
                timeout=10
            )
            
            if result.returncode == 0:
                return True, f"✅ Compiled {len(_files)} files", sandbox_dir / "a.out"
            else:
                return False, result.stdout, None
                
    except Exception as e:
        return False, f"❌ Error: {str(e)}", None

def secure_run(exe_path, input_data):
    """Run with timeout"""
    try:
        with tempfile.TemporaryDirectory() as sandbox_path:
            sandbox_dir = Path(sandbox_path)
            
            # Input file
            input_file = sandbox_dir / "input.txt"
            with open(input_file, 'w') as f:
                f.write(input_data)
            
            start_time = time.time()
            process = subprocess.Popen(
                [str(exe_path)], stdin=open(input_file, 'r'),
                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                cwd=sandbox_dir, text=True, timeout=8
            )
            
            stdout, stderr = process.communicate(timeout=8)
            exec_time = time.time() - start_time
            
            return True, stdout, stderr, exec_time
            
    except:
        return False, "", "⏰ Timeout (8s)", 8.0

# === FILE MANAGER ===
def render_file_manager():
    with st.sidebar:
        st.markdown("## 💾 Files")
        
        # New file
        new_name = st.text_input("New file:", key="new_file_name", placeholder="file.cpp")
        if st.button("➕ Create") and new_name:
            if new_name not in get_state('files', {}):
                files = get_state('files', {})
                files[new_name] = "// New file\n"
                set_state('files', files)
        
        st.markdown("---")
        
        # File list
        files = get_state('files', {})
        for filename in list(files.keys()):
            col1, col2 = st.columns([4, 1])
            with col1:
                if st.button(filename, key=f"select_{filename}"):
                    set_state('active_file', filename)
            with col2:
                if st.button("🗑️", key=f"del_{filename}"):
                    del files[filename]
                    set_state('files', files)
                    if get_state('active_file') == filename:
                        set_state('active_file', list(files.keys())[0])
        
        # Download ZIP
        if st.button("📦 Download Project"):
            zip_buffer = io.BytesIO()
            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
                for filename, content in files.items():
                    zf.writestr(filename, content)
            zip_buffer.seek(0)
            b64 = base64.b64encode(zip_buffer.read()).decode()
            st.markdown(f'<a href="data:application/zip;base64,{b64}" download="cpp-ide.zip">💾 Download ZIP</a>', unsafe_allow_html=True)

# === MAIN LAYOUT ===
st.markdown('<div class="ide-header">💻 C++ Online IDE | Production Grade</div>', unsafe_allow_html=True)

# Top controls
cols = st.columns(6)
with cols[0]:
    if st.button("🔨 Compile", key="compile"):
        with st.spinner("Compiling..."):
            files = get_state('files', {})
            success, msg, exe_path = secure_compile(files)
            set_state('compile_status', "success" if success else "error")
            set_state('compile_output', msg)
            set_state('sandbox_exe', str(exe_path) if success else None)

with cols[1]:
    exe_path = get_state('sandbox_exe')
    if st.button("▶️ Run", key="run", disabled=not exe_path):
        with st.spinner("Running..."):
            input_data = get_state('input_data', '')
            success, stdout, stderr, exec_time = secure_run(exe_path, input_data)
            set_state('output', stdout)
            set_state('error', stderr)
            set_state('exec_time', exec_time)

with cols[2]:
    if st.button("🗑️ Clear", key="clear"):
        set_state('output', '')
        set_state('error', '')
        set_state('compile_output', '')

with cols[3]:
    if st.button("🔄 Reset", key="reset"):
        st.session_state.state = init_state()
        st.rerun()

# IDE Layout
col1, col2, col3 = st.columns([1, 3, 1.2])

# Left: File Manager
with col1:
    render_file_manager()

# Center: Editor
with col2:
    st.markdown("### 📝 Code Editor")
    active_file = get_state('active_file', 'main.cpp')
    
    # File tabs
    for filename in get_state('files', {}).keys():
        if st.button(filename, key=f"tab_{filename}"):
            set_state('active_file', filename)
    
    # Editor
    code = st.text_area(
        f"Editing: **{active_file}**",
        value=get_state('files', {}).get(active_file, ''),
        height=450,
        key=f"editor_{active_file}"
    )
    files = get_state('files', {})
    files[active_file] = code
    set_state('files', files)

# Right: Panels
with col3:
    st.markdown("### 📥 Input")
    input_data = st.text_area("stdin:", height=120, key="input_panel")
    set_state('input_data', input_data)
    
    # Output tabs
    if get_state('output') or get_state('error') or get_state('compile_output'):
        tab1, tab2, tab3 = st.tabs(["📤 Output", "❌ Errors", "🔧 Compiler"])

with tab1:
    st.text_area(
        "Program Output",
        value=get_state('output', ''),
        height=200,
        disabled=True,
        key="stdout_box"
    )

with tab2:
    st.text_area(
        "Runtime Errors",
        value=get_state('error', ''),
        height=200,
        disabled=True,
        key="stderr_box"
    )

with tab3:
    st.text_area(
        "Compiler Output",
        value=get_state('compile_output', ''),
        height=200,
        disabled=True,
        key="compile_box"
    )

# Status bar
st.markdown(f'''
<div class="status-bar">
    Status: {get_state('compile_status', 'idle')} | 
    File: {get_state('active_file', 'main.cpp')} | 
    Time: {get_state('exec_time', 0):.2f}s
</div>
''', unsafe_allow_html=True)