app.py

"""
PaperTrack-Agent - Streamlit UI
A futuristic, tech-inspired interface for paper research
"""
import streamlit as st
import json
import time
from pathlib import Path
from datetime import datetime, timedelta
import plotly.express as px
import plotly.graph_objects as go
from typing import Dict, List, Any
import sys

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

# Page config - must be first
st.set_page_config(
    page_title="PaperTrack Agent",
    page_icon="🔬",
    layout="wide",
    initial_sidebar_state="expanded",
)

# Custom CSS for tech/cyberpunk style
st.markdown("""
<style>
    /* Main background */
    .stApp {
        background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 50%, #16213e 100%);
    }

    /* Sidebar */
    [data-testid="stSidebar"] {
        background: linear-gradient(180deg, #0f0f23 0%, #1a1a2e 100%);
        border-right: 1px solid #00d4ff33;
    }

    /* Headers */
    h1, h2, h3 {
        background: linear-gradient(90deg, #00d4ff, #7b2cbf, #ff006e);
        -webkit-background-clip: text;
        -webkit-text-fill-color: transparent;
        font-weight: 700;
    }

    /* Cards */
    .cyber-card {
        background: linear-gradient(145deg, #1a1a2e 0%, #0f0f23 100%);
        border: 1px solid #00d4ff33;
        border-radius: 15px;
        padding: 20px;
        margin: 10px 0;
        box-shadow: 0 0 20px rgba(0, 212, 255, 0.1);
        transition: all 0.3s ease;
    }

    .cyber-card:hover {
        border-color: #00d4ff;
        box-shadow: 0 0 30px rgba(0, 212, 255, 0.3);
        transform: translateY(-2px);
    }

    /* Glowing text */
    .glow-text {
        color: #00d4ff;
        text-shadow: 0 0 10px #00d4ff, 0 0 20px #00d4ff, 0 0 30px #00d4ff;
    }

    /* Progress bar */
    .stProgress > div > div {
        background: linear-gradient(90deg, #00d4ff, #7b2cbf, #ff006e);
    }

    /* Buttons */
    .stButton > button {
        background: linear-gradient(90deg, #00d4ff, #7b2cbf);
        color: white;
        border: none;
        border-radius: 25px;
        padding: 10px 30px;
        font-weight: 600;
        transition: all 0.3s ease;
        box-shadow: 0 0 15px rgba(0, 212, 255, 0.3);
    }

    .stButton > button:hover {
        transform: scale(1.05);
        box-shadow: 0 0 25px rgba(0, 212, 255, 0.5);
    }

    /* Input fields */
    .stTextInput > div > div > input,
    .stSelectbox > div > div > select {
        background: #1a1a2e;
        border: 1px solid #00d4ff33;
        color: #e0e0e0;
        border-radius: 10px;
    }

    /* Metrics */
    [data-testid="stMetricValue"] {
        color: #00d4ff;
        font-size: 2rem;
        text-shadow: 0 0 10px rgba(0, 212, 255, 0.5);
    }

    /* Expander */
    .streamlit-expanderHeader {
        background: #1a1a2e;
        border: 1px solid #00d4ff33;
        border-radius: 10px;
    }

    /* Agent status badge */
    .agent-badge {
        display: inline-block;
        padding: 5px 15px;
        border-radius: 20px;
        font-size: 0.8rem;
        font-weight: 600;
        margin: 5px;
    }

    .agent-active {
        background: linear-gradient(90deg, #00ff88, #00d4ff);
        color: #0a0a0a;
        animation: pulse 2s infinite;
    }

    .agent-idle {
        background: #333;
        color: #888;
    }

    .agent-complete {
        background: linear-gradient(90deg, #7b2cbf, #ff006e);
        color: white;
    }

    @keyframes pulse {
        0%, 100% { box-shadow: 0 0 5px #00ff88; }
        50% { box-shadow: 0 0 20px #00ff88; }
    }

    /* Animated border */
    .animated-border {
        position: relative;
        background: #1a1a2e;
        border-radius: 15px;
        padding: 20px;
    }

    .animated-border::before {
        content: '';
        position: absolute;
        top: -2px; left: -2px; right: -2px; bottom: -2px;
        background: linear-gradient(45deg, #00d4ff, #7b2cbf, #ff006e, #00d4ff);
        border-radius: 17px;
        z-index: -1;
        animation: borderRotate 3s linear infinite;
        background-size: 400% 400%;
    }

    @keyframes borderRotate {
        0% { background-position: 0% 50%; }
        50% { background-position: 100% 50%; }
        100% { background-position: 0% 50%; }
    }

    /* Paper card */
    .paper-card {
        background: linear-gradient(145deg, #1f1f3a 0%, #151528 100%);
        border-left: 4px solid #00d4ff;
        padding: 15px 20px;
        margin: 10px 0;
        border-radius: 0 10px 10px 0;
        transition: all 0.3s ease;
    }

    .paper-card:hover {
        border-left-color: #ff006e;
        transform: translateX(5px);
    }

    /* Insight card */
    .insight-card {
        background: linear-gradient(145deg, #1f1f3a 0%, #151528 100%);
        border: 1px solid #7b2cbf55;
        border-radius: 15px;
        padding: 20px;
        margin: 15px 0;
        transition: all 0.3s ease;
    }

    .insight-card:hover {
        border-color: #7b2cbf;
        box-shadow: 0 0 25px rgba(123, 44, 191, 0.3);
    }

    /* Trend badge */
    .trend-badge {
        display: inline-block;
        padding: 3px 12px;
        border-radius: 15px;
        font-size: 0.75rem;
        font-weight: 600;
        margin: 3px;
    }

    .trend-hot {
        background: linear-gradient(90deg, #ff006e, #ff4444);
        color: white;
    }

    .trend-rising {
        background: linear-gradient(90deg, #00d4ff, #00ff88);
        color: #0a0a0a;
    }

    .trend-stable {
        background: #444;
        color: #aaa;
    }

    /* Method comparison card */
    .method-card {
        background: linear-gradient(145deg, #1a2a3a 0%, #0f1a2a 100%);
        border: 1px solid #00d4ff33;
        border-radius: 12px;
        padding: 15px;
        margin: 10px 0;
    }

    /* Stats grid */
    .stats-grid {
        display: grid;
        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
        gap: 15px;
        margin: 20px 0;
    }

    .stat-item {
        background: linear-gradient(145deg, #1a1a2e 0%, #0f0f23 100%);
        border: 1px solid #00d4ff22;
        border-radius: 10px;
        padding: 15px;
        text-align: center;
    }

    .stat-value {
        font-size: 1.8rem;
        font-weight: 700;
        color: #00d4ff;
    }

    .stat-label {
        font-size: 0.85rem;
        color: #888;
        margin-top: 5px;
    }

    /* Timeline */
    .timeline-item {
        position: relative;
        padding-left: 30px;
        padding-bottom: 20px;
        border-left: 2px solid #00d4ff33;
    }

    .timeline-item::before {
        content: '';
        position: absolute;
        left: -6px;
        top: 0;
        width: 10px;
        height: 10px;
        border-radius: 50%;
        background: #00d4ff;
        box-shadow: 0 0 10px #00d4ff;
    }
</style>
""", unsafe_allow_html=True)


