app.py

import streamlit as st
import nbformat
import ast
import re
import zipfile
import io
import hashlib
from pathlib import Path
from typing import List, Tuple, Dict, Any, Optional, Set
from datetime import datetime

# ==============================
# SESSION STATE INITIALIZATION
# ==============================
def init_session_state():
    """Initialize all session state variables."""
    defaults = {
        'conversion_results': {},
        'uploaded_files': [],
        'uploaded_zip': None,
        'theme': "light",
        'conversion_mode': "Hybrid (Recommended)",
        'large_file_threshold': 200,
        'add_main_guard': False,
        'preserve_comments': True,
        'conversion_stats': {
            'total_files': 0,
            'successful': 0,
            'failed': 0,
            'total_conversions': 0
        }
    }
    for key, value in defaults.items():
        if key not in st.session_state:
            st.session_state[key] = value

init_session_state()

# ==============================
# PAGE CONFIG & ENHANCED THEME
# ==============================
st.set_page_config(
    page_title="📊 Python → Streamlit Converter Pro",
    page_icon="📊",
    layout="wide",
    initial_sidebar_state="expanded",
    menu_items={
        'Get Help': None,
        'Report a bug': None,
        'About': "Python to Streamlit Converter Pro - Transform your code into beautiful Streamlit apps!"
    }
)

def apply_enhanced_theme():
    """Apply enhanced theme with modern styling."""
    is_dark = st.session_state.theme == "dark"
    
    # Color scheme
    if is_dark:
        bg_primary = "#0e1117"
        bg_secondary = "#1e2127"
        bg_tertiary = "#262730"
        text_primary = "#fafafa"
        text_secondary = "#d0d0d0"
        accent = "#ff4b4b"
        accent_hover = "#ff6b6b"
        border = "#3a3d47"
        success = "#00d4aa"
        warning = "#ffa726"
        card_bg = "#1a1d24"
    else:
        bg_primary = "#ffffff"
        bg_secondary = "#f8f9fa"
        bg_tertiary = "#e9ecef"
        text_primary = "#1a1a1a"
        text_secondary = "#4a4a4a"
        accent = "#ff4b4b"
        accent_hover = "#ff6b6b"
        border = "#dee2e6"
        success = "#00d4aa"
        warning = "#ffa726"
        card_bg = "#ffffff"
    
    st.markdown(f"""
    <style>
    /* Main App Styling */
    .stApp {{
        background: linear-gradient(135deg, {bg_primary} 0%, {bg_secondary} 100%);
        color: {text_primary};
    }}
    
    /* Typography */
    h1, h2, h3, h4, h5, h6 {{
        color: {text_primary} !important;
        font-weight: 700;
    }}
    
    /* Sidebar Styling */
    [data-testid="stSidebar"] {{
        background: {bg_secondary} !important;
        border-right: 1px solid {border};
    }}
    
    /* Cards and Containers */
    .main-card {{
        background: {card_bg};
        border-radius: 12px;
        padding: 24px;
        margin: 16px 0;
        border: 1px solid {border};
        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
    }}
    
    .stat-card {{
        background: linear-gradient(135deg, {accent}15 0%, {accent}05 100%);
        border-radius: 10px;
        padding: 20px;
        border: 1px solid {accent}30;
        text-align: center;
    }}
    
    /* Buttons */
    .stButton > button {{
        border-radius: 8px;
        font-weight: 600;
        transition: all 0.3s ease;
    }}
    
    .stButton > button:hover {{
        transform: translateY(-2px);
        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
    }}
    
    /* Expanders */
    .streamlit-expanderHeader {{
        background: {bg_tertiary} !important;
        border-radius: 8px !important;
        font-weight: 600;
    }}
    
    /* Code Blocks */
    .stCodeBlock {{
        border-radius: 8px;
        border: 1px solid {border};
    }}
    
    /* Metrics */
    [data-testid="stMetricValue"] {{
        color: {accent} !important;
        font-weight: 700;
    }}
    
    /* Tabs */
    .stTabs [data-baseweb="tab-list"] {{
        gap: 8px;
    }}
    
    .stTabs [data-baseweb="tab"] {{
        border-radius: 8px 8px 0 0;
        padding: 12px 24px;
        font-weight: 600;
    }}
    
    /* File Uploader */
    [data-testid="stFileUploader"] {{
        border: 2px dashed {border};
        border-radius: 12px;
        padding: 20px;
        background: {bg_tertiary};
    }}
    
    /* Progress Bar */
    .stProgress > div > div > div {{
        background: linear-gradient(90deg, {accent}, {accent_hover});
    }}
    
    /* Custom Badge */
    .custom-badge {{
        display: inline-block;
        padding: 4px 12px;
        border-radius: 12px;
        font-size: 0.85em;
        font-weight: 600;
        background: {accent}20;
        color: {accent};
        border: 1px solid {accent}40;
    }}
    
    /* Hero Section */
    .hero-section {{
        background: linear-gradient(135deg, {accent}15 0%, {accent}05 100%);
        border-radius: 16px;
        padding: 40px;
        margin: 20px 0;
        text-align: center;
        border: 1px solid {accent}30;
    }}
    
    /* Info Boxes */
    .info-box {{
        background: {bg_tertiary};
        border-left: 4px solid {accent};
        border-radius: 4px;
        padding: 16px;
        margin: 12px 0;
    }}
    
    /* Success Message */
    .success-box {{
        background: {success}15;
        border-left: 4px solid {success};
        border-radius: 4px;
        padding: 16px;
        margin: 12px 0;
    }}
    </style>
    """, unsafe_allow_html=True)

apply_enhanced_theme()

# ==============================
# UI COMPONENTS
# ==============================

def render_stat_card(title: str, value: str, icon: str = "📊"):
    """Render a statistics card."""
    st.markdown(f"""
    <div class="stat-card">
        <div style="font-size: 2em; margin-bottom: 8px;">{icon}</div>
        <div style="font-size: 1.8em; font-weight: 700; color: {st.session_state.get('accent', '#ff4b4b')}; margin-bottom: 4px;">{value}</div>
        <div style="color: {st.session_state.get('text_secondary', '#4a4a4a')}; font-size: 0.9em;">{title}</div>
    </div>
    """, unsafe_allow_html=True)

def render_badge(text: str, color: str = "#ff4b4b"):
    """Render a custom badge."""
    st.markdown(f'<span class="custom-badge" style="background: {color}20; color: {color}; border-color: {color}40;">{text}</span>', unsafe_allow_html=True)

def render_hero_section():
    """Render the hero section."""
    st.markdown("""
    <div class="hero-section">
        <h1 style="font-size: 3em; margin-bottom: 16px;">🐍 Python → Streamlit Converter Pro</h1>
        <p style="font-size: 1.2em; color: #666; margin-bottom: 24px;">
            Transform your <strong>Jupyter Notebooks</strong> and <strong>Python scripts</strong> into beautiful, 
            interactive <strong>Streamlit apps</strong> in seconds!
        </p>
        <div style="display: flex; gap: 12px; justify-content: center; flex-wrap: wrap;">
            <span class="custom-badge">✨ Auto-Conversion</span>
            <span class="custom-badge">📊 Handles Large Files</span>
            <span class="custom-badge">💬 Preserves Comments</span>
            <span class="custom-badge">📦 Batch Processing</span>
        </div>
    </div>
    """, unsafe_allow_html=True)

# ==============================
# ENHANCED SIDEBAR
# ==============================
with st.sidebar:
    # Logo and Title
    st.markdown("""
    <div style="text-align: center; padding: 20px 0;">
        <h1 style="font-size: 2.5em; margin: 0;">🐍</h1>
        <h2 style="margin-top: 8px; font-size: 1.2em;">Converter Pro</h2>
    </div>
    """, unsafe_allow_html=True)
    
    st.divider()
    
    # Quick Actions
    st.markdown("### ⚡ Quick Actions")
    
    col1, col2 = st.columns(2)
    with col1:
        theme_icon = "🌙" if st.session_state.theme == "light" else "☀️"
        if st.button(theme_icon, use_container_width=True, help="Toggle theme"):
            st.session_state.theme = "dark" if st.session_state.theme == "light" else "light"
            st.rerun()
    
    with col2:
        if (st.session_state.conversion_results or 
            st.session_state.uploaded_files or 
            st.session_state.uploaded_zip):
            if st.button("🔄", use_container_width=True, help="Clear all"):
                for key in list(st.session_state.keys()):
                    del st.session_state[key]
                init_session_state()
                st.rerun()
    
    st.divider()
    
    # Upload Section
    st.markdown("### 📥 Upload Files")
    upload_method = st.radio(
        "Upload Method",
        ["📁 Individual Files", "📦 ZIP Archive"],
        index=0,
        help="Choose how to upload your files",
        label_visibility="collapsed"
    )
    
    if upload_method == "📁 Individual Files":
        uploaded_files = st.file_uploader(
            "Select Python or Notebook files",
            type=["py", "ipynb"],
            accept_multiple_files=True,
            key="file_uploader",
            help="Upload one or more .py or .ipynb files"
        )
        st.session_state.uploaded_files = uploaded_files if uploaded_files else []
        st.session_state.uploaded_zip = None
    else:
        uploaded_zip = st.file_uploader(
            "Upload ZIP archive",
            type=["zip"],
            key="zip_uploader",
            help="Upload a ZIP file containing multiple Python/Notebook files"
        )
        st.session_state.uploaded_zip = uploaded_zip
        st.session_state.uploaded_files = []
    
    st.divider()
    
    # Advanced Settings
    with st.expander("🔧 Advanced Settings", expanded=False):
        st.session_state.conversion_mode = st.selectbox(
            "🧠 Conversion Strategy",
            ["Hybrid (Recommended)", "Auto", "AST (Precise)", "Regex (Fast)"],
            index=["Hybrid (Recommended)", "Auto", "AST (Precise)", "Regex (Fast)"].index(
                st.session_state.conversion_mode
            ) if st.session_state.conversion_mode in ["Hybrid (Recommended)", "Auto", "AST (Precise)", "Regex (Fast)"] else 0,
            help="Hybrid combines AST and regex for best results"
        )
        
        st.session_state.large_file_threshold = st.slider(
            "📏 Large File Threshold (KB)",
            min_value=50,
            max_value=5000,
            value=st.session_state.large_file_threshold,
            help="Files larger than this use optimized processing",
            step=50
        )
        
        st.session_state.add_main_guard = st.checkbox(
            "🛡️ Add `if __name__ == '__main__':` guard",
            value=st.session_state.add_main_guard,
            help="Prevents execution issues when imported"
        )
        
        st.session_state.preserve_comments = st.checkbox(
            "💬 Preserve Comments & Docstrings",
            value=st.session_state.preserve_comments,
            help="Keep all comments and documentation"
        )
    
    st.divider()
    
    # Sample Notebook Button
    if st.button("🧪 Load Sample Notebook", use_container_width=True, type="secondary"):
        sample_nb = get_sample_notebook()
        sample_bytes = nbformat.writes(sample_nb).encode('utf-8')
        st.session_state.uploaded_files = [io.BytesIO(sample_bytes)]
        st.session_state.uploaded_files[0].name = "sample_notebook.ipynb"
        st.rerun()
    
    st.divider()
    
    # Statistics
    if st.session_state.conversion_stats['total_files'] > 0:
        st.markdown("### 📊 Statistics")
        stats = st.session_state.conversion_stats
        st.metric("Total Files", stats['total_files'])
        st.metric("Successful", stats['successful'], delta=f"{stats['total_conversions']} conversions")
        if stats['failed'] > 0:
            st.metric("Failed", stats['failed'], delta_color="inverse")

# ==============================
# SAMPLE FILE GENERATOR
# ==============================
@st.cache_data
def get_sample_notebook():
    """Generate a sample notebook for testing."""
    nb = nbformat.v4.new_notebook()
    nb.cells = [
        nbformat.v4.new_markdown_cell("# Data Analysis Sample\n\nThis notebook demonstrates data visualization."),
        nbformat.v4.new_code_cell("import pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\n\n# Load sample data\ndf = pd.DataFrame({'x': np.random.randn(100), 'y': np.random.randn(100)})"),
        nbformat.v4.new_code_cell("print('Dataset shape:', df.shape)\nprint(f'Total rows: {len(df)}')"),
        nbformat.v4.new_code_cell("display(df.head())\ndisplay(df.describe())"),
        nbformat.v4.new_code_cell("plt.figure(figsize=(8,5))\nsns.scatterplot(data=df, x='x', y='y')\nplt.title('Scatter Plot')\nplt.show()"),
        nbformat.v4.new_code_cell("import plotly.express as px\nfig = px.scatter(df, x='x', y='y', title='Plotly Scatter')\nfig.show()")
    ]
    return nb

# ==============================
# ENHANCED CONVERTER CORE
# ==============================

class CommentPreservingTransformer(ast.NodeTransformer):
    """Enhanced AST transformer that preserves comments and handles more patterns."""
    def __init__(self, source_lines: List[str]):
        self.source_lines = source_lines
        self.conversion_log = []
        self.imports_needed = set()
        self.line_comments = {}
        
    def visit_Expr(self, node):
        """Transform expression statements like print, display, plt.show, etc."""
        if isinstance(node.value, ast.Call):
            call = node.value
            
            if self._is_print_call(call):
                self.conversion_log.append("Converted print() → st.write()")
                self.imports_needed.add("import streamlit as st")
                call.func = ast.Attribute(
                    value=ast.Name(id='st', ctx=ast.Load()),
                    attr='write',
                    ctx=ast.Load()
                )
                return node
            
            elif self._is_display_call(call):
                self.conversion_log.append("Converted display() → st.dataframe()")
                self.imports_needed.add("import streamlit as st")
                call.func = ast.Attribute(
                    value=ast.Name(id='st', ctx=ast.Load()),
                    attr='dataframe',
                    ctx=ast.Load()
                )
                return node
            
            elif self._is_plt_show_call(call):
                self.conversion_log.append("Converted plt.show() → st.pyplot()")
                self.imports_needed.add("import streamlit as st")
                self.imports_needed.add("import matplotlib.pyplot as plt")
                return ast.Expr(
                    value=ast.Call(
                        func=ast.Attribute(
                            value=ast.Name(id='st', ctx=ast.Load()),
                            attr='pyplot',
                            ctx=ast.Load()
                        ),
                        args=[ast.Call(
                            func=ast.Attribute(
                                value=ast.Name(id='plt', ctx=ast.Load()),
                                attr='gcf',
                                ctx=ast.Load()
                            ),
                            args=[], keywords=[]
                        )],
                        keywords=[]
                    )
                )
            
            elif self._is_plotly_show_call(call):
                var_name = self._get_call_attr_name(call)
                if var_name:
                    self.conversion_log.append(f"Converted {var_name}.show() → st.plotly_chart()")
                    self.imports_needed.add("import streamlit as st")
                    return ast.Expr(
                        value=ast.Call(
                            func=ast.Attribute(
                                value=ast.Name(id='st', ctx=ast.Load()),
                                attr='plotly_chart',
                                ctx=ast.Load()
                            ),
                            args=[ast.Name(id=var_name, ctx=ast.Load())],
                            keywords=[]
                        )
                    )
        
        return self.generic_visit(node)
    
    def visit_Call(self, node):
        """Handle method calls like df.head(), df.tail(), etc."""
        if isinstance(node.func, ast.Attribute):
            attr_name = node.func.attr
            
            if attr_name in ('head', 'tail') and isinstance(node.func.value, (ast.Name, ast.Attribute)):
                parent = getattr(node, '_parent', None)
                if parent is None or isinstance(parent, ast.Expr):
                    self.conversion_log.append(f"Wrapped {attr_name}() → st.dataframe()")
                    self.imports_needed.add("import streamlit as st")
                    return ast.Call(
                        func=ast.Attribute(
                            value=ast.Name(id='st', ctx=ast.Load()),
                            attr='dataframe',
                            ctx=ast.Load()
                        ),
                        args=[node],
                        keywords=[]
                    )
        
        return self.generic_visit(node)
    
    def _is_print_call(self, call):
        return (isinstance(call.func, ast.Name) and call.func.id == 'print')
    
    def _is_display_call(self, call):
        return (isinstance(call.func, ast.Name) and call.func.id == 'display')
    
    def _is_plt_show_call(self, call):
        return (isinstance(call.func, ast.Attribute) and
                isinstance(call.func.value, ast.Name) and
                call.func.value.id == 'plt' and
                call.func.attr == 'show')
    
    def _is_plotly_show_call(self, call):
        return (isinstance(call.func, ast.Attribute) and
                call.func.attr == 'show')
    
    def _get_call_attr_name(self, call):
        if isinstance(call.func, ast.Attribute):
            if isinstance(call.func.value, ast.Name):
                return call.func.value.id
        return None


class HybridConverter:
    """Hybrid converter that combines AST parsing with regex for comprehensive conversion."""
    def __init__(self, code: str, filename: str = "unknown", 
                 conversion_mode: str = "hybrid", large_file_threshold: int = 200,
                 add_main_guard: bool = False, preserve_comments: bool = True):
        self.original_code = code
        self.filename = filename
        self.conversion_mode = conversion_mode.lower()
        self.large_file_threshold = large_file_threshold * 1024
        self.add_main_guard = add_main_guard
        self.preserve_comments = preserve_comments
        self.conversion_report = []
        self.imports_needed = set()
        self.source_lines = code.splitlines(keepends=True)
        
    def convert(self) -> str:
        """Main conversion entry point."""
        file_size = len(self.original_code.encode('utf-8'))
        is_large = file_size > self.large_file_threshold
        
        if self.conversion_mode == "regex (fast)":
            self.conversion_report.append("✅ Using fast regex-based conversion")
            return self._regex_convert()
        elif self.conversion_mode == "ast (precise)":
            self.conversion_report.append("✅ Using precise AST-based conversion")
            return self._ast_convert()
        elif "hybrid" in self.conversion_mode:
            self.conversion_report.append("✅ Using hybrid conversion (AST + Regex)")
            return self._hybrid_convert()
        else:  # Auto mode
            if is_large:
                self.conversion_report.append(f"✅ Large file detected ({file_size/1024:.1f}KB), using hybrid mode")
                return self._hybrid_convert()
            else:
                self.conversion_report.append("✅ Using AST-based conversion")
                return self._ast_convert()
    
    def _hybrid_convert(self) -> str:
        """Hybrid approach: AST for structure, regex for patterns."""
        try:
            code = self._ast_convert_core()
            code = self._apply_regex_patterns(code)
            self._detect_needed_imports(self.original_code)
            return self._add_streamlit_boilerplate(code)
        except Exception as e:
            self.conversion_report.append(f"⚠️ Hybrid conversion issue: {e}, falling back to regex")
            return self._regex_convert()
    
    def _ast_convert(self) -> str:
        """Pure AST-based conversion."""
        try:
            code = self._ast_convert_core()
            self._detect_needed_imports(self.original_code)
            return self._add_streamlit_boilerplate(code)
        except Exception as e:
            self.conversion_report.append(f"⚠️ AST conversion failed: {e}, falling back to regex")
            return self._regex_convert()
    
    def _ast_convert_core(self) -> str:
        """Core AST conversion logic."""
        try:
            tree = ast.parse(self.original_code, filename=self.filename)
            transformer = CommentPreservingTransformer(self.source_lines)
            transformed_tree = transformer.visit(tree)
            ast.fix_missing_locations(transformed_tree)
            
            self.imports_needed.update(transformer.imports_needed)
            self.conversion_report.extend(transformer.conversion_log)
            
            try:
                return ast.unparse(transformed_tree)
            except AttributeError:
                return self._ast_to_source(transformed_tree)
        except SyntaxError as e:
            self.conversion_report.append(f"⚠️ Syntax error: {e}, using line-by-line fallback")
            return self._line_by_line_fallback()
        except Exception as e:
            self.conversion_report.append(f"⚠️ AST parsing error: {e}")
            raise
    
    def _ast_to_source(self, node) -> str:
        """Custom AST to source converter for Python < 3.9."""
        try:
            import astor
            return astor.to_source(node)
        except ImportError:
            self.conversion_report.append("⚠️ Python < 3.9 detected, using regex fallback")
            return self._regex_convert()
    
    def _apply_regex_patterns(self, code: str) -> str:
        """Apply regex patterns for additional conversions."""
        lines = code.splitlines(keepends=True)
        new_lines = []
        
        for line in lines:
            stripped = line.strip()
            
            if stripped.startswith("%") or stripped.startswith("!"):
                continue
            
            if re.search(r'^\s*([a-zA-Z_]\w*\.(?:head|tail)\([^)]*\))\s*$', stripped):
                match = re.search(r'([a-zA-Z_]\w*\.(?:head|tail)\([^)]*\))', stripped)
                if match:
                    indent = len(line) - len(line.lstrip())
                    new_lines.append(' ' * indent + f"st.dataframe({match.group(1)})\n")
                    self.conversion_report.append("✅ Wrapped DataFrame method → st.dataframe()")
                    continue
            
            if re.search(r'\.show\(\)', stripped) and ('sns.' in stripped or 'seaborn' in stripped):
                var_match = re.search(r'([a-zA-Z_]\w*)\.show\(\)', stripped)
                if var_match:
                    indent = len(line) - len(line.lstrip())
                    new_lines.append(' ' * indent + f"st.pyplot({var_match.group(1)})\n")
                    self.conversion_report.append("✅ Converted seaborn plot → st.pyplot()")
                    continue
            
            new_lines.append(line)
        
        return "".join(new_lines)
    
    def _regex_convert(self) -> str:
        """Regex-based conversion for large files or fallback."""
        lines = self.source_lines
        new_lines = []
        in_multiline_string = False
        
        i = 0
        while i < len(lines):
            line = lines[i]
            stripped = line.strip()
            
            if stripped.startswith("%") or stripped.startswith("!"):
                i += 1
                continue
            
            if '"""' in line or "'''" in line:
                triple_quotes = '"""' if '"""' in line else "'''"
                count = line.count(triple_quotes)
                if count % 2 == 1:
                    in_multiline_string = not in_multiline_string
                new_lines.append(line)
                i += 1
                continue
            
            if in_multiline_string:
                new_lines.append(line)
                i += 1
                continue
            
            if re.match(r'^\s*print\s*\(', stripped):
                new_line = re.sub(r'\bprint\s*\(', 'st.write(', line, count=1)
                new_lines.append(new_line)
                self.conversion_report.append("✅ Replaced print() → st.write()")
                self.imports_needed.add("import streamlit as st")
                i += 1
                continue
            
            if re.match(r'^\s*display\s*\(', stripped):
                new_line = re.sub(r'\bdisplay\s*\(', 'st.dataframe(', line, count=1)
                new_lines.append(new_line)
                self.conversion_report.append("✅ Replaced display() → st.dataframe()")
                self.imports_needed.add("import streamlit as st")
                i += 1
                continue
            
            if re.match(r'^\s*plt\.show\s*\(\s*\)', stripped):
                indent = len(line) - len(line.lstrip())
                new_lines.append(' ' * indent + "st.pyplot(plt.gcf())\n")
                self.conversion_report.append("✅ Replaced plt.show() → st.pyplot()")
                self.imports_needed.add("import streamlit as st")
                self.imports_needed.add("import matplotlib.pyplot as plt")
                i += 1
                continue
            
            if re.match(r'^\s*[a-zA-Z_]\w*\.show\s*\(\s*\)', stripped):
                match = re.search(r'([a-zA-Z_]\w*)\.show\s*\(\s*\)', stripped)
                if match:
                    var_name = match.group(1)
                    indent = len(line) - len(line.lstrip())
                    new_lines.append(' ' * indent + f"st.plotly_chart({var_name})\n")
                    self.conversion_report.append(f"✅ Replaced {var_name}.show() → st.plotly_chart()")
                    self.imports_needed.add("import streamlit as st")
                    i += 1
                    continue
            
            if re.match(r'^\s*[a-zA-Z_]\w*\.(?:head|tail)\s*\([^)]*\)\s*$', stripped):
                match = re.search(r'([a-zA-Z_]\w*\.(?:head|tail)\s*\([^)]*\))', stripped)
                if match:
                    indent = len(line) - len(line.lstrip())
                    new_lines.append(' ' * indent + f"st.dataframe({match.group(1)})\n")
                    self.conversion_report.append("✅ Wrapped DataFrame method → st.dataframe()")
                    self.imports_needed.add("import streamlit as st")
                    i += 1
                    continue
            
            new_lines.append(line)
            i += 1
        
        self._detect_needed_imports(self.original_code)
        return self._add_streamlit_boilerplate("".join(new_lines))
    
    def _line_by_line_fallback(self) -> str:
        """Fallback for when AST parsing fails."""
        return self._regex_convert()
    
    def _detect_needed_imports(self, code: str):
        """Detect which imports are needed based on code content."""
        code_lower = code.lower()
        self.imports_needed.add("import streamlit as st")
        
        if 'plt.' in code or 'matplotlib' in code_lower or 'pyplot' in code_lower:
            self.imports_needed.add("import matplotlib.pyplot as plt")
        if 'sns.' in code or 'seaborn' in code_lower:
            self.imports_needed.add("import seaborn as sns")
        if 'px.' in code or 'go.' in code or 'plotly' in code_lower:
            self.imports_needed.add("import plotly.express as px")
            self.imports_needed.add("import plotly.graph_objects as go")
        if 'pd.' in code or 'pandas' in code_lower or 'dataframe' in code_lower:
            self.imports_needed.add("import pandas as pd")
        if 'np.' in code or 'numpy' in code_lower:
            self.imports_needed.add("import numpy as np")
    
    def _add_streamlit_boilerplate(self, code: str) -> str:
        """Add Streamlit boilerplate and imports."""
        imports = sorted(list(self.imports_needed))
        
        existing_imports = []
        code_lines = code.splitlines()
        for line in code_lines[:20]:
            if line.strip().startswith('import ') or line.strip().startswith('from '):
                existing_imports.append(line.strip())
        
        filtered_imports = []
        for imp in imports:
            imp_name = imp.split()[1].split('.')[0] if 'import' in imp else None
            if imp_name:
                if not any(imp_name in existing for existing in existing_imports):
                    filtered_imports.append(imp)
            else:
                filtered_imports.append(imp)
        
        boilerplate = [
            "# ==============================",
            "# AUTO-GENERATED STREAMLIT APP",
            f"# Source: {self.filename}",
            "# Converted with Python → Streamlit Converter Pro",
            "# ==============================\n",
            *filtered_imports,
            "",
            "st.set_page_config(",
            "    page_title='Converted App',",
            "    layout='wide'",
            ")\n",
            "st.title('🐍 Converted Streamlit App')",
            f"st.caption(f'_Converted from: {self.filename}_')\n",
            "st.divider()\n"
        ]
        
        if self.add_main_guard:
            indented_code = "\n".join("    " + line if line.strip() else line 
                                     for line in code.splitlines())
            return "\n".join(boilerplate) + "\nif __name__ == '__main__':\n" + indented_code
        else:
            return "\n".join(boilerplate) + code
    
    def get_conversion_report(self) -> List[str]:
        """Get the conversion report."""
        if not self.conversion_report:
            return ["ℹ️ No transformations applied (code may already be Streamlit-compatible)"]
        seen = set()
        unique_report = []
        for item in self.conversion_report:
            if item not in seen:
                seen.add(item)
                unique_report.append(item)
        return unique_report


# ==============================
# NOTEBOOK PROCESSING
# ==============================

def extract_code_from_notebook(notebook_content: str, preserve_markdown: bool = True) -> str:
    """Convert notebook to Python script with enhanced markdown handling."""
    try:
        nb = nbformat.reads(notebook_content, as_version=4)
    except Exception as e:
        raise ValueError(f"Invalid notebook format: {e}")
    
    lines = []
    cell_num = 0
    
    for cell in nb.cells:
        cell_num += 1
        
        if cell.cell_type == "markdown" and preserve_markdown:
            md_content = cell.source
            lines.append(f"\n# {'='*60}")
            lines.append(f"# MARKDOWN CELL {cell_num}")
            lines.append(f"# {'='*60}")
            
            for md_line in md_content.split('\n'):
                if not md_line.strip():
                    lines.append("#")
                else:
                    clean_line = md_line.replace('"""', "'''").replace("'''", '"""')
                    if md_line.strip().startswith('#'):
                        lines.append(f"# {clean_line}")
                    else:
                        lines.append(f"# {clean_line}")
            lines.append("")
            
        elif cell.cell_type == "code":
            code_content = cell.source
            
            if lines and lines[-1].strip():
                lines.append("")
            
            if hasattr(cell, 'metadata') and cell.metadata:
                lines.append(f"# Cell {cell_num} metadata: {cell.metadata}")
            
            lines.append(code_content)
            
            if not code_content.endswith('\n'):
                lines.append("")
    
    result = "\n".join(lines)
    if not result.endswith('\n'):
        result += "\n"
    
    return result


# ==============================
# FILE PROCESSING UTILITIES
# ==============================

@st.cache_data(show_spinner=False)
def process_single_file_cached(file_bytes: bytes, filename: str, file_hash: str, 
                              conversion_mode: str, large_file_threshold: int, 
                              add_main_guard: bool, preserve_comments: bool):
    """Cached file processing function."""
    file_extension = Path(filename).suffix.lower()
    
    try:
        if file_extension == ".ipynb":
            original_code = extract_code_from_notebook(file_bytes.decode('utf-8'), 
                                                      preserve_markdown=preserve_comments)
        else:
            original_code = file_bytes.decode("utf-8")
        
        converter = HybridConverter(
            original_code, 
            filename, 
            conversion_mode=conversion_mode,
            large_file_threshold=large_file_threshold,
            add_main_guard=add_main_guard,
            preserve_comments=preserve_comments
        )
        streamlit_code = converter.convert()
        
        return streamlit_code, original_code, converter.get_conversion_report()
    
    except Exception as e:
        error_msg = f"Error processing {filename}: {str(e)}"
        return f"# {error_msg}\n# Original file could not be processed.", "", [f"❌ {error_msg}"]

def process_single_file(uploaded_file, **kwargs):
    """Process a single uploaded file."""
    file_bytes = uploaded_file.getvalue()
    file_hash = hashlib.md5(file_bytes).hexdigest()[:8]
    return process_single_file_cached(
        file_bytes, uploaded_file.name, file_hash, **kwargs
    )


# ==============================
# MAIN APP UI
# ==============================

# Hero Section
render_hero_section()

# Main Tabs
tab1, tab2, tab3 = st.tabs(["🚀 Convert Files", "📊 Dashboard", "ℹ️ How It Works"])

with tab1:
    if st.session_state.uploaded_files:
        st.markdown(f"### 📄 Processing {len(st.session_state.uploaded_files)} File(s)")
        
        for idx, uploaded_file in enumerate(st.session_state.uploaded_files):
            file_key = f"file_{idx}_{uploaded_file.name}"
            
            with st.container():
                st.markdown(f"<div class='main-card'>", unsafe_allow_html=True)
                
                # File Header
                col1, col2, col3 = st.columns([3, 1, 1])
                with col1:
                    st.markdown(f"#### 📑 {uploaded_file.name}")
                    file_size = len(uploaded_file.getvalue())
                    st.caption(f"Size: {file_size:,} bytes ({file_size/1024:.2f} KB)")
                
                with col2:
                    file_ext = Path(uploaded_file.name).suffix
                    render_badge(file_ext.upper().replace('.', ''), "#00d4aa")
                
                with col3:
                    render_badge("Ready", "#ff4b4b")
                
                try:
                    with st.spinner(f"🔄 Converting {uploaded_file.name}..."):
                        streamlit_code, original_code, report = process_single_file(
                            uploaded_file,
                            conversion_mode=st.session_state.conversion_mode.lower(),
                            large_file_threshold=st.session_state.large_file_threshold,
                            add_main_guard=st.session_state.add_main_guard,
                            preserve_comments=st.session_state.preserve_comments
                        )
                    
                    # Update stats
                    st.session_state.conversion_stats['total_files'] += 1
                    st.session_state.conversion_stats['successful'] += 1
                    st.session_state.conversion_stats['total_conversions'] += len([r for r in report if '✅' in r])
                    
                    st.success(f"✅ Successfully converted {uploaded_file.name}!")
                    
                    # View Mode Selector
                    view_mode = st.radio(
                        "👁️ View Mode",
                        ["🔁 Side-by-Side", "📜 Original Only", "✨ Converted Only"],
                        index=0,
                        horizontal=True,
                        key=f"view_{file_key}"
                    )

                    # Code Display
                    if "Side-by-Side" in view_mode:
                        col1, col2 = st.columns(2)
                        with col1:
                            st.markdown("##### 📜 Original Code")
                            display_original = original_code[:20000] + ("..." if len(original_code) > 20000 else "")
                            st.code(display_original, language="python", line_numbers=True)
                        with col2:
                            st.markdown("##### ✨ Converted Streamlit App")
                            display_converted = streamlit_code[:20000] + ("..." if len(streamlit_code) > 20000 else "")
                            st.code(display_converted, language="python", line_numbers=True)
                    elif "Original Only" in view_mode:
                        st.markdown("##### 📜 Original Code")
                        display_original = original_code[:30000] + ("..." if len(original_code) > 30000 else "")
                        st.code(display_original, language="python", line_numbers=True)
                    else:
                        st.markdown("##### ✨ Converted Streamlit App")
                        display_converted = streamlit_code[:30000] + ("..." if len(streamlit_code) > 30000 else "")
                        st.code(display_converted, language="python", line_numbers=True)
                    
                    # File Metrics
                    col1, col2, col3, col4 = st.columns(4)
                    with col1:
                        st.metric("Original Size", f"{len(original_code):,}", "chars")
                    with col2:
                        st.metric("Converted Size", f"{len(streamlit_code):,}", "chars")
                    with col3:
                        size_diff = len(streamlit_code) - len(original_code)
                        st.metric("Size Change", f"{size_diff:+,}", "chars")
                    with col4:
                        st.metric("Conversions", len([r for r in report if '✅' in r]), "transformations")
                    
                    # Download Button
                    st.download_button(
                        f"⬇️ Download {Path(uploaded_file.name).stem}_streamlit.py",
                        streamlit_code,
                        file_name=f"{Path(uploaded_file.name).stem}_streamlit.py",
                        mime="text/plain",
                        key=f"dl_{file_key}",
                        use_container_width=True,
                        type="primary"
                    )
                    
                    # Conversion Report
                    with st.expander("📋 Conversion Report", expanded=False):
                        for item in report:
                            if '✅' in item:
                                st.success(item)
                            elif '⚠️' in item:
                                st.warning(item)
                            elif '❌' in item:
                                st.error(item)
                            else:
                                st.info(item)
                
                except Exception as e:
                    st.session_state.conversion_stats['total_files'] += 1
                    st.session_state.conversion_stats['failed'] += 1
                    st.error(f"❌ Failed to convert `{uploaded_file.name}`: {str(e)}")
                    st.exception(e)
                
                st.markdown("</div>", unsafe_allow_html=True)
                st.divider()

    elif st.session_state.uploaded_zip:
        st.markdown("### 📦 Processing ZIP Archive")
        try:
            with st.spinner("Extracting and converting files..."):
                results = {}
                with zipfile.ZipFile(st.session_state.uploaded_zip) as zip_ref:
                    file_list = [f for f in zip_ref.namelist() if f.endswith(('.py', '.ipynb'))]
                    if not file_list:
                        st.warning("⚠️ No .py or .ipynb files found in ZIP!")
                    else:
                        progress_bar = st.progress(0)
                        status_text = st.empty()
                        
                        for i, filename in enumerate(file_list):
                            status_text.markdown(f"**Processing {i+1}/{len(file_list)}:** `{filename}`")
                            with zip_ref.open(filename) as f:
                                file_obj = io.BytesIO(f.read())
                                file_obj.name = filename
                                try:
                                    code, orig, rep = process_single_file(
                                        file_obj,
                                        conversion_mode=st.session_state.conversion_mode.lower(),
                                        large_file_threshold=st.session_state.large_file_threshold,
                                        add_main_guard=st.session_state.add_main_guard,
                                        preserve_comments=st.session_state.preserve_comments
                                    )
                                    results[filename] = (code, orig, rep)
                                    st.session_state.conversion_stats['successful'] += 1
                                except Exception as e:
                                    results[filename] = (f"# Conversion failed: {str(e)}", "", [f"❌ Error: {str(e)}"])
                                    st.session_state.conversion_stats['failed'] += 1
                            progress_bar.progress((i + 1) / len(file_list))
                            st.session_state.conversion_stats['total_files'] += 1
                        
                        status_text.empty()
                        progress_bar.empty()
                        
                        # Create ZIP of results
                        zip_buffer = io.BytesIO()
                        with zipfile.ZipFile(zip_buffer, "w") as zf:
                            for name, (code, _, _) in results.items():
                                if not code.startswith("# Conversion failed"):
                                    zf.writestr(f"{Path(name).stem}_streamlit.py", code)
                        
                        successful = len([r for r in results.values() if not r[0].startswith('# Conversion failed')])
                        st.success(f"✅ Successfully converted {successful}/{len(file_list)} file(s)")
                        
                        # Download Button
                        st.download_button(
                            "⬇️ Download All Converted Apps (ZIP)",
                            zip_buffer.getvalue(),
                            "streamlit_converted_apps.zip",
                            "application/zip",
                            use_container_width=True,
                            type="primary"
                        )
                        
                        # Results Display
                        for name, (code, orig, rep) in results.items():
                            with st.expander(f"📄 {name}", expanded=False):
                                if code.startswith("# Conversion failed"):
                                    st.error(code)
                                else:
                                    view_mode = st.radio(
                                        "👁️ View Mode",
                                        ["🔁 Side-by-Side", "📜 Original Only", "✨ Converted Only"],
                                        index=0,
                                        horizontal=True,
                                        key=f"view_{name}"
                                    )

                                    if "Side-by-Side" in view_mode:
                                        col1, col2 = st.columns(2)
                                        with col1:
                                            st.markdown("##### 📜 Original")
                                            st.code(orig[:5000] + ("..." if len(orig) > 5000 else ""), language="python")
                                        with col2:
                                            st.markdown("##### ✨ Converted")
                                            st.code(code[:5000] + ("..." if len(code) > 5000 else ""), language="python")
                                    elif "Original Only" in view_mode:
                                        st.code(orig[:10000] + ("..." if len(orig) > 10000 else ""), language="python")
                                    else:
                                        st.code(code[:10000] + ("..." if len(code) > 10000 else ""), language="python")
                                    
                                    with st.expander("📋 Report"):
                                        for r in rep:
                                            if '✅' in r:
                                                st.success(r)
                                            elif '❌' in r:
                                                st.error(r)
                                            else:
                                                st.info(r)
        except Exception as e:
            st.error(f"❌ ZIP processing failed: {str(e)}")
            st.exception(e)
    else:
        st.info("""
        👈 **Get Started:**
        1. Upload files using the sidebar (or try the sample notebook)
        2. Adjust settings if needed
        3. View and download your converted Streamlit apps!
        """)

with tab2:
    st.markdown("### 📊 Conversion Dashboard")
    
    stats = st.session_state.conversion_stats
    
    if stats['total_files'] > 0:
        col1, col2, col3, col4 = st.columns(4)
        with col1:
            render_stat_card("Total Files", str(stats['total_files']), "📁")
        with col2:
            render_stat_card("Successful", str(stats['successful']), "✅")
        with col3:
            render_stat_card("Failed", str(stats['failed']), "❌")
        with col4:
            render_stat_card("Total Conversions", str(stats['total_conversions']), "🔄")
        
        # Success Rate
        if stats['total_files'] > 0:
            success_rate = (stats['successful'] / stats['total_files']) * 100
            st.metric("Success Rate", f"{success_rate:.1f}%")
    else:
        st.info("📊 No conversions yet. Upload files to see statistics here!")

with tab3:
    st.markdown("### 📖 How It Works")
    
    st.markdown("""
    <div class="info-box">
    <h4>✨ Enhanced Conversion Engine</h4>
    <p><strong>Hybrid Mode (Recommended)</strong>: Combines AST parsing for structure with regex for patterns.
    - Preserves code structure and comments
    - Handles large files efficiently
    - Best balance of accuracy and performance</p>
    </div>
    """, unsafe_allow_html=True)
    
    st.markdown("""
    ### 🔄 Conversion Table
    
    | Original Code | → Streamlit Equivalent |
    |--------------|------------------------|
    | `print(x)` | `st.write(x)` |
    | `display(df)` | `st.dataframe(df)` |
    | `df.head()` / `df.tail()` | `st.dataframe(df.head())` |
    | `plt.show()` | `st.pyplot(plt.gcf())` |
    | `fig.show()` (Plotly) | `st.plotly_chart(fig)` |
    | Markdown cells | Commented markdown |
    | All comments | Preserved |
    """)
    
    st.markdown("""
    ### 📦 Key Features
    
    - ✅ **Large File Support**: Handles files up to 5MB+ efficiently
    - ✅ **Markdown Preservation**: Notebook markdown cells converted to comments
    - ✅ **Comment Preservation**: All comments and docstrings maintained
    - ✅ **ZIP Support**: Batch convert entire folders
    - ✅ **Error Recovery**: Graceful fallbacks for malformed code
    - ✅ **Import Detection**: Automatically adds required imports
    - ✅ **Real-time Statistics**: Track your conversion progress
    """)
    
    st.info("💡 **Pro Tip**: Use Hybrid mode for best results. It combines the accuracy of AST with the speed of regex!")