fix(state): Correct UI bugs and finalize modular integration

This commit finalizes the modular refactor by updating the main `app.py` script to correctly orchestrate the new components. It also addresses several critical UI and state management bugs that were present.

Key fixes:
- **Disappearing Buttons:** Fixes a critical bug where the 'Run Analysis' and 'Reset' buttons would disappear in Batch or Sample mode. The button rendering logic has been de-nested from conditional blocks to ensure it is drawn on every script rerun.
- **Redundant Rerun:** Removes an unnecessary `st.rerun()` call from a callback, resolving the "no-op" informational message from Streamlit.
- **State Logic:** Corrects a logical error in the `clear_batch_results` callback to ensure it targets the correct session state variable.
- **Orchestration:** The `app.py` script is now a clean, high-level orchestrator, responsible only for page setup and the main layout, delegating all other tasks to the appropriate modules.

app.py

@@ -1,1291 +1,41 @@
-from typing import Union
-from utils.multifile import create_batch_uploader, process_multiple_files, display_batch_results
-from utils.confidence import calculate_softmax_confidence, get_confidence_badge, create_confidence_progress_html
-from utils.results_manager import ResultsManager
-from utils.errors import ErrorHandler, safe_execute
-from utils.preprocessing import resample_spectrum
-from models.resnet_cnn import ResNet1D
-from models.figure2_cnn import Figure2CNN
-import hashlib
-import gc
-import time
-import io
-from PIL import Image
-import matplotlib.pyplot as plt
-import matplotlib
-import numpy as np
-import torch
-import torch.nn.functional as F
+"""Streamlit main entrance; modularized for clarity"""
+
 import streamlit as st
-import os
-import sys
-from pathlib import Path
 
-# Ensure 'utils' directory is in the Python path
-utils_path = Path(__file__).resolve().parent / "utils"
-if utils_path.is_dir() and str(utils_path) not in sys.path:
-    sys.path.append(str(utils_path))
-matplotlib.use("Agg")  # ensure headless rendering in Spaces
+from modules.callbacks import init_session_state
 
-# ==Import local modules + new modules==
+from modules.ui_components import (
+    render_sidebar,
+    render_results_column,
+    render_input_column,
+    load_css,
+)
 
-KEEP_KEYS = {
-    # ==global UI context we want to keep after "Reset"==
-    "model_select",     # sidebar model key
-    "input_mode",       # radio for Upload|Sample
-    "uploader_version",  # version counter for file uploader
-    "input_registry",   # radio controlling Upload vs Sample
-}
 
-# ==Page Configuration==
+# --- Page Setup (Called only ONCE) ---
 st.set_page_config(
     page_title="ML Polymer Classification",
     page_icon="🔬",
     layout="wide",
     initial_sidebar_state="expanded",
-    menu_items={
-        "Get help": "https://github.com/KLab-AI3/ml-polymer-recycling"}
+    menu_items={"Get help": "https://github.com/KLab-AI3/ml-polymer-recycling"},
 )
 
 
