streamlit_app.py

"""
IntelliTag - Stack Overflow Tag Suggestion System
Streamlit Web Application

This app provides an interactive interface for predicting tags
for Stack Overflow questions using NLP and machine learning.
"""

import sys
import time
from pathlib import Path

import streamlit as st

# Add src to path for imports
sys.path.insert(0, str(Path(__file__).parent / "src"))

# Page configuration
st.set_page_config(
    page_title="IntelliTag - Tag Predictor",
    page_icon="🏷️",
    layout="wide",
    initial_sidebar_state="expanded",
)

# =============================================================================
# MODEL LOADING
# =============================================================================


@st.cache_resource
def load_intellitag_models():
    """Load IntelliTag models if available."""
    try:
        from intellitag.config.settings import settings
        from intellitag.data.preprocessor import TextPreprocessor
        from intellitag.features import BowExtractor
        from intellitag.models.classifier import TagClassifier

        preprocessor = TextPreprocessor.for_bow()

        extractor_path = settings.model_path / "bow_extractor.pkl"
        classifier_path = settings.model_path / "classifier.pkl"

        if extractor_path.exists() and classifier_path.exists():
            extractor = BowExtractor.load(extractor_path)
            classifier = TagClassifier.load(classifier_path)
            return {
                "preprocessor": preprocessor,
                "extractor": extractor,
                "classifier": classifier,
                "loaded": True,
            }
    except Exception as e:
        st.sidebar.warning(f"Model loading: {e}")

    return {"loaded": False}


def predict_tags_demo(title: str, body: str, top_k: int = 5) -> list:
    """
    Demo prediction based on keyword matching.
    Used when ML models are not available.
    """
    text = f"{title} {body}".lower()

    # Keyword-based tag suggestions (demo mode)
    tag_keywords = {
        "python": ["python", "pandas", "numpy", "django", "flask", "pip"],
        "javascript": ["javascript", "js", "node", "react", "vue", "angular"],
        "java": ["java", "spring", "maven", "gradle", "jvm"],
        "c#": ["c#", "csharp", ".net", "asp.net", "unity"],
        "html": ["html", "html5", "dom", "webpage"],
        "css": ["css", "css3", "flexbox", "grid", "sass", "bootstrap"],
        "sql": ["sql", "mysql", "postgresql", "database", "query"],
        "json": ["json", "parse", "serialize", "api"],
        "api": ["api", "rest", "endpoint", "request", "response"],
        "pandas": ["pandas", "dataframe", "series", "csv"],
        "numpy": ["numpy", "array", "matrix", "ndarray"],
        "machine-learning": ["machine learning", "ml", "model", "train", "predict"],
        "tensorflow": ["tensorflow", "keras", "neural", "deep learning"],
        "django": ["django", "orm", "views", "templates"],
        "flask": ["flask", "route", "blueprint"],
        "react": ["react", "jsx", "component", "hooks", "redux"],
        "node.js": ["node", "npm", "express", "async"],
        "git": ["git", "commit", "branch", "merge", "github"],
        "docker": ["docker", "container", "image", "dockerfile"],
        "regex": ["regex", "regular expression", "pattern", "match"],
        "list": ["list", "array", "append", "iterate"],
        "dictionary": ["dictionary", "dict", "key", "value", "hash"],
        "string": ["string", "text", "substring", "split", "join"],
        "file": ["file", "read", "write", "open", "path"],
        "error": ["error", "exception", "traceback", "debug"],
    }

    scores = {}
    for tag, keywords in tag_keywords.items():
        score = sum(1 for kw in keywords if kw in text)
        if score > 0:
            # Normalize score
            scores[tag] = min(0.95, 0.3 + score * 0.15)

    # Sort by score and return top_k
    sorted_tags = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:top_k]

    # If no matches, return generic tags
    if not sorted_tags:
        sorted_tags = [("python", 0.5), ("programming", 0.3), ("code", 0.2)][:top_k]

    return sorted_tags