def create_header():
    """Create animated header"""
    st.markdown("""
    <div style="text-align: center; padding: 20px;">
        <h1 style="font-size: 3rem; margin-bottom: 0;">
            🔬 PaperTrack Agent
        </h1>
        <p style="color: #888; font-size: 1.2rem;">
            AI-Powered Research Paper Analysis System
        </p>
        <div style="display: flex; justify-content: center; gap: 20px; margin-top: 20px;">
            <span class="agent-badge agent-idle">🎯 Field Tracker</span>
            <span class="agent-badge agent-idle">📥 Paper Retrieval</span>
            <span class="agent-badge agent-idle">📖 Paper Reader</span>
            <span class="agent-badge agent-idle">💻 Code Extractor</span>
            <span class="agent-badge agent-idle">📊 Analyzer</span>
        </div>
    </div>
    """, unsafe_allow_html=True)


def create_phase_progress(current_phase: int, total_phases: int = 5):
    """Create phase progress indicator"""
    phases = ["Discovery", "Analysis", "Comparison", "Innovation", "Writing"]

    cols = st.columns(5)
    for i, (col, phase_name) in enumerate(zip(cols, phases)):
        with col:
            if i + 1 < current_phase:
                status = "✅"
                color = "#00ff88"
            elif i + 1 == current_phase:
                status = "🔄"
                color = "#00d4ff"
            else:
                status = "⏳"
                color = "#444"

            st.markdown(f"""
            <div style="text-align: center;">
                <div style="
                    width: 50px; height: 50px;
                    border-radius: 50%;
                    background: {color}22;
                    border: 2px solid {color};
                    display: flex; align-items: center; justify-content: center;
                    margin: 0 auto; font-size: 1.5rem;
                ">{status}</div>
                <p style="color: {color}; margin-top: 10px; font-size: 0.9rem;">{phase_name}</p>
            </div>
            """, unsafe_allow_html=True)


def create_agent_status_panel(agent_states: Dict[str, str]):
    """Create real-time agent status panel"""
    st.markdown("### 🤖 Agent Status")

    cols = st.columns(5)
    agents = [
        ("Field Tracker", "🎯"),
        ("Paper Retrieval", "📥"),
        ("Paper Reader", "📖"),
        ("Code Extractor", "💻"),
        ("Analyzer", "📊"),
    ]

    for col, (agent_name, icon) in zip(cols, agents):
        with col:
            status = agent_states.get(agent_name, "idle")
            if status == "running":
                badge_class = "agent-active"
                status_text = "Running..."
            elif status == "complete":
                badge_class = "agent-complete"
                status_text = "Complete"
            else:
                badge_class = "agent-idle"
                status_text = "Idle"

            st.markdown(f"""
            <div class="cyber-card" style="text-align: center; padding: 15px;">
                <div style="font-size: 2rem;">{icon}</div>
                <div style="color: #ddd; margin: 10px 0;">{agent_name}</div>
                <span class="agent-badge {badge_class}">{status_text}</span>
            </div>
            """, unsafe_allow_html=True)