-# ==============================================================================
-# THEME-AWARE CUSTOM CSS
-# ==============================================================================
-# This CSS block has been refactored to use Streamlit's internal theme
-# variables. This ensures that all custom components will automatically adapt
-# to both light and dark themes selected by the user in the settings menu.
-st.markdown("""
-<style>
-/* ====== Font Imports (Optional but Recommended) ====== */
-@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&family=Fira+Code:wght@400&display=swap');
-
-/* ====== Base & Typography ====== */
-.stApp,
-section[data-testid="stSidebar"],
-div[data-testid="stMetricValue"],
-div[data-testid="stMetricLabel"] {
-  font-family: 'Inter', sans-serif;
-  /* Uses the main text color from the current theme (light or dark) */
-  color: var(--text-color);
-}
-
-.kv-val {
-  font-family: 'Fira Code', monospace;
-}
-
-/* ====== Custom Containers: Tabs & Info Boxes ====== */
-div[data-testid="stTabs"] > div[role="tablist"] + div {
-  min-height: 400px;
-  /* Uses the secondary background color, which is different in light and dark modes */
-  background-color: var(--secondary-background-color);
-  /* Border color uses a semi-transparent version of the text color for a subtle effect that works on any background */
-  border: 10px solid rgba(128, 128, 128, 0.2);
-  border-radius: 10px;
-  padding: 24px;
-  box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-}
-
-.info-box {
-  font-size: 0.9rem;
-  padding: 12px 16px;
-  border: 1px solid rgba(128, 128, 128, 0.2);
-  border-radius: 10px;
-  background-color: var(--secondary-background-color);
-}
-
-/* ====== Key-Value Pair Styling ====== */
-.kv-row {
-  display: flex;
-  justify-content: space-between;
-  gap: 16px;
-  padding: 8px 0;
-  border-bottom: 1px solid rgba(128, 128, 128, 0.2);
-}
-.kv-row:last-child {
-  border-bottom: none;
-}
-.kv-key {
-  opacity: 0.7;
-  font-size: 0.9rem;
-  white-space: nowrap;
-}
-.kv-val {
-  font-size: 0.9rem;
-  overflow-wrap: break-word;
-  text-align: right;
-}
-
-/* ====== Custom Expander Styling ====== */
-div.stExpander > details > summary::-webkit-details-marker,
-div.stExpander > details > summary::marker,
-div[data-testid="stExpander"] summary svg {
-  display: none !important;
-}
-
-div.stExpander > details > summary::after {
-  content: 'DETAILS';
-  font-size: 0.75rem;
-  font-weight: 600;
-  letter-spacing: 0.5px;
-  padding: 4px 12px;
-  border-radius: 999px;
-  /* The primary color is set in config.toml and adapted by Streamlit */
-  background-color: var(--primary);
-  /* Text on the primary color needs high contrast. White works well for our chosen purple. */
-
-  transition: background-color 0.2s ease-in-out;
-}
-
-div.stExpander > details > summary:hover::after {
-  /* Using a fixed darker shade on hover. A more advanced solution could use color-mix() in CSS. */
-  filter: brightness(90%);
-}
-
-/* Specialized Expander Labels */
-.expander-results div[data-testid="stExpander"] summary::after {
-  content: "RESULTS";
-  background-color: #16A34A; /* Green is universal for success */
-
-}
-div[data-testid="stExpander"] details {
-  content: "RESULTS";
-  background-color: var(--primary);
-  border-radius: 10px;
-  padding: 10px
-
-}
-.expander-advanced div[data-testid="stExpander"] summary::after {
-  content: "ADVANCED";
-  background-color: #D97706; /* Amber is universal for warning/technical */
-
-}
-
-[data-testid="stExpanderDetails"] {
-  padding: 16px 4px 4px 4px;
-  background-color: transparent;
-  border-top: 1px solid rgba(128, 128, 128, 0.2);
-  margin-top: 12px;
-}
-
-/* ====== Sidebar & Metrics ====== */
-section[data-testid="stSidebar"] > div:first-child {
-  background-color: var(--secondary-background-color);
-  border-right: 1px solid rgba(128, 128, 128, 0.2);
-}
-
-div[data-testid="stMetricValue"] {
-  font-size: 1.1rem !important;
-  font-weight: 500;
-}
-div[data-testid="stMetricLabel"] {
-  font-size: 0.85rem !important;
-  opacity: 0.8;
-}
-
-/* ====== Interactivity & Accessibility ====== */
-:focus-visible {
-  /* The focus outline now uses the theme's primary color */
-  outline: 2px solid var(--primary);
-  outline-offset: 2px;
-  border-radius: 8px;
-}
-</style>
-""", unsafe_allow_html=True)
-
-
-# ==CONSTANTS==
-TARGET_LEN = 500
-SAMPLE_DATA_DIR = Path("sample_data")
-# Prefer env var, else 'model_weights' if present; else canonical 'outputs'
-MODEL_WEIGHTS_DIR = (
-    os.getenv("WEIGHTS_DIR")
-    or ("model_weights" if os.path.isdir("model_weights") else "outputs")
-)
-
-# Model configuration
-MODEL_CONFIG = {
-    "Figure2CNN (Baseline)": {
-        "class": Figure2CNN,
-        "path": f"{MODEL_WEIGHTS_DIR}/figure2_model.pth",
-        "emoji": "",
-        "description": "Baseline CNN with standard filters",
-        "accuracy": "94.80%",
-        "f1": "94.30%"
-    },
-    "ResNet1D (Advanced)": {
-        "class": ResNet1D,
-        "path": f"{MODEL_WEIGHTS_DIR}/resnet_model.pth",
-        "emoji": "",
-        "description": "Residual CNN with deeper feature learning",
-        "accuracy": "96.20%",
-        "f1": "95.90%"
-    }
-}
-
-# ==Label mapping==
-LABEL_MAP = {0: "Stable (Unweathered)", 1: "Weathered (Degraded)"}
-
-
-# ==UTILITY FUNCTIONS==
-def init_session_state():
-    """Keep a persistent session state"""
-    defaults = {
-        "status_message": "Ready to analyze polymer spectra 🔬",
-        "status_type": "info",
-        "input_text": None,
-        "filename": None,
-        "input_source": None,     # "upload", "batch" or "sample"
-        "sample_select": "-- Select Sample --",
-        "input_mode": "Upload File",   # controls which pane is visible
-        "inference_run_once": False,
-        "x_raw": None, "y_raw": None, "y_resampled": None,
-        "log_messages": [],
-        "uploader_version": 0,
-        "current_upload_key": "upload_txt_0",
-        "active_tab": "Details",
-        "batch_mode": False,
-    }
-
-    if 'uploader_key' not in st.session_state:
-        st.session_state.uploader_key = 0
-
-    for k, v in defaults.items():
-        st.session_state.setdefault(k, v)
-
-    for key, default_value in defaults.items():
-        if key not in st.session_state:
-            st.session_state[key] = default_value
-
-    # ==Initialize results table==
-    ResultsManager.init_results_table()
-
-
-def label_file(filename: str) -> int:
-    """Extract label from filename based on naming convention"""
-    name = Path(filename).name.lower()
-    if name.startswith("sta"):
-        return 0
-    elif name.startswith("wea"):
-        return 1
-    else:
-        # Return None for unknown patterns instead of raising error
-        return -1  # Default value for unknown patterns
-
-
-@st.cache_data
-def load_state_dict(_mtime, model_path):
-    """Load state dict with mtime in cache key to detect file changes"""
-    try:
-        return torch.load(model_path, map_location="cpu")
-    except (FileNotFoundError, RuntimeError) as e:
-        st.warning(f"Error loading state dict: {e}")
-        return None
-
-
-@st.cache_resource
-def load_model(model_name):
-    """Load and cache the specified model with error handling"""
-    try:
-        config = MODEL_CONFIG[model_name]
-        model_class = config["class"]
-        model_path = config["path"]
-
-        # Initialize model
-        model = model_class(input_length=TARGET_LEN)
-
-        # Check if model file exists
-        if not os.path.exists(model_path):
-            st.warning(f"⚠️ Model weights not found: {model_path}")
-            st.info("Using randomly initialized model for demonstration purposes.")
-            return model, False
-
-        # Get mtime for cache invalidation
-        mtime = os.path.getmtime(model_path)
-
-        # Load weights
-        state_dict = load_state_dict(mtime, model_path)
-        if state_dict:
-            model.load_state_dict(state_dict, strict=True)
-            if model is None:
-                raise ValueError(
-                    "Model is not loaded. Please check the model configuration or weights.")
-            model.eval()
-            return model, True
-        else:
-            return model, False
-
-    except (FileNotFoundError, KeyError, RuntimeError) as e:
-        st.error(f"❌ Error loading model {model_name}: {str(e)}")
-        return None, False
-
-
-def cleanup_memory():
-    """Clean up memory after inference"""
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-
-
-@st.cache_data
-def run_inference(y_resampled, model_choice, _cache_key=None):
-    """Run model inference and cache results"""
-    model, model_loaded = load_model(model_choice)
-    if not model_loaded:
-        return None, None, None, None, None
-
-    input_tensor = torch.tensor(
-        y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
-    start_time = time.time()
-    model.eval()
-    with torch.no_grad():
-        if model is None:
-            raise ValueError(
-                "Model is not loaded. Please check the model configuration or weights.")
-        logits = model(input_tensor)
-        prediction = torch.argmax(logits, dim=1).item()
-        logits_list = logits.detach().numpy().tolist()[0]
-        probs = F.softmax(logits.detach(), dim=1).cpu().numpy().flatten()
-    inference_time = time.time() - start_time
-    cleanup_memory()
-    return prediction, logits_list, probs, inference_time,  logits
-
-
-@st.cache_data
-def get_sample_files():
-    """Get list of sample files if available"""
-    sample_dir = Path(SAMPLE_DATA_DIR)
-    if sample_dir.exists():
-        return sorted(list(sample_dir.glob("*.txt")))
-    return []
-
-
-def parse_spectrum_data(raw_text):
-    """Parse spectrum data from text with robust error handling and validation"""
-    x_vals, y_vals = [], []
-
-    for line in raw_text.splitlines():
-        line = line.strip()
-        if not line or line.startswith('#'):  # Skip empty lines and comments
-            continue
-
-        try:
-            # Handle different separators
-            parts = line.replace(",", " ").split()
-            numbers = [p for p in parts if p.replace('.', '', 1).replace(
-                '-', '', 1).replace('+', '', 1).isdigit()]
-
-            if len(numbers) >= 2:
-                x, y = float(numbers[0]), float(numbers[1])
-                x_vals.append(x)
-                y_vals.append(y)
-
-        except ValueError:
-            # Skip problematic lines but don't fail completely
-            continue
-
-    if len(x_vals) < 10:  # Minimum reasonable spectrum length
-        raise ValueError(
-            f"Insufficient data points: {len(x_vals)}. Need at least 10 points.")
-
-    x = np.array(x_vals)
-    y = np.array(y_vals)
-
-    # Check for NaNs
-    if np.any(np.isnan(x)) or np.any(np.isnan(y)):
-        raise ValueError("Input data contains NaN values")
-
-    # Check monotonic increasing x
-    if not np.all(np.diff(x) > 0):
-        raise ValueError("Wavenumbers must be strictly increasing")
-
-    # Check reasonable range for Raman spectroscopy
-    if min(x) < 0 or max(x) > 10000 or (max(x) - min(x)) < 100:
-        raise ValueError(
-            f"Invalid wavenumber range: {min(x)} - {max(x)}. Expected ~400-4000 cm⁻¹ with span >100")
-
-    return x, y
-
-
-@st.cache_data
-def create_spectrum_plot(x_raw, y_raw, x_resampled, y_resampled, _cache_key=None):
-    """Create spectrum visualization plot"""
-    fig, ax = plt.subplots(1, 2, figsize=(13, 5), dpi=100)
-
-    # == Raw spectrum ==
-    ax[0].plot(x_raw, y_raw, label="Raw", color="dimgray", linewidth=1)
-    ax[0].set_title("Raw Input Spectrum")
-    ax[0].set_xlabel("Wavenumber (cm⁻¹)")
-    ax[0].set_ylabel("Intensity")
-    ax[0].grid(True, alpha=0.3)
-    ax[0].legend()
-
-    # == Resampled spectrum ==
-    ax[1].plot(x_resampled, y_resampled, label="Resampled",
-               color="steelblue", linewidth=1)
-    ax[1].set_title(f"Resampled ({len(y_resampled)} points)")
-    ax[1].set_xlabel("Wavenumber (cm⁻¹)")
-    ax[1].set_ylabel("Intensity")
-    ax[1].grid(True, alpha=0.3)
-    ax[1].legend()
-
-    plt.tight_layout()
-    # == Convert to image ==
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png', bbox_inches='tight', dpi=100)
-    buf.seek(0)
-    plt.close(fig)  # Prevent memory leaks
-
-    return Image.open(buf)
-
-
-def render_confidence_progress(
-    probs: np.ndarray,
-    labels: list[str] = ["Stable", "Weathered"],
-    highlight_idx: Union[int, None] = None,
-    side_by_side: bool = True
-):
-    """Render Streamlit native progress bars with scientific formatting."""
-    p = np.asarray(probs, dtype=float)
-    p = np.clip(p, 0.0, 1.0)
-
-    if side_by_side:
-        cols = st.columns(len(labels))
-        for i, (lbl, val, col) in enumerate(zip(labels, p, cols)):
-            with col:
-                is_highlighted = (
-                    highlight_idx is not None and i == highlight_idx)
-                label_text = f"**{lbl}**" if is_highlighted else lbl
-                st.markdown(f"{label_text}: {val*100:.1f}%")
-                st.progress(int(round(val * 100)))
-    else:
-        # Vertical layout for better readability
-        for i, (lbl, val) in enumerate(zip(labels, p)):
-            is_highlighted = (highlight_idx is not None and i == highlight_idx)
-
-            # Create a container for each probability
-            with st.container():
-                col1, col2 = st.columns([3, 1])
-                with col1:
-                    if is_highlighted:
-                        st.markdown(f"**{lbl}** ← Predicted")
-                    else:
-                        st.markdown(f"{lbl}")
-                with col2:
-                    st.metric(
-                        label="",
-                        value=f"{val*100:.1f}%",
-                        delta=None
-                    )
-
-                # Progress bar with conditional styling
-                if is_highlighted:
-                    st.progress(int(round(val * 100)))
-                    st.caption("🎯 **Model Prediction**")
-                else:
-                    st.progress(int(round(val * 100)))
-
-                if i < len(labels) - 1:  # Add spacing between items
-                    st.markdown("")
-
-
-def render_kv_grid(d: dict, ncols: int = 2):
-    """Display dict as a clean grid of key/value rows using native Streamlit components."""
-    if not d:
-        return
-    items = list(d.items())
-    cols = st.columns(ncols)
-    for i, (k, v) in enumerate(items):
-        with cols[i % ncols]:
-            st.caption(f"**{k}:** {v}")
-
-
-def render_model_meta(model_choice: str):
-    info = MODEL_CONFIG.get(model_choice, {})
-    emoji = info.get("emoji", "")
-    desc = info.get("description", "").strip()
-    acc = info.get("accuracy", "-")
-    f1 = info.get("f1", "-")
-
-    st.caption(f"{emoji} **Model Snapshot** - {model_choice}")
-    cols = st.columns(2)
-    with cols[0]:
-        st.metric("Accuracy", acc)
-    with cols[1]:
-        st.metric("F1 Score", f1)
-    if desc:
-        st.caption(desc)
-
-
-def get_confidence_description(logit_margin):
-    """Get human-readable confidence description"""
-    if logit_margin > 1000:
-        return "VERY HIGH", "🟢"
-    elif logit_margin > 250:
-        return "HIGH", "🟡"
-    elif logit_margin > 100:
-        return "MODERATE", "🟠"
-    else:
-        return "LOW", "🔴"
-
-
-def log_message(msg: str):
-    """Append a timestamped line to the in-app log, creating the buffer if needed."""
-    ErrorHandler.log_info(msg)
-
-
-def trigger_run():
-    """Set a flag so we can detect button press reliably across reruns"""
-    st.session_state['run_requested'] = True
-
-
-def on_sample_change():
-    """Read selected sample once and persist as text."""
-    sel = st.session_state.get("sample_select", "-- Select Sample --")
-    if sel == "-- Select Sample --":
-        return
-    try:
-        text = (Path(SAMPLE_DATA_DIR / sel).read_text(encoding="utf-8"))
-        st.session_state["input_text"] = text
-        st.session_state["filename"] = sel
-        st.session_state["input_source"] = "sample"
-        # 🔧 Clear previous results so right column resets immediately
-        reset_results("New sample selected")
-        st.session_state["status_message"] = f"📁 Sample '{sel}' ready for analysis"
-        st.session_state["status_type"] = "success"
-    except (FileNotFoundError, IOError) as e:
-        st.session_state["status_message"] = f"❌ Error loading sample: {e}"
-        st.session_state["status_type"] = "error"
-
-
-def on_input_mode_change():
-    """Reset sample when switching to Upload"""
-    if st.session_state["input_mode"] == "Upload File":
-        st.session_state["sample_select"] = "-- Select Sample --"
-        st.session_state["batch_mode"] = False  # Reset batch mode
-    elif st.session_state["input_mode"] == "Sample Data":
-        st.session_state["batch_mode"] = False  # Reset batch mode
-    # 🔧 Reset when switching modes to prevent stale right-column visuals
-    reset_results("Switched input mode")
-
-
-def on_model_change():
-    """Force the right column back to init state when the model changes"""
-    reset_results("Model changed")
-
-
-def reset_results(reason: str = ""):
-    """Clear previous inference artifacts so the right column returns to initial state."""
-    st.session_state["inference_run_once"] = False
-    st.session_state["x_raw"] = None
-    st.session_state["y_raw"] = None
-    st.session_state["y_resampled"] = None
-    # ||== Clear batch results when resetting ==||
-    if "batch_results" in st.session_state:
-        del st.session_state["batch_results"]
-    # ||== Clear logs between runs ==||
-    st.session_state["log_messages"] = []
-    # ||== Always reset the status box ==||
-    st.session_state["status_message"] = (
-        f"ℹ️ {reason}"
-        if reason else "Ready to analyze polymer spectra 🔬"
-    )
-    st.session_state["status_type"] = "info"
-
-
-def reset_ephemeral_state():
-    """Comprehensive reset for the entire app state."""
-    # Define keys that should NOT be cleared by a full reset
-    keep_keys = {"model_select", "input_mode"}
-
-    for k in list(st.session_state.keys()):
-        if k not in keep_keys:
-            st.session_state.pop(k, None)
-
-    # Re-initialize the core state after clearing
-    init_session_state()
-
-    # CRITICAL: Bump the uploader version to force a widget reset
-    st.session_state["uploader_version"] += 1
-    st.session_state["current_upload_key"] = f"upload_txt_{st.session_state['uploader_version']}"
-
-
-# --- START: BUG 2 FIX (Callback Function) ---
-
-
-def clear_batch_results():
-    """Callback to clear only the batch results and the results log table."""
-    if "batch_results" in st.session_state:
-        del st.session_state["batch_files"]
-    # Also clear the persistent table from the ResultsManager utility
-    ResultsManager.clear_results()
-    st.rerun()
-# --- END: BUG 2 FIX (Callback Function) ---
-
-
-def reset_all():
-    # Increment the key to force the file uploader to re-render
-    st.session_state.uploader_key += 1
-
-
-# Main app
 def main():
+    """Modularized main content to other scripts to clean the main app"""
+    load_css("static/style.css")
     init_session_state()
 
-    # Sidebar
-    with st.sidebar:
-        # Header
-        st.header("AI-Driven Polymer Classification")
-        st.caption(
-            "Predict polymer degradation (Stable vs Weathered) from Raman spectra using validated CNN models. — v0.1")
-        model_labels = [
-            f"{MODEL_CONFIG[name]['emoji']} {name}" for name in MODEL_CONFIG.keys()]
-        selected_label = st.selectbox(
-            "Choose AI Model", model_labels, key="model_select", on_change=on_model_change)
-        model_choice = selected_label.split(" ", 1)[1]
-
-        # ===Compact metadata directly under dropdown===
-        render_model_meta(model_choice)
-
-        # ===Collapsed info to reduce clutter===
-        with st.expander("About This App", icon=":material/info:", expanded=False):
-            st.markdown("""
-            AI-Driven Polymer Aging Prediction and Classification
-
-            **Purpose**: Classify polymer degradation using AI
-            **Input**: Raman spectroscopy `.txt` files
-            **Models**: CNN architectures for binary classification
-            **Next**: More trained CNNs in evaluation pipeline
-
-
-            **Contributors**
-            Dr. Sanmukh Kuppannagari (Mentor)
-            Dr. Metin Karailyan (Mentor)
-            Jaser Hasan (Author)
-
-
-            **Links**
-            [Live HF Space](https://huggingface.co/spaces/dev-jas/polymer-aging-ml)
-            [GitHub Repository](https://github.com/KLab-AI3/ml-polymer-recycling)
-
+    # Render UI components
+    render_sidebar()
 
-            **Citation Figure2CNN (baseline)**
-            Neo et al., 2023, *Resour. Conserv. Recycl.*, 188, 106718.
-            [https://doi.org/10.1016/j.resconrec.2022.106718](https://doi.org/10.1016/j.resconrec.2022.106718)
-            """, )
-
-    # Main content area
     col1, col2 = st.columns([1, 1.35], gap="small")
-
     with col1:
-        st.markdown("##### Data Input")
-
-        mode = st.radio(
-            "Input mode",
-            ["Upload File", "Batch Upload", "Sample Data"],
-            key="input_mode",
-            horizontal=True,
-            on_change=on_input_mode_change
-        )
-
-        # ==Upload tab==
-        if mode == "Upload File":
-            upload_key = st.session_state["current_upload_key"]
-            up = st.file_uploader(
-                "Upload Raman spectrum (.txt)",
-                type="txt",
-                help="Upload a text file with wavenumber and intensity columns",
-                key=upload_key,     # ← versioned key
-            )
-
-            # ==Process change immediately (no on_change; simpler & reliable)==
-            if up is not None:
-                raw = up.read()
-                text = raw.decode("utf-8") if isinstance(raw, bytes) else raw
-                # == only reparse if its a different file|source ==
-                if st.session_state.get("filename") != getattr(up, "name", None) or st.session_state.get("input_source") != "upload":
-                    st.session_state["input_text"] = text
-                    st.session_state["filename"] = getattr(up, "name", None)
-                    st.session_state["input_source"] = "upload"
-                    # Ensure single file mode
-                    st.session_state["batch_mode"] = False
-                    st.session_state["status_message"] = f"File '{st.session_state['filename']}' ready for analysis"
-                    st.session_state["status_type"] = "success"
-                    reset_results("New file uploaded")
-
-        # ==Batch Upload tab==
-        elif mode == "Batch Upload":
-            st.session_state["batch_mode"] = True
-            # --- START: BUG 1 & 3 FIX ---
-            # Use a versioned key to ensure the file uploader resets properly.
-            batch_upload_key = f"batch_upload_{st.session_state['uploader_version']}"
-            uploaded_files = st.file_uploader(
-                "Upload multiple Raman spectrum files (.txt)",
-                type="txt",
-                accept_multiple_files=True,
-                help="Upload one or more text files with wavenumber and intensity columns.",
-                key=batch_upload_key
-            )
-            # --- END: BUG 1 & 3 FIX ---
-
-            if uploaded_files:
-                # --- START: Bug 1 Fix ---
-                # Use a dictionary to keep only unique files based on name and size
-                unique_files = {(file.name, file.size)
-                                 : file for file in uploaded_files}
-                unique_file_list = list(unique_files.values())
-
-                num_uploaded = len(uploaded_files)
-                num_unique = len(unique_file_list)
-
-                # Optionally, inform the user that duplicates were removed
-                if num_uploaded > num_unique:
-                    st.info(
-                        f"ℹ️ {num_uploaded - num_unique} duplicate file(s) were removed.")
-
-                # Use the unique list
-                st.session_state["batch_files"] = unique_file_list
-                st.session_state["status_message"] = f"{num_unique} ready for batch analysis"
-                st.session_state["status_type"] = "success"
-                # --- END: Bug 1 Fix ---
-            else:
-                st.session_state["batch_files"] = []
-                # This check prevents resetting the status if files are already staged
-                if not st.session_state.get("batch_files"):
-                    st.session_state["status_message"] = "No files selected for batch processing"
-                    st.session_state["status_type"] = "info"
-
-        # ==Sample tab==
-        elif mode == "Sample Data":
-            st.session_state["batch_mode"] = False
-            sample_files = get_sample_files()
-            if sample_files:
-                options = ["-- Select Sample --"] + \
-                    [p.name for p in sample_files]
-                sel = st.selectbox(
-                    "Choose sample spectrum:",
-                    options,
-                    key="sample_select",
-                    on_change=on_sample_change,
-                )
-                if sel != "-- Select Sample --":
-                    st.session_state["status_message"] = f"📁 Sample '{sel}' ready for analysis"
-                    st.session_state["status_type"] = "success"
-            else:
-                st.info("No sample data available")
-
-        # ==Status box==
-        msg = st.session_state.get("status_message", "Ready")
-        typ = st.session_state.get("status_type", "info")
-        if typ == "success":
-            st.success(msg)
-        elif typ == "error":
-            st.error(msg)
-        else:
-            st.info(msg)
-
-        # ==Model load==
-        model, model_loaded = load_model(model_choice)
-        if not model_loaded:
-            st.warning("⚠️ Model weights not available - using demo mode")
-
-        # ==Ready to run if we have text (single) or files (batch) and a model==|
-        is_batch_mode = st.session_state.get("batch_mode", False)
-        batch_files = st.session_state.get("batch_files", [])
-
-        inference_ready = False  # Initialize with a default value
-        if is_batch_mode:
-            inference_ready = len(batch_files) > 0 and (model is not None)
-        else:
-            inference_ready = st.session_state.get(
-                "input_text") is not None and (model is not None)
-
-        # === Run Analysis (form submit batches state) ===
-        with st.form("analysis_form", clear_on_submit=False):
-            submitted = st.form_submit_button(
-                "Run Analysis",
-                type="primary",
-                disabled=not inference_ready,
-            )
-
-        # Renamed for clarity and uses the robust on_click callback
-        st.button("Reset All", on_click=reset_ephemeral_state,
-                  help="Clear all uploaded files and results.")
-
-        if submitted and inference_ready:
-            if is_batch_mode:
-                with st.spinner(f"Processing {len(batch_files)} files ..."):
-                    try:
-                        batch_results = process_multiple_files(
-                            uploaded_files=batch_files,
-                            model_choice=model_choice,
-                            load_model_func=load_model,
-                            run_inference_func=run_inference,
-                            label_file_func=label_file
-                        )
-                        st.session_state["batch_results"] = batch_results
-                        st.success(
-                            f"Successfully processed {len([r for r in batch_results if r.get('success', False)])}/{len(batch_files)} files")
-                    except Exception as e:
-                        st.error(f"Error during batch processing: {e}")
-            else:
-                try:
-                    x_raw, y_raw = parse_spectrum_data(
-                        st.session_state["input_text"])
-                    x_resampled, y_resampled = resample_spectrum(
-                        x_raw, y_raw, TARGET_LEN)
-                    st.session_state["x_raw"] = x_raw
-                    st.session_state["y_raw"] = y_raw
-                    st.session_state["x_resampled"] = x_resampled
-                    st.session_state["y_resampled"] = y_resampled
-                    st.session_state["inference_run_once"] = True
-                except (ValueError, TypeError) as e:
-                    st.error(f"Error processing spectrum data: {e}")
-                    st.session_state["status_message"] = f"❌ Error: {e}"
-                    st.session_state["status_type"] = "error"
-
-    # Results column
+        render_input_column()
     with col2:
-
-        # Check if we're in batch more or have batch results
-        is_batch_mode = st.session_state.get("batch_mode", False)
-        has_batch_results = "batch_results" in st.session_state
-
-        if is_batch_mode and has_batch_results:
-            # Display batch results
-            st.markdown("##### Batch Analysis Results")
-            batch_results = st.session_state["batch_results"]
-            display_batch_results(batch_results)
-
-            # Add session results table
-            st.markdown("---")
-
-            # --- START: BUG 2 FIX (Button) ---
-            # This button will clear all results from col2 correctly.
-            # st.button("Clear Results", on_click=clear_batch_results,
-            #           help="Clear all uploaded files and results.")
-            # --- END: BUG 2 FIX (Button) ---
-
-            ResultsManager.display_results_table()
-
-        elif st.session_state.get("inference_run_once", False) and not is_batch_mode:
-            st.markdown("##### Analysis Results")
-
-            # Get data from session state
-            x_raw = st.session_state.get('x_raw')
-            y_raw = st.session_state.get('y_raw')
-            x_resampled = st.session_state.get('x_resampled')   # ← NEW
-            y_resampled = st.session_state.get('y_resampled')
-            filename = st.session_state.get('filename', 'Unknown')
-
-            if all(v is not None for v in [x_raw, y_raw, y_resampled]):
-                # ===Run inference===
-                if y_resampled is None:
-                    raise ValueError(
-                        "y_resampled is None. Ensure spectrum data is properly resampled before proceeding.")
-                cache_key = hashlib.md5(
-                    f"{y_resampled.tobytes()}{model_choice}".encode()).hexdigest()
-                prediction, logits_list, probs, inference_time, logits = run_inference(
-                    y_resampled, model_choice, _cache_key=cache_key
-                )
-                if prediction is None:
-                    st.error(
-                        "❌ Inference failed: Model not loaded. Please check that weights are available.")
-                    st.stop()  # prevents the rest of the code in this block from executing
-
-                log_message(
-                    f"Inference completed in {inference_time:.2f}s, prediction: {prediction}")
-
-                # ===Get ground truth===
-                true_label_idx = label_file(filename)
-                true_label_str = LABEL_MAP.get(
-                    true_label_idx, "Unknown") if true_label_idx is not None else "Unknown"
-                # ===Get prediction===
-                predicted_class = LABEL_MAP.get(
-                    int(prediction), f"Class {int(prediction)}")
-
-                # Enhanced confidence calculation
-                if logits is not None:
-                    # Use new softmax-based confidence
-                    probs_np, max_confidence, confidence_level, confidence_emoji = calculate_softmax_confidence(
-                        logits)
-                    confidence_desc = confidence_level
-                else:
-                    # Fallback to legace method
-                    logit_margin = abs(
-                        (logits_list[0] - logits_list[1]) if logits_list is not None and len(logits_list) >= 2 else 0)
-                    confidence_desc, confidence_emoji = get_confidence_description(
-                        logit_margin)
-                    max_confidence = logit_margin / 10.0  # Normalize for display
-                    probs_np = np.array([])
-
-                # Store result in results manager for single file too
-                ResultsManager.add_results(
-                    filename=filename,
-                    model_name=model_choice,
-                    prediction=int(prediction),
-                    predicted_class=predicted_class,
-                    confidence=max_confidence,
-                    logits=logits_list if logits_list else [],
-                    ground_truth=true_label_idx if true_label_idx >= 0 else None,
-                    processing_time=inference_time if inference_time is not None else 0.0,
-                    metadata={
-                        "confidence_level": confidence_desc,
-                        "confidence_emoji": confidence_emoji
-                    }
-                )
-
-                # ===Precompute Stats===
-                spec_stats = {
-                    "Original Length": len(x_raw) if x_raw is not None else 0,
-                    "Resampled Length": TARGET_LEN,
-                    "Wavenumber Range": f"{min(x_raw):.1f}-{max(x_raw):.1f} cm⁻¹" if x_raw is not None else "N/A",
-                    "Intensity Range": f"{min(y_raw):.1f}-{max(y_raw):.1f} au" if y_raw is not None else "N/A",
-                    "Confidence Bucket": confidence_desc,
-                }
-                model_path = MODEL_CONFIG[model_choice]["path"]
-                mtime = os.path.getmtime(
-                    model_path) if os.path.exists(model_path) else None
-                file_hash = (
-                    hashlib.md5(open(model_path, 'rb').read()).hexdigest()
-                    if os.path.exists(model_path) else "N/A"
-                )
-                input_tensor = torch.tensor(
-                    y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
-                model_stats = {
-                    "Architecture": model_choice,
-                    "Model Path": model_path,
-                    "Weights Last Modified": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime)) if mtime else "N/A",
-                    "Weights Hash (md5)": file_hash,
-                    "Input Shape": list(input_tensor.shape),
-                    "Output Shape": list(logits.shape) if logits is not None else "N/A",
-                    "Inference Time": f"{inference_time:.3f}s",
-                    "Device": "CPU",
-                    "Model Loaded": model_loaded,
-                }
-
-                start_render = time.time()
-
-                active_tab = st.selectbox(
-                    "View Results",
-                    ["Details", "Technical", "Explanation"],
-                    key="active_tab",   # reuse the key you were managing manually
-                )
-
-                if active_tab == "Details":
-                    st.markdown('<div class="expander-results">',
-                                unsafe_allow_html=True)
-                    # Use a dynamic and informative title for the expander
-                    with st.expander(f"Results for {filename}", expanded=True):
-
-                        # --- START: STREAMLINED METRICS ---
-                        # A single, powerful row for the most important results.
-                        key_metric_cols = st.columns(3)
-
-                        # Metric 1: The Prediction
-                        key_metric_cols[0].metric(
-                            "Prediction", predicted_class)
-
-                        # Metric 2: The Confidence (with level in tooltip)
-                        confidence_icon = "🟢" if max_confidence >= 0.8 else "🟡" if max_confidence >= 0.6 else "🔴"
-                        key_metric_cols[1].metric(
-                            "Confidence",
-                            f"{confidence_icon} {max_confidence:.1%}",
-                            help=f"Confidence Level: {confidence_desc}"
-                        )
-
-                        # Metric 3: Ground Truth + Correctness (Combined)
-                        if true_label_idx is not None:
-                            is_correct = (predicted_class == true_label_str)
-                            delta_text = "✅ Correct" if is_correct else "❌ Incorrect"
-                            # Use delta_color="normal" to let the icon provide the visual cue
-                            key_metric_cols[2].metric(
-                                "Ground Truth", true_label_str, delta=delta_text, delta_color="normal")
-                        else:
-                            key_metric_cols[2].metric("Ground Truth", "N/A")
-
-                        st.divider()
-                        # --- END: STREAMLINED METRICS ---
-
-                        # --- START: CONSOLIDATED CONFIDENCE ANALYSIS ---
-                        st.markdown("##### Probability Breakdown")
-
-                        # This custom bullet bar logic remains as it is highly specific and valuable
-                        def create_bullet_bar(probability, width=20, predicted=False):
-                            filled_count = int(probability * width)
-                            bar = "▤" * filled_count + \
-                                "▢" * (width - filled_count)
-                            percentage = f"{probability:.1%}"
-                            pred_marker = "↩ Predicted" if predicted else ""
-                            return f"{bar} {percentage}    {pred_marker}"
-
-                        stable_prob, weathered_prob = probs[0], probs[1]
-                        is_stable_predicted, is_weathered_predicted = (
-                            int(prediction) == 0), (int(prediction) == 1)
-
-                        st.markdown(f"""
-                            <div style="font-family: 'Fira Code', monospace;">
-                                Stable (Unweathered)<br>
-                                {create_bullet_bar(stable_prob, predicted=is_stable_predicted)}<br><br>
-                                Weathered (Degraded)<br>
-                                {create_bullet_bar(weathered_prob, predicted=is_weathered_predicted)}
-                            </div>
-                        """, unsafe_allow_html=True)
-                        # --- END: CONSOLIDATED CONFIDENCE ANALYSIS ---
-
-                        st.divider()
-
-                        # --- START: CLEAN METADATA FOOTER ---
-                        # Secondary info is now a clean, single-line caption
-                        st.caption(
-                            f"Analyzed with **{model_choice}** in **{inference_time:.2f}s**.")
-                        # --- END: CLEAN METADATA FOOTER ---
-
-                    st.markdown('</div>', unsafe_allow_html=True)
-
-                elif active_tab == "Technical":
-                    with st.container():
-                        st.markdown("Technical Diagnostics")
-
-                        # Model performance metrics
-                        with st.container(border=True):
-                            st.markdown("##### **Model Performance**")
-                            tech_col1, tech_col2 = st.columns(2)
-
-                            with tech_col1:
-                                st.metric("Inference Time",
-                                          f"{inference_time:.3f}s")
-                                st.metric(
-                                    "Input Length", f"{len(x_raw) if x_raw is not None else 0} points")
-                                st.metric("Resampled Length",
-                                          f"{TARGET_LEN} points")
-
-                            with tech_col2:
-                                st.metric("Model Loaded",
-                                          "✅ Yes" if model_loaded else "❌ No")
-                                st.metric("Device", "CPU")
-                                st.metric("Confidence Score",
-                                          f"{max_confidence:.3f}")
-
-                        # Raw logits display
-                        with st.container(border=True):
-                            st.markdown("##### **Raw Model Outputs (Logits)**")
-                            if logits_list is not None:
-                                logits_df = {
-                                    "Class": [LABEL_MAP.get(i, f"Class {i}") for i in range(len(logits_list))],
-                                    "Logit Value": [f"{score:.4f}" for score in logits_list],
-                                    "Probability": [f"{prob:.4f}" for prob in probs_np] if len(probs_np) > 0 else ["N/A"] * len(logits_list)
-                                }
-
-                            # Display as a simple table format
-                            for i, (cls, logit, prob) in enumerate(zip(logits_df["Class"], logits_df["Logit Value"], logits_df["Probability"])):
-                                col1, col2, col3 = st.columns([2, 1, 1])
-                                with col1:
-                                    if i == prediction:
-                                        st.markdown(f"**{cls}** ← Predicted")
-                                    else:
-                                        st.markdown(cls)
-                                with col2:
-                                    st.caption(f"Logit: {logit}")
-                                with col3:
-                                    st.caption(f"Prob: {prob}")
-
-                        # Spectrum statistics in organized sections
-                        with st.container(border=True):
-                            st.markdown("##### **Spectrum Analysis**")
-                            spec_cols = st.columns(2)
-
-                            with spec_cols[0]:
-                                st.markdown("**Original Spectrum:**")
-                                render_kv_grid({
-                                    "Length": f"{len(x_raw) if x_raw is not None else 0} points",
-                                    "Range": f"{min(x_raw):.1f} - {max(x_raw):.1f} cm⁻¹" if x_raw is not None else "N/A",
-                                    "Min Intensity": f"{min(y_raw):.2e}" if y_raw is not None else "N/A",
-                                    "Max Intensity": f"{max(y_raw):.2e}" if y_raw is not None else "N/A"
-                                }, ncols=1)
-
-                            with spec_cols[1]:
-                                st.markdown("**Processed Spectrum:**")
-                                render_kv_grid({
-                                    "Length": f"{TARGET_LEN} points",
-                                    "Resampling": "Linear interpolation",
-                                    "Normalization": "None",
-                                    "Input Shape": f"(1, 1, {TARGET_LEN})"
-                                }, ncols=1)
-
-                        # Model information
-                        with st.container(border=True):
-                            st.markdown("##### **Model Information**")
-                            model_info_cols = st.columns(2)
-
-                            with model_info_cols[0]:
-                                render_kv_grid({
-                                    "Architecture": model_choice,
-                                    "Path": MODEL_CONFIG[model_choice]["path"],
-                                    "Weights Modified": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime)) if mtime else "N/A"
-                                }, ncols=1)
-
-                            with model_info_cols[1]:
-                                if os.path.exists(model_path):
-                                    file_hash = hashlib.md5(
-                                        open(model_path, 'rb').read()).hexdigest()
-                                    render_kv_grid({
-                                        "Weights Hash": f"{file_hash[:16]}...",
-                                        "Output Shape": f"(1, {len(LABEL_MAP)})",
-                                        "Activation": "Softmax"
-                                    }, ncols=1)
-
-                        # Debug logs (collapsed by default)
-                        with st.expander("📋 Debug Logs", expanded=False):
-                            log_content = "\n".join(
-                                st.session_state.get("log_messages", []))
-                            if log_content.strip():
-                                st.code(log_content, language="text")
-                            else:
-                                st.caption("No debug logs available")
-
-                elif active_tab == "Explanation":
-                    with st.container():
-                        st.markdown("### 🔍 Methodology & Interpretation")
-
-                        # Process explanation
-                        st.markdown("Analysis Pipeline")
-                        process_steps = [
-                            "📁 **Data Upload**: Raman spectrum file loaded and validated",
-                            "🔍 **Preprocessing**: Spectrum parsed and resampled to 500 data points using linear interpolation",
-                            "🧠 **AI Inference**: Convolutional Neural Network analyzes spectral patterns and molecular signatures",
-                            "📊 **Classification**: Binary prediction with confidence scoring using softmax probabilities",
-                            "✅ **Validation**: Ground truth comparison (when available from filename)"
-                        ]
-
-                        for step in process_steps:
-                            st.markdown(step)
-
-                        st.markdown("---")
-
-                        # Model interpretation
-                        st.markdown("#### Scientific Interpretation")
-
-                        interp_col1, interp_col2 = st.columns(2)
-
-                        with interp_col1:
-                            st.markdown("**Stable (Unweathered) Polymers:**")
-                            st.info("""
-                            - Well-preserved molecular structure
-                            - Minimal oxidative degradation
-                            - Characteristic Raman peaks intact
-                            - Suitable for recycling applications
-                            """)
-
-                        with interp_col2:
-                            st.markdown("**Weathered (Degraded) Polymers:**")
-                            st.warning("""
-                            - Oxidized molecular bonds
-                            - Surface degradation present
-                            - Altered spectral signatures
-                            - May require additional processing
-                            """)
-
-                        st.markdown("---")
-
-                        # Applications
-                        st.markdown("#### Research Applications")
-
-                        applications = [
-                            "🔬 **Material Science**: Polymer degradation studies",
-                            "♻️ **Recycling Research**: Viability assessment for circular economy",
-                            "🌱 **Environmental Science**: Microplastic weathering analysis",
-                            "🏭 **Quality Control**: Manufacturing process monitoring",
-                            "📈 **Longevity Studies**: Material aging prediction"
-                        ]
-
-                        for app in applications:
-                            st.markdown(app)
-
-                        # Technical details
-                        # MODIFIED: Wrap the expander in a div with the 'expander-advanced' class
-                        st.markdown('<div class="expander-advanced">',
-                                    unsafe_allow_html=True)
-                        with st.expander("🔧 Technical Details", expanded=False):
-                            st.markdown("""
-                            **Model Architecture:**
-                            - Convolutional layers for feature extraction
-                            - Residual connections for gradient flow
-                            - Fully connected layers for classification
-                            - Softmax activation for probability distribution
-
-                            **Performance Metrics:**
-                            - Accuracy: 94.8-96.2% on validation set
-                            - F1-Score: 94.3-95.9% across classes
-                            - Robust to spectral noise and baseline variations
-
-                            **Data Processing:**
-                            - Input: Raman spectra (any length)
-                            - Resampling: Linear interpolation to 500 points
-                            - Normalization: None (preserves intensity relationships)
-                            """)
-                        st.markdown(
-                            '</div>', unsafe_allow_html=True)  # Close the wrapper div
-
-                        render_time = time.time() - start_render
-                        log_message(
-                            f"col2 rendered in {render_time:.2f}s, active tab: {active_tab}")
-
-                with st.expander("Spectrum Preprocessing Results", expanded=False):
-                    st.caption("<br>Spectral Analysis", unsafe_allow_html=True)
-
-                    # Add some context about the preprocessing
-                    st.markdown("""
-                    **Preprocessing Overview:**
-                    - **Original Spectrum**: Raw Raman data as uploaded
-                    - **Resampled Spectrum**: Data interpolated to 500 points for model input
-                    - **Purpose**: Ensures consistent input dimensions for neural network
-                    """)
-
-                    # Create and display plot
-                    cache_key = hashlib.md5(
-                        f"{(x_raw.tobytes() if x_raw is not None else b'')}"
-                        f"{(y_raw.tobytes() if y_raw is not None else b'')}"
-                        f"{(x_resampled.tobytes() if x_resampled is not None else b'')}"
-                        f"{(y_resampled.tobytes() if y_resampled is not None else b'')}".encode()
-                    ).hexdigest()
-                    spectrum_plot = create_spectrum_plot(
-                        x_raw, y_raw, x_resampled, y_resampled, _cache_key=cache_key)
-                    st.image(
-                        spectrum_plot, caption="Raman Spectrum: Raw vs Processed", use_container_width=True)
-
-            else:
-                st.error(
-                    "❌ Missing spectrum data. Please upload a file and run analysis.")
-        else:
-            # ===Getting Started===
-            st.markdown("""
-            ##### How to Get Started
-
-            1.  **Select an AI Model:** Use the dropdown menu in the sidebar to choose a model.
-            2.  **Provide Your Data:** Select one of the three input modes:
-                -   **Upload File:** Analyze a single spectrum.
-                -   **Batch Upload:** Process multiple files at once.
-                -   **Sample Data:** Explore functionality with pre-loaded examples.
-            3.  **Run Analysis:** Click the "Run Analysis" button to generate the classification results.
-
-            ---
-
-            ##### Supported Data Format
-
-            -   **File Type:** Plain text (`.txt`)
-            -   **Content:** Must contain two columns: `wavenumber` and `intensity`.
-            -   **Separators:** Values can be separated by spaces or commas.
-            -   **Preprocessing:** Your spectrum will be automatically resampled to 500 data points to match the model's input requirements.
-
-            ---
-
-            ##### Example Applications
-            - 🔬 Research on polymer degradation
-            - ♻️ Recycling feasibility assessment
-            - 🌱 Sustainability impact studies
-            - 🏭 Quality control in manufacturing
-            """)
+        render_results_column()
 
 
-# Run the application
-main()
+if __name__ == "__main__":
+    main()