def predict_tags_ml(
    models: dict, title: str, body: str, top_k: int = 5, threshold: float = 0.1
) -> list:
    """Predict tags using loaded ML models."""
    text = f"{title} {body}"

    # Preprocess
    preprocessed = models["preprocessor"].process(text)

    # Extract features
    features = models["extractor"].transform([preprocessed])

    # Predict
    models["classifier"].threshold = threshold
    models["classifier"].top_k = top_k
    predictions = models["classifier"].predict_with_proba(features)

    return predictions[0]


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


def render_sidebar():
    """Render sidebar with settings and info."""
    st.sidebar.title("🏷️ IntelliTag")
    st.sidebar.markdown("*Intelligent Tag Suggestions*")

    st.sidebar.markdown("---")

    # Settings
    st.sidebar.header("⚙️ Settings")

    top_k = st.sidebar.slider(
        "Number of tags",
        min_value=1,
        max_value=10,
        value=5,
        help="Maximum number of tags to suggest",
    )

    threshold = st.sidebar.slider(
        "Confidence threshold",
        min_value=0.0,
        max_value=1.0,
        value=0.1,
        step=0.05,
        help="Minimum confidence score for tag suggestions",
    )

    st.sidebar.markdown("---")

    # Model status
    st.sidebar.header("📊 Model Status")
    models = load_intellitag_models()

    if models["loaded"]:
        st.sidebar.success("✅ ML Models Loaded")
        n_tags = (
            models["classifier"].n_classes if models["classifier"]._is_fitted else "N/A"
        )
        st.sidebar.metric("Supported Tags", n_tags)
    else:
        st.sidebar.info("🎮 Demo Mode (keyword-based)")
        st.sidebar.caption("ML models not available. Using demo predictions.")

    st.sidebar.markdown("---")

    # About
    st.sidebar.header("ℹ️ About")
    st.sidebar.markdown("""
    **IntelliTag** is an intelligent tag suggestion system
    for Stack Overflow questions.

    - 🧠 Multi-model NLP pipeline
    - 📊 78% Precision@5 achieved
    - ⚡ <200ms latency

    [GitHub](https://github.com/ThomasMeb/Classifier_Questions_StackOverflow) |
    [API Docs](/docs)
    """)

    return top_k, threshold, models


def render_example_questions():
    """Render example question buttons."""
    st.markdown("##### 💡 Try an example:")

    examples = [
        {
            "title": "How to parse JSON in Python?",
            "body": "I have a JSON string and I want to convert it to a Python dictionary. What is the best way to do this? I tried using the json module but I'm getting errors when the JSON contains special characters.",
        },
        {
            "title": "React useState not updating immediately",
            "body": "I'm using useState in my React component but when I call setState, the value doesn't update immediately. I need to use the updated value right after setting it. How can I solve this? Should I use useEffect?",
        },
        {
            "title": "SQL query to find duplicates in a table",
            "body": "I have a MySQL database table with millions of rows and I need to find all duplicate entries based on the email column. What's the most efficient query to do this without affecting performance?",
        },
        {
            "title": "How to train a neural network with TensorFlow",
            "body": "I'm new to machine learning and want to build a simple neural network for image classification. I have a dataset of images and labels. Can someone explain how to structure the model and train it using TensorFlow/Keras?",
        },
    ]

    cols = st.columns(len(examples))
    for i, (col, example) in enumerate(zip(cols, examples)):
        with col:
            if st.button(
                f"Example {i+1}", key=f"example_{i}", use_container_width=True
            ):
                st.session_state.title = example["title"]
                st.session_state.body = example["body"]
                st.rerun()


def render_results(predictions: list, processing_time: float, is_demo: bool):
    """Render prediction results."""
    st.markdown("### 🏷️ Suggested Tags")

    if is_demo:
        st.caption("🎮 Demo mode - Results based on keyword matching")
    else:
        st.caption("🤖 ML model predictions")

    # Metrics row
    col1, col2, col3 = st.columns(3)
    with col1:
        st.metric("Tags Found", len(predictions))
    with col2:
        st.metric("Processing Time", f"{processing_time:.0f}ms")
    with col3:
        avg_conf = (
            sum(p[1] for p in predictions) / len(predictions) if predictions else 0
        )
        st.metric("Avg. Confidence", f"{avg_conf:.1%}")

    st.markdown("---")

    # Tags display
    if predictions:
        # Visual tags
        tag_html = " ".join(
            [
                f'<span style="background-color: {"#2ecc71" if conf > 0.7 else "#3498db" if conf > 0.4 else "#95a5a6"}; '
                f"color: white; padding: 5px 12px; border-radius: 15px; margin: 3px; display: inline-block; "
                f'font-size: 14px;">{tag} <small>({conf:.0%})</small></span>'
                for tag, conf in predictions
            ]
        )
        st.markdown(
            f'<div style="line-height: 2.5;">{tag_html}</div>', unsafe_allow_html=True
        )

        st.markdown("")

        # Detailed table
        with st.expander("📊 Detailed Confidence Scores"):
            for tag, conf in predictions:
                col1, col2 = st.columns([3, 1])
                with col1:
                    st.progress(conf, text=tag)
                with col2:
                    st.write(f"**{conf:.2%}**")
    else:
        st.warning(
            "No tags predicted. Try adjusting the threshold or adding more detail to your question."
        )


# =============================================================================
# MAIN APPLICATION
# =============================================================================


def main():
    """Main application entry point."""

    # Initialize session state
    if "title" not in st.session_state:
        st.session_state.title = ""
    if "body" not in st.session_state:
        st.session_state.body = ""

    # Render sidebar and get settings
    top_k, threshold, models = render_sidebar()

    # Main content
    st.title("🏷️ IntelliTag")
    st.markdown("### Intelligent Tag Suggestion for Stack Overflow Questions")

    st.markdown("""
    > Enter your Stack Overflow question below and get AI-powered tag suggestions
    > to help categorize your question effectively.
    """)

    # Example questions
    render_example_questions()

    st.markdown("---")

    # Input form
    st.markdown("### 📝 Your Question")

    title = st.text_input(
        "Question Title",
        value=st.session_state.title,
        max_chars=300,
        placeholder="e.g., How to parse JSON in Python?",
        help="Enter a clear, specific title (10-300 characters)",
    )

    body = st.text_area(
        "Question Body",
        value=st.session_state.body,
        height=200,
        max_chars=30000,
        placeholder="Describe your question in detail. Include code snippets, error messages, and what you've tried...",
        help="Provide detailed context (30-30,000 characters)",
    )

    # Validation
    title_valid = len(title) >= 10
    body_valid = len(body) >= 30

    col1, col2 = st.columns(2)
    with col1:
        if title and not title_valid:
            st.warning("⚠️ Title must be at least 10 characters")
    with col2:
        if body and not body_valid:
            st.warning("⚠️ Body must be at least 30 characters")

    # Predict button
    st.markdown("")
    predict_button = st.button(
        "🔮 Predict Tags",
        type="primary",
        disabled=not (title_valid and body_valid),
        use_container_width=True,
    )

    # Prediction
    if predict_button and title_valid and body_valid:
        with st.spinner("Analyzing your question..."):
            start_time = time.time()

            if models["loaded"]:
                predictions = predict_tags_ml(models, title, body, top_k, threshold)
                is_demo = False
            else:
                predictions = predict_tags_demo(title, body, top_k)
                # Filter by threshold
                predictions = [(t, c) for t, c in predictions if c >= threshold]
                is_demo = True

            processing_time = (time.time() - start_time) * 1000

        st.markdown("---")
        render_results(predictions, processing_time, is_demo)

    # Footer
    st.markdown("---")
    st.markdown(
        """
    <div style='text-align: center; color: gray; padding: 20px;'>
        <p>🏷️ <strong>IntelliTag</strong> - Stack Overflow Tag Suggestion System</p>
        <p>
            <a href='https://github.com/ThomasMeb/Classifier_Questions_StackOverflow'>GitHub</a> |
            Built with Streamlit & FastAPI |
            © 2026 Thomas Mebarki
        </p>
    </div>
    """,
        unsafe_allow_html=True,
    )


if __name__ == "__main__":
    main()