def create_paper_card(paper: Dict[str, Any], index: int, paper_analyses: Dict[str, Any] = None):
    """Create a styled paper card with expandable details"""
    title = paper.get("title", "Unknown Title")
    authors = paper.get("authors", [])
    if isinstance(authors, list):
        authors_str = ", ".join(str(a) for a in authors[:3]) + ("..." if len(authors) > 3 else "")
    else:
        authors_str = str(authors)
    abstract = paper.get("abstract", "No abstract available")
    arxiv_id = paper.get("arxiv_id", "")
    published = paper.get("published", paper.get("published_date", ""))
    pdf_path = paper.get("pdf_path", "")
    pdf_url = paper.get("pdf_url", f"https://arxiv.org/pdf/{arxiv_id}")

    # Get detailed analysis if available
    analysis = None
    if paper_analyses:
        for field_analyses in paper_analyses.values():
            if isinstance(field_analyses, list):
                for a in field_analyses:
                    if a.get("arxiv_id") == arxiv_id:
                        analysis = a
                        break

    # Also check if paper itself has analysis data
    if not analysis and paper.get("structure"):
        analysis = paper

    # Create expandable card
    with st.expander(f"📄 #{index + 1} - {title[:80]}{'...' if len(title) > 80 else ''}", expanded=False):
        # Header info
        st.markdown(f"""
        <div style="margin-bottom: 15px;">
            <h4 style="color: #00d4ff; margin: 0 0 10px 0;">{title}</h4>
            <p style="color: #888; font-size: 0.9rem; margin: 5px 0;">👥 {authors_str}</p>
            <div style="margin-top: 8px;">
                <span style="color: #666; font-size: 0.85rem;">📅 {published[:10] if published else 'N/A'}</span>
                <span style="color: #666; font-size: 0.85rem; margin-left: 15px;">🔗 {arxiv_id}</span>
            </div>
        </div>
        """, unsafe_allow_html=True)

        # Action buttons
        col1, col2, col3 = st.columns(3)
        with col1:
            st.link_button("📥 View PDF (arXiv)", pdf_url, use_container_width=True)
        with col2:
            if pdf_path and Path(pdf_path).exists():
                st.success("✅ PDF Downloaded")
            else:
                st.warning("⚠️ PDF Not Downloaded")
        with col3:
            abs_url = f"https://arxiv.org/abs/{arxiv_id}"
            st.link_button("🔗 arXiv Page", abs_url, use_container_width=True)

        st.markdown("---")

        # Tabs for different sections
        detail_tabs = st.tabs(["📝 Abstract", "🔬 Methods", "📊 Results", "💡 Contributions"])

        with detail_tabs[0]:
            st.markdown("#### Abstract")
            st.markdown(f"<div style='color: #ccc; line-height: 1.6;'>{abstract}</div>", unsafe_allow_html=True)

        with detail_tabs[1]:
            if analysis and analysis.get("structure"):
                structure = analysis.get("structure", {})

                # Introduction
                intro = structure.get("introduction", "")
                if intro:
                    st.markdown("#### Introduction")
                    st.markdown(f"<div style='color: #aaa; line-height: 1.6;'>{intro[:1000]}{'...' if len(intro) > 1000 else ''}</div>", unsafe_allow_html=True)

                # Methodology
                methodology = structure.get("methodology", "")
                if methodology:
                    st.markdown("#### Methodology")
                    st.markdown(f"<div style='color: #aaa; line-height: 1.6;'>{methodology}</div>", unsafe_allow_html=True)

                # Technical details - algorithms
                tech = analysis.get("technical_details", {})
                algorithms = tech.get("algorithms", [])
                if algorithms:
                    st.markdown("#### Algorithms")
                    for algo in algorithms:
                        if isinstance(algo, dict):
                            st.markdown(f"""
                            <div class="method-card" style="margin: 10px 0; padding: 12px; background: #1a2a3a; border-radius: 8px; border-left: 3px solid #00d4ff;">
                                <strong style="color: #00d4ff;">{algo.get('name', 'Algorithm')}</strong>
                                <p style="color: #aaa; margin: 8px 0; font-size: 0.9rem;">{algo.get('description', '')}</p>
                                <p style="color: #7b2cbf; font-size: 0.85rem;"><em>Novelty: {algo.get('novelty', 'N/A')}</em></p>
                            </div>
                            """, unsafe_allow_html=True)
            else:
                st.info("No detailed methodology analysis available. Run the full pipeline to generate analysis.")

        with detail_tabs[2]:
            if analysis and analysis.get("structure"):
                structure = analysis.get("structure", {})

                # Experiments
                experiments = structure.get("experiments", "")
                if experiments:
                    st.markdown("#### Experiments")
                    st.markdown(f"<div style='color: #aaa; line-height: 1.6;'>{experiments}</div>", unsafe_allow_html=True)

                # Results
                results = structure.get("results", "")
                if results:
                    st.markdown("#### Results")
                    st.markdown(f"<div style='color: #aaa; line-height: 1.6;'>{results}</div>", unsafe_allow_html=True)

                # Metrics
                tech = analysis.get("technical_details", {})
                metrics = tech.get("metrics", [])
                if metrics:
                    st.markdown("#### Performance Metrics")
                    for metric in metrics:
                        if isinstance(metric, dict):
                            st.markdown(f"- **{metric.get('name', 'Metric')}**: {metric.get('value', 'N/A')} - {metric.get('comparison', '')}")

                # Baselines
                baselines = tech.get("baselines", [])
                if baselines:
                    st.markdown("#### Baselines Compared")
                    st.markdown(", ".join(str(b) for b in baselines))
            else:
                st.info("No detailed results analysis available. Run the full pipeline to generate analysis.")

        with detail_tabs[3]:
            if analysis and analysis.get("structure"):
                structure = analysis.get("structure", {})

                # Key contributions
                contributions = structure.get("key_contributions", [])
                if contributions:
                    st.markdown("#### Key Contributions")
                    for i, contrib in enumerate(contributions, 1):
                        st.markdown(f"""
                        <div style="margin: 10px 0; padding: 10px; background: #1f1f3a; border-radius: 8px; border-left: 3px solid #7b2cbf;">
                            <span style="color: #7b2cbf; font-weight: bold;">{i}.</span>
                            <span style="color: #ddd;"> {contrib}</span>
                        </div>
                        """, unsafe_allow_html=True)

                # Keywords
                keywords = structure.get("keywords", [])
                if keywords:
                    st.markdown("#### Keywords")
                    kw_html = " ".join([f'<span style="background: #00d4ff22; border: 1px solid #00d4ff; padding: 3px 10px; border-radius: 15px; margin: 3px; display: inline-block; color: #00d4ff; font-size: 0.85rem;">{kw}</span>' for kw in keywords])
                    st.markdown(f"<div style='margin: 10px 0;'>{kw_html}</div>", unsafe_allow_html=True)

                # Conclusion
                conclusion = structure.get("conclusion", "")
                if conclusion:
                    st.markdown("#### Conclusion")
                    st.markdown(f"<div style='color: #aaa; line-height: 1.6;'>{conclusion}</div>", unsafe_allow_html=True)
            else:
                st.info("No detailed contribution analysis available. Run the full pipeline to generate analysis.")


def create_metrics_dashboard(state: Dict[str, Any]):
    """Create metrics dashboard with animations"""
    col1, col2, col3, col4 = st.columns(4)

    with col1:
        tracked = sum(len(v.get("papers", [])) for v in state.get("tracked_papers", {}).values() if isinstance(v, dict))
        st.metric("📚 Papers Tracked", tracked)

    with col2:
        downloaded = sum(
            sum(1 for p in papers if p.get("download_status") == "success")
            for papers in state.get("retrieved_papers", {}).values()
            if isinstance(papers, list)
        )
        st.metric("📥 Downloaded", downloaded)

    with col3:
        analyzed = sum(
            sum(1 for p in papers if p.get("read_status") == "success")
            for papers in state.get("paper_analyses", {}).values()
            if isinstance(papers, list)
        )
        st.metric("🔍 Analyzed", analyzed)

    with col4:
        ideas = len(state.get("research_gaps", {}).get("research_ideas", []))
        st.metric("💡 Ideas Generated", ideas)


def create_trend_chart(trend_data: Dict[str, Any]):
    """Create interactive trend visualization"""
    if not trend_data or "error" in trend_data:
        st.info("No trend data available yet. Run the analysis to generate trends.")
        return

    # Get keywords data
    keywords = trend_data.get("keywords", {})
    hot_keywords = keywords.get("hot_keywords", [])

    if hot_keywords:
        # Create keyword frequency chart
        st.markdown("#### 🔥 Hot Keywords")

        kw_names = [kw.get("keyword", "Unknown")[:20] for kw in hot_keywords[:10]]
        kw_counts = [kw.get("count", kw.get("frequency", 1)) for kw in hot_keywords[:10]]

        fig = go.Figure(go.Bar(
            x=kw_counts,
            y=kw_names,
            orientation='h',
            marker=dict(
                color=kw_counts,
                colorscale=[[0, '#00d4ff'], [0.5, '#7b2cbf'], [1, '#ff006e']],
            ),
        ))

        fig.update_layout(
            template="plotly_dark",
            paper_bgcolor='rgba(0,0,0,0)',
            plot_bgcolor='rgba(0,0,0,0)',
            height=400,
            margin=dict(l=10, r=10, t=30, b=10),
            yaxis=dict(autorange="reversed"),
            xaxis_title="Frequency",
        )

        st.plotly_chart(fig, use_container_width=True)

        # Display keywords as badges
        st.markdown("#### 📈 Trending Topics")
        badge_html = ""
        for i, kw in enumerate(hot_keywords[:15]):
            name = kw.get("keyword", "Unknown")
            if i < 3:
                badge_class = "trend-hot"
            elif i < 8:
                badge_class = "trend-rising"
            else:
                badge_class = "trend-stable"
            badge_html += f'<span class="trend-badge {badge_class}">{name}</span>'

        st.markdown(f'<div style="margin: 15px 0;">{badge_html}</div>', unsafe_allow_html=True)

    # Technology evolution
    tech_evolution = trend_data.get("technology_evolution", {})
    if tech_evolution:
        st.markdown("#### 🚀 Technology Evolution")

        col1, col2 = st.columns(2)

        with col1:
            emerging = tech_evolution.get("emerging_technologies", [])
            if emerging:
                st.markdown("**Emerging Technologies:**")
                for tech in emerging[:5]:
                    if isinstance(tech, dict):
                        st.markdown(f"- 🌟 {tech.get('name', tech)}")
                    else:
                        st.markdown(f"- 🌟 {tech}")

        with col2:
            mature = tech_evolution.get("mature_technologies", [])
            if mature:
                st.markdown("**Mature Technologies:**")
                for tech in mature[:5]:
                    if isinstance(tech, dict):
                        st.markdown(f"- ✅ {tech.get('name', tech)}")
                    else:
                        st.markdown(f"- ✅ {tech}")

    # Research directions
    directions = trend_data.get("future_directions", trend_data.get("research_directions", []))
    if directions:
        st.markdown("#### 🔮 Future Research Directions")
        for i, direction in enumerate(directions[:5]):
            if isinstance(direction, dict):
                text = direction.get("direction", direction.get("description", str(direction)))
            else:
                text = str(direction)
            st.markdown(f"""
            <div class="timeline-item">
                <strong style="color: #00d4ff;">Direction {i+1}</strong>
                <p style="color: #aaa; margin: 5px 0;">{text}</p>
            </div>
            """, unsafe_allow_html=True)


def create_radar_chart(papers: List[Dict[str, Any]]):
    """Create paper comparison radar chart"""
    if not papers:
        st.info("No papers available for comparison")
        return

    categories = ['Novelty', 'Methodology', 'Results', 'Reproducibility', 'Impact']

    fig = go.Figure()

    colors = ['#00d4ff', '#7b2cbf', '#ff006e', '#00ff88', '#ffaa00']

    for i, paper in enumerate(papers[:5]):
        title = paper.get("structure", {}).get("title", paper.get("title", f"Paper {i+1}"))
        if len(title) > 30:
            title = title[:30] + "..."

        # Generate scores based on paper content analysis
        structure = paper.get("structure", {})
        technical = paper.get("technical_details", {})

        # Calculate scores (simplified scoring)
        novelty = min(5, 3 + len(structure.get("key_contributions", [])) * 0.5)
        methodology = min(5, 3 + len(technical.get("algorithms", [])) * 0.3)
        results = min(5, 3 + len(technical.get("metrics", [])) * 0.4)
        reproducibility = 4 if technical.get("implementation", {}).get("code_available") else 2.5
        impact = min(5, 3 + len(technical.get("datasets", [])) * 0.3)

        values = [novelty, methodology, results, reproducibility, impact]
        values.append(values[0])  # Close the radar

        fig.add_trace(go.Scatterpolar(
            r=values,
            theta=categories + [categories[0]],
            fill='toself',
            name=title,
            opacity=0.7,
            line=dict(color=colors[i % len(colors)]),
        ))

    fig.update_layout(
        polar=dict(
            radialaxis=dict(visible=True, range=[0, 5]),
            bgcolor='rgba(0,0,0,0)',
        ),
        template="plotly_dark",
        paper_bgcolor='rgba(0,0,0,0)',
        title="Paper Quality Comparison",
        showlegend=True,
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=-0.3,
            xanchor="center",
            x=0.5
        ),
        height=450,
    )

    st.plotly_chart(fig, use_container_width=True)


def create_analysis_view(state: Dict[str, Any]):
    """Create comprehensive analysis view"""
    comp = state.get("comparative_analysis", {})

    if not comp or isinstance(comp, str):
        st.info("No comparative analysis available yet. Run the full pipeline to generate analysis.")
        return

    # Method Comparison Section
    st.markdown("### 🔬 Method Comparison")

    method_comp = comp.get("method_comparison", {})

    col1, col2 = st.columns(2)

    with col1:
        # Common approaches
        common = method_comp.get("common_approaches", [])
        if common:
            st.markdown("#### Common Approaches")
            for approach in common[:6]:
                st.markdown(f"""
                <div class="method-card">
                    <span style="color: #00d4ff;">✓</span>
                    <span style="color: #ddd; margin-left: 10px;">{approach}</span>
                </div>
                """, unsafe_allow_html=True)

    with col2:
        # Unique methods
        unique = method_comp.get("unique_methods", [])
        if unique:
            st.markdown("#### Unique Methods")
            for method in unique[:6]:
                if isinstance(method, dict):
                    paper = method.get("paper", "Unknown")[:25]
                    method_text = method.get("method", "N/A")
                    novelty = method.get("novelty", "")
                    st.markdown(f"""
                    <div class="method-card">
                        <div style="color: #7b2cbf; font-weight: 600;">{paper}</div>
                        <div style="color: #ddd; margin: 5px 0;">{method_text}</div>
                        <div style="color: #888; font-size: 0.85rem;">💡 {novelty}</div>
                    </div>
                    """, unsafe_allow_html=True)

    # Strengths & Weaknesses
    st.markdown("---")
    st.markdown("### 💪 Strengths & Weaknesses Analysis")

    sw_analysis = method_comp.get("strengths_weaknesses", [])
    if sw_analysis:
        for item in sw_analysis[:4]:
            if isinstance(item, dict):
                paper = item.get("paper", "Unknown Paper")
                strengths = item.get("strengths", [])
                weaknesses = item.get("weaknesses", [])

                with st.expander(f"📄 {paper[:50]}"):
                    col1, col2 = st.columns(2)
                    with col1:
                        st.markdown("**✅ Strengths:**")
                        for s in strengths[:4]:
                            st.markdown(f"- {s}")
                    with col2:
                        st.markdown("**⚠️ Weaknesses:**")
                        for w in weaknesses[:4]:
                            st.markdown(f"- {w}")

    # Results Comparison
    st.markdown("---")
    st.markdown("### 📊 Results Comparison")

    result_comp = comp.get("result_comparison", {})

    col1, col2, col3 = st.columns(3)

    with col1:
        datasets = result_comp.get("common_datasets", [])
        if datasets:
            st.markdown("**📁 Common Datasets:**")
            for ds in datasets[:5]:
                st.markdown(f"- {ds}")

    with col2:
        metrics = result_comp.get("common_metrics", [])
        if metrics:
            st.markdown("**📏 Common Metrics:**")
            for m in metrics[:5]:
                st.markdown(f"- {m}")

    with col3:
        best = result_comp.get("best_performing", {})
        if best:
            st.markdown("**🏆 Best Performing:**")
            st.markdown(f"**{best.get('paper', 'N/A')}**")
            st.markdown(f"_{best.get('reason', '')}_")

    # Insights
    insights = result_comp.get("result_insights", [])
    if insights:
        st.markdown("#### 💡 Key Insights")
        for insight in insights[:5]:
            st.info(insight)

    # Research Themes
    st.markdown("---")
    st.markdown("### 🎯 Research Themes")

    themes = comp.get("research_themes", {})
    main_themes = themes.get("main_themes", [])

    if main_themes:
        cols = st.columns(min(3, len(main_themes)))
        for i, theme in enumerate(main_themes[:3]):
            with cols[i]:
                if isinstance(theme, dict):
                    st.markdown(f"""
                    <div class="insight-card">
                        <h4 style="color: #00d4ff; margin: 0;">{theme.get('theme', 'Theme')}</h4>
                        <p style="color: #aaa; font-size: 0.9rem; margin: 10px 0;">
                            {theme.get('description', '')[:150]}
                        </p>
                        <div style="margin-top: 10px;">
                            <strong style="color: #888;">Related Papers:</strong>
                            <div style="color: #666; font-size: 0.85rem;">
                                {', '.join(str(p)[:20] for p in theme.get('papers', [])[:3])}
                            </div>
                        </div>
                    </div>
                    """, unsafe_allow_html=True)


def create_insights_view(state: Dict[str, Any]):
    """Create research insights and gaps view"""
    gaps = state.get("research_gaps", {})

    if not gaps:
        st.info("No research insights available yet. Run the full pipeline including Phase 4 to generate insights.")

        # Show placeholder with what will be available
        st.markdown("""
        <div class="cyber-card">
            <h3 style="color: #7b2cbf;">🔮 What you'll discover:</h3>
            <ul style="color: #aaa;">
                <li>Identified research gaps in the field</li>
                <li>Novel research ideas and directions</li>
                <li>Unexplored combinations of methods</li>
                <li>Potential high-impact research opportunities</li>
            </ul>
        </div>
        """, unsafe_allow_html=True)
        return

    # Research Ideas
    ideas = gaps.get("research_ideas", [])
    if ideas:
        st.markdown("### 💡 Generated Research Ideas")

        for i, idea in enumerate(ideas[:5]):
            if isinstance(idea, dict):
                title = idea.get("title", f"Research Idea {i+1}")
                motivation = idea.get("motivation", "")
                approach = idea.get("approach", "")
                contribution = idea.get("expected_contribution", "")
                feasibility = idea.get("feasibility", "Medium")

                # Feasibility color
                feas_color = {"High": "#00ff88", "Medium": "#ffaa00", "Low": "#ff4444"}.get(feasibility, "#888")

                st.markdown(f"""
                <div class="insight-card">
                    <div style="display: flex; justify-content: space-between; align-items: start;">
                        <h4 style="color: #00d4ff; margin: 0;">💡 {title}</h4>
                        <span style="
                            background: {feas_color}22;
                            border: 1px solid {feas_color};
                            color: {feas_color};
                            padding: 3px 10px;
                            border-radius: 10px;
                            font-size: 0.8rem;
                        ">{feasibility} Feasibility</span>
                    </div>
                    <div style="margin-top: 15px;">
                        <p style="color: #888; margin-bottom: 5px;"><strong>Motivation:</strong></p>
                        <p style="color: #aaa;">{motivation}</p>
                    </div>
                    <div style="margin-top: 10px;">
                        <p style="color: #888; margin-bottom: 5px;"><strong>Approach:</strong></p>
                        <p style="color: #aaa;">{approach}</p>
                    </div>
                    <div style="margin-top: 10px;">
                        <p style="color: #888; margin-bottom: 5px;"><strong>Expected Contribution:</strong></p>
                        <p style="color: #ddd;">{contribution}</p>
                    </div>
                </div>
                """, unsafe_allow_html=True)

    # Research Gaps
    identified_gaps = gaps.get("gaps", gaps.get("identified_gaps", []))
    if identified_gaps:
        st.markdown("---")
        st.markdown("### 🔍 Identified Research Gaps")

        for gap in identified_gaps[:6]:
            if isinstance(gap, dict):
                area = gap.get("area", gap.get("gap", "Unknown Area"))
                description = gap.get("description", "")
                importance = gap.get("importance", "Medium")

                imp_color = {"High": "#ff006e", "Medium": "#7b2cbf", "Low": "#444"}.get(importance, "#444")

                st.markdown(f"""
                <div class="method-card" style="border-left: 4px solid {imp_color};">
                    <div style="display: flex; justify-content: space-between;">
                        <strong style="color: #ddd;">{area}</strong>
                        <span style="color: {imp_color}; font-size: 0.85rem;">{importance} Priority</span>
                    </div>
                    <p style="color: #888; margin-top: 8px; font-size: 0.9rem;">{description}</p>
                </div>
                """, unsafe_allow_html=True)
            else:
                st.markdown(f"- {gap}")

    # Unexplored Combinations
    combinations = gaps.get("unexplored_combinations", [])
    if combinations:
        st.markdown("---")
        st.markdown("### 🧬 Unexplored Method Combinations")

        cols = st.columns(2)
        for i, combo in enumerate(combinations[:4]):
            with cols[i % 2]:
                if isinstance(combo, dict):
                    methods = combo.get("methods", [])
                    potential = combo.get("potential", "")
                    st.markdown(f"""
                    <div class="cyber-card" style="padding: 15px;">
                        <div style="color: #00d4ff; font-weight: 600;">
                            {' + '.join(methods[:3])}
                        </div>
                        <p style="color: #888; font-size: 0.9rem; margin-top: 8px;">{potential}</p>
                    </div>
                    """, unsafe_allow_html=True)


def run_pipeline_with_ui(research_fields: List[str], time_range: str, max_papers: int, custom_days: int = None):
    """Run pipeline with real-time UI updates"""
    from src.agents import (
        FieldTrackerAgent,
        PaperRetrievalAgent,
        PaperReaderAgent,
        CodeExtractorAgent,
        ComparativeAnalysisAgent,
        TrendAnalyzerAgent,
        ResearchGapFinderAgent,
    )

    # Determine actual time range
    actual_time_range = time_range
    if time_range == "custom" and custom_days:
        actual_time_range = f"last_{custom_days}_days"

    # Initialize state
    state = {
        "research_fields": research_fields,
        "time_range": actual_time_range,
        "max_papers_per_field": max_papers,
        "tracked_papers": {},
        "retrieved_papers": {},
        "paper_analyses": {},
        "code_extractions": {},
        "comparative_analysis": {},
        "trend_analysis": {},
        "citation_network": {},
        "research_gaps": {},
    }

    progress_bar = st.progress(0)
    status_text = st.empty()
    log_container = st.empty()

    def log(message):
        log_container.markdown(f"```\n{message}\n```")

    # Phase 1: Field Tracking
    status_text.markdown("### 🎯 Phase 1: Field Tracking...")
    st.session_state.agent_states["Field Tracker"] = "running"

    try:
        tracker = FieldTrackerAgent(max_papers=max_papers)
        for field in research_fields:
            log(f"Tracking papers in field: {field}")
            result = tracker.track_papers(
                field=field,
                time_range=actual_time_range,
                max_papers=max_papers,
                expand_query=True,
            )
            state["tracked_papers"][field] = result
            log(f"Found {len(result.get('papers', []))} papers")
    except Exception as e:
        st.error(f"Field tracking error: {e}")
        return state

    st.session_state.agent_states["Field Tracker"] = "complete"
    progress_bar.progress(15)

    # Phase 1.2: Paper Retrieval
    status_text.markdown("### 📥 Phase 1.2: Paper Retrieval...")
    st.session_state.agent_states["Paper Retrieval"] = "running"

    try:
        retriever = PaperRetrievalAgent()
        for field, result in state["tracked_papers"].items():
            papers = result.get("papers", [])
            log(f"Downloading {len(papers)} papers...")
            retrieved = retriever.retrieve_papers(papers, field=field)
            state["retrieved_papers"][field] = retrieved
            success_count = sum(1 for p in retrieved if p.get("download_status") == "success")
            log(f"Successfully downloaded {success_count} papers")
    except Exception as e:
        st.error(f"Paper retrieval error: {e}")

    st.session_state.agent_states["Paper Retrieval"] = "complete"
    progress_bar.progress(30)

    # Phase 2: Paper Reading
    status_text.markdown("### 📖 Phase 2: Paper Reading...")
    st.session_state.agent_states["Paper Reader"] = "running"

    try:
        reader = PaperReaderAgent(extract_figures=True, max_figures_per_paper=5)
        for field, papers in state["retrieved_papers"].items():
            downloaded = [p for p in papers if p.get("download_status") == "success"]
            if downloaded:
                log(f"Analyzing {len(downloaded)} papers...")
                analyses = reader.read_papers(downloaded)
                state["paper_analyses"][field] = analyses
                success_count = sum(1 for p in analyses if p.get("read_status") == "success")
                log(f"Successfully analyzed {success_count} papers")
    except Exception as e:
        st.error(f"Paper reading error: {e}")

    st.session_state.agent_states["Paper Reader"] = "complete"
    progress_bar.progress(50)

    # Phase 2.2: Code Extraction
    status_text.markdown("### 💻 Phase 2.2: Code Extraction...")
    st.session_state.agent_states["Code Extractor"] = "running"

    try:
        extractor = CodeExtractorAgent()
        for field, analyses in state["paper_analyses"].items():
            log(f"Extracting code from papers...")
            extractions = extractor.extract_from_papers(analyses, {})
            state["code_extractions"][field] = extractions
    except Exception as e:
        st.error(f"Code extraction error: {e}")

    st.session_state.agent_states["Code Extractor"] = "complete"
    progress_bar.progress(65)

    # Phase 3: Analysis
    status_text.markdown("### 📊 Phase 3: Comparative Analysis...")
    st.session_state.agent_states["Analyzer"] = "running"

    all_papers = []
    for field, analyses in state["paper_analyses"].items():
        for paper in analyses:
            paper["field"] = field
            all_papers.append(paper)

    if all_papers:
        try:
            log("Running comparative analysis...")
            comparator = ComparativeAnalysisAgent()
            state["comparative_analysis"] = comparator.analyze(all_papers, field=research_fields[0])

            log("Analyzing trends...")
            trend_analyzer = TrendAnalyzerAgent()
            state["trend_analysis"] = trend_analyzer.analyze(all_papers, field=research_fields[0])
        except Exception as e:
            st.error(f"Analysis error: {e}")

    progress_bar.progress(80)

    # Phase 4: Research Gaps
    status_text.markdown("### 🔍 Phase 4: Finding Research Gaps...")

    if all_papers:
        try:
            log("Identifying research gaps...")
            gap_finder = ResearchGapFinderAgent()
            state["research_gaps"] = gap_finder.analyze(all_papers, field=research_fields[0])
        except Exception as e:
            st.error(f"Research gap finding error: {e}")

    st.session_state.agent_states["Analyzer"] = "complete"
    progress_bar.progress(100)

    status_text.markdown("### ✅ Pipeline Complete!")
    log_container.empty()

    # Save state
    save_pipeline_state(state)

    return state


def save_pipeline_state(state: Dict[str, Any]):
    """Save pipeline state to file"""
    output_dir = Path("./outputs")
    output_dir.mkdir(parents=True, exist_ok=True)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    state_path = output_dir / f"pipeline_state_{timestamp}.json"

    # Create a JSON-serializable version
    def make_serializable(obj):
        if isinstance(obj, dict):
            return {k: make_serializable(v) for k, v in obj.items()}
        elif isinstance(obj, list):
            return [make_serializable(v) for v in obj]
        elif isinstance(obj, (datetime,)):
            return obj.isoformat()
        elif hasattr(obj, '__dict__'):
            return str(obj)
        else:
            return obj

    try:
        with open(state_path, "w", encoding="utf-8") as f:
            json.dump(make_serializable(state), f, indent=2, ensure_ascii=False)
        st.success(f"Results saved to: {state_path}")
    except Exception as e:
        st.warning(f"Could not save state: {e}")


def load_latest_state():
    """Load the most recent pipeline state if available"""
    output_dir = Path("./outputs")
    if output_dir.exists():
        json_files = list(output_dir.glob("pipeline_state_*.json"))
        if json_files:
            latest_file = max(json_files, key=lambda f: f.stat().st_mtime)
            try:
                with open(latest_file, 'r', encoding='utf-8') as f:
                    return json.load(f), latest_file.name
            except Exception:
                pass
    return None, None


def main():
    """Main application"""
    # Initialize session state
    if "state" not in st.session_state:
        st.session_state.state = None
    if "running" not in st.session_state:
        st.session_state.running = False
    if "agent_states" not in st.session_state:
        st.session_state.agent_states = {
            "Field Tracker": "idle",
            "Paper Retrieval": "idle",
            "Paper Reader": "idle",
            "Code Extractor": "idle",
            "Analyzer": "idle",
        }
    if "auto_loaded" not in st.session_state:
        st.session_state.auto_loaded = False

    # Auto-load latest results on first visit
    if not st.session_state.auto_loaded and st.session_state.state is None:
        latest_state, latest_file = load_latest_state()
        if latest_state:
            st.session_state.state = latest_state
            st.session_state.loaded_file = latest_file
        st.session_state.auto_loaded = True

    # Header
    create_header()

    # Sidebar
    with st.sidebar:
        st.markdown("## ⚙️ Configuration")

        research_field = st.text_input(
            "🔬 Research Field",
            value="Multi-Agent Systems",
            help="Enter your research field of interest"
        )

        st.markdown("---")
        st.markdown("### 📅 Time Range")

        time_range_option = st.radio(
            "Select time range:",
            options=["preset", "custom"],
            format_func=lambda x: "📆 Preset Options" if x == "preset" else "🎯 Custom Range",
            horizontal=True
        )

        if time_range_option == "preset":
            time_range = st.selectbox(
                "Choose range:",
                options=["last_7_days", "last_month", "last_3_months", "last_6_months", "last_year"],
                format_func=lambda x: {
                    "last_7_days": "📅 Last 7 Days",
                    "last_month": "📆 Last Month",
                    "last_3_months": "🗓️ Last 3 Months",
                    "last_6_months": "📊 Last 6 Months",
                    "last_year": "📈 Last Year"
                }.get(x, x)
            )
            custom_days = None
        else:
            time_range = "custom"
            custom_days = st.slider(
                "Number of days:",
                min_value=1,
                max_value=365,
                value=30,
                help="Select custom number of days to look back"
            )

            # Show date range preview
            end_date = datetime.now()
            start_date = end_date - timedelta(days=custom_days)
            st.markdown(f"""
            <div style="
                background: #1a1a2e;
                border: 1px solid #00d4ff33;
                border-radius: 10px;
                padding: 10px;
                margin: 10px 0;
                font-size: 0.9rem;
            ">
                <span style="color: #888;">From:</span> <span style="color: #00d4ff;">{start_date.strftime('%Y-%m-%d')}</span><br>
                <span style="color: #888;">To:</span> <span style="color: #00d4ff;">{end_date.strftime('%Y-%m-%d')}</span>
            </div>
            """, unsafe_allow_html=True)

        st.markdown("---")
        st.markdown("### 📚 Paper Settings")

        max_papers = st.slider(
            "Max Papers per Field",
            min_value=3,
            max_value=50,
            value=10,
            help="Maximum papers to analyze"
        )

        st.markdown("---")

        # Start button
        start_disabled = st.session_state.running
        if st.button("🚀 Start Analysis", use_container_width=True, disabled=start_disabled):
            st.session_state.running = True
            st.session_state.agent_states = {k: "idle" for k in st.session_state.agent_states}

        st.markdown("---")

        # Load previous results
        st.markdown("### 📂 Previous Results")

        # Show currently loaded file
        if st.session_state.state and hasattr(st.session_state, 'loaded_file'):
            st.markdown(f"""
            <div style="
                background: #1a2a3a;
                border: 1px solid #00ff88;
                border-radius: 8px;
                padding: 10px;
                margin-bottom: 10px;
                font-size: 0.85rem;
            ">
                <span style="color: #00ff88;">✓ Loaded:</span>
                <span style="color: #aaa;">{st.session_state.loaded_file}</span>
            </div>
            """, unsafe_allow_html=True)

        output_dir = Path("./outputs")
        if output_dir.exists():
            json_files = list(output_dir.glob("pipeline_state_*.json"))
            if json_files:
                selected_file = st.selectbox(
                    "Load results:",
                    options=[""] + [f.name for f in sorted(json_files, reverse=True)[:10]],
                    format_func=lambda x: "Select a file..." if x == "" else x
                )
                if selected_file:
                    col1, col2 = st.columns(2)
                    with col1:
                        if st.button("📥 Load", use_container_width=True):
                            try:
                                with open(output_dir / selected_file, 'r', encoding='utf-8') as f:
                                    st.session_state.state = json.load(f)
                                st.session_state.loaded_file = selected_file
                                st.success("Loaded!")
                                st.rerun()
                            except Exception as e:
                                st.error(f"Error loading: {e}")
                    with col2:
                        if st.button("🗑️ Clear", use_container_width=True):
                            st.session_state.state = None
                            if hasattr(st.session_state, 'loaded_file'):
                                del st.session_state.loaded_file
                            st.rerun()
            else:
                st.info("No previous results found")

        st.markdown("---")
        st.markdown("""
        <div style="text-align: center; color: #666; font-size: 0.8rem;">
            PaperTrack Agent v1.0<br>
            Powered by AI 🤖
        </div>
        """, unsafe_allow_html=True)

    # Main content
    if st.session_state.running:
        st.session_state.state = run_pipeline_with_ui(
            [research_field],
            time_range,
            max_papers,
            custom_days if time_range == "custom" else None
        )
        st.session_state.running = False
        st.rerun()

    # Display results
    if st.session_state.state:
        state = st.session_state.state

        # Phase progress
        st.markdown("---")
        current_phase = 5 if state.get("research_gaps") else (
            4 if state.get("trend_analysis") else (
                3 if state.get("comparative_analysis") else (
                    2 if state.get("paper_analyses") else (
                        1 if state.get("retrieved_papers") else 0
                    )
                )
            )
        )
        create_phase_progress(current_phase)

        # Metrics
        st.markdown("---")
        create_metrics_dashboard(state)

        # Agent status
        st.markdown("---")
        create_agent_status_panel(st.session_state.agent_states)

        # Tabs for different views
        st.markdown("---")
        tab1, tab2, tab3, tab4 = st.tabs([
            "📚 Papers",
            "📊 Analysis",
            "📈 Trends",
            "💡 Insights"
        ])

        with tab1:
            st.markdown("### 📚 Discovered Papers")

            # Summary stats
            total_tracked = sum(
                len(v.get("papers", []))
                for v in state.get("tracked_papers", {}).values()
                if isinstance(v, dict)
            )

            for field, result in state.get("tracked_papers", {}).items():
                if isinstance(result, dict):
                    papers = result.get("papers", [])

                    st.markdown(f"""
                    <div style="
                        display: flex;
                        justify-content: space-between;
                        align-items: center;
                        margin: 20px 0 10px 0;
                    ">
                        <h4 style="color: #00d4ff; margin: 0;">🔬 {field}</h4>
                        <span style="
                            background: #00d4ff22;
                            border: 1px solid #00d4ff;
                            padding: 5px 15px;
                            border-radius: 20px;
                            color: #00d4ff;
                        ">{len(papers)} papers</span>
                    </div>
                    """, unsafe_allow_html=True)

                    for i, paper in enumerate(papers[:15]):
                        create_paper_card(paper, i, state.get("paper_analyses"))

                    if len(papers) > 15:
                        st.info(f"Showing 15 of {len(papers)} papers. Full results saved to output file.")

        with tab2:
            st.markdown("### 📊 Comparative Analysis")

            col1, col2 = st.columns([1, 1])

            with col1:
                # Get papers for radar chart
                all_papers = []
                for analyses in state.get("paper_analyses", {}).values():
                    if isinstance(analyses, list):
                        all_papers.extend(analyses)
                create_radar_chart(all_papers)

            with col2:
                # Quick stats
                comp = state.get("comparative_analysis", {})
                if comp:
                    method_comp = comp.get("method_comparison", {})
                    themes = comp.get("research_themes", {})

                    st.markdown("""
                    <div class="stats-grid">
                        <div class="stat-item">
                            <div class="stat-value">{}</div>
                            <div class="stat-label">Common Approaches</div>
                        </div>
                        <div class="stat-item">
                            <div class="stat-value">{}</div>
                            <div class="stat-label">Unique Methods</div>
                        </div>
                        <div class="stat-item">
                            <div class="stat-value">{}</div>
                            <div class="stat-label">Research Themes</div>
                        </div>
                    </div>
                    """.format(
                        len(method_comp.get("common_approaches", [])),
                        len(method_comp.get("unique_methods", [])),
                        len(themes.get("main_themes", []))
                    ), unsafe_allow_html=True)

            st.markdown("---")
            create_analysis_view(state)

        with tab3:
            st.markdown("### 📈 Research Trends")
            create_trend_chart(state.get("trend_analysis", {}))

        with tab4:
            st.markdown("### 💡 Research Insights & Opportunities")
            create_insights_view(state)

    else:
        # Welcome screen
        st.markdown("""
        <div class="cyber-card" style="text-align: center; padding: 40px;">
            <h2 style="color: #00d4ff;">Welcome to PaperTrack Agent</h2>
            <p style="color: #888; font-size: 1.1rem;">
                Your AI-powered research paper analysis system.<br>
                Configure your search parameters in the sidebar and click <strong>Start Analysis</strong> to begin.
            </p>
            <div style="margin-top: 30px;">
                <span style="color: #00d4ff; font-size: 3rem;">🔬</span>
                <span style="color: #7b2cbf; font-size: 3rem;">📊</span>
                <span style="color: #ff006e; font-size: 3rem;">💡</span>
            </div>
        </div>
        """, unsafe_allow_html=True)

        # Feature cards
        col1, col2, col3 = st.columns(3)

        with col1:
            st.markdown("""
            <div class="cyber-card">
                <h3 style="color: #00d4ff;">🎯 Smart Discovery</h3>
                <p style="color: #aaa;">Automatically track and discover relevant papers from arXiv using AI-powered search.</p>
                <ul style="color: #666; font-size: 0.9rem;">
                    <li>Custom time range selection</li>
                    <li>Field-specific search</li>
                    <li>Automatic PDF download</li>
                </ul>
            </div>
            """, unsafe_allow_html=True)

        with col2:
            st.markdown("""
            <div class="cyber-card">
                <h3 style="color: #7b2cbf;">📖 Deep Analysis</h3>
                <p style="color: #aaa;">Extract key insights, methodologies, and results from papers using advanced NLP.</p>
                <ul style="color: #666; font-size: 0.9rem;">
                    <li>Method comparison</li>
                    <li>Result benchmarking</li>
                    <li>Code extraction</li>
                </ul>
            </div>
            """, unsafe_allow_html=True)

        with col3:
            st.markdown("""
            <div class="cyber-card">
                <h3 style="color: #ff006e;">💡 Research Gaps</h3>
                <p style="color: #aaa;">Identify research opportunities and generate novel research ideas.</p>
                <ul style="color: #666; font-size: 0.9rem;">
                    <li>Gap identification</li>
                    <li>Idea generation</li>
                    <li>Trend analysis</li>
                </ul>
            </div>
            """, unsafe_allow_html=True)


if __name__ == "__main__":
    main()