app.py

"""
AUTOMATION 2 (UPGRADED) — Hugging Face Spaces App
==================================================
Improvements over v1:
  ✓ LLM (GPT-4o-mini) called DIRECTLY from inside the app
  ✓ Richer interactive visualisations (radar chart, trend bars, gauge)
  ✓ Side-by-side metric comparison panel
  ✓ Session history tracker
  ✓ Automated pipeline trigger button (runs agentic_pipeline.py)
  ✓ Confidence intervals on predictions
  ✓ Better UX: loading states, cleaner layout, collapsible AI section

Deploy on Hugging Face Spaces (SDK: Gradio).
Set HF Secret: OPENAI_API_KEY
"""

import os
import json
import time
import subprocess
import gradio as gr
import pandas as pd
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import warnings
warnings.filterwarnings("ignore")

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

try:
    import requests
    REQUESTS_OK = True
except ImportError:
    REQUESTS_OK = False

# ── CONFIG ──────────────────────────────────────────────────
OPENAI_KEY = os.environ.get("OPENAI_API_KEY", "")   # Set as HF Secret
GPT_MODEL  = "gpt-4o-mini"

PALETTE = {
    "blue":   "#2E86AB",
    "pink":   "#A23B72",
    "amber":  "#F18F01",
    "red":    "#C73E1D",
    "teal":   "#44BBA4",
    "light":  "#F5F5F5",
    "dark":   "#1A1A2E",
}

# ── STARTUP: TRAIN MODELS ───────────────────────────────────
print("Loading data and training models on startup...")

def _load_and_train_amazon():
    df = pd.read_csv("amazon_synthetic.csv")
    df["log_sales"] = np.log1p(df["rating_count"])
    features = ["actual_price", "discounted_price", "discount_pct", "rating", "sentiment_score"]
    X = df[features].dropna()
    y = df.loc[X.index, "log_sales"]
    rf = RandomForestRegressor(n_estimators=150, random_state=42)
    rf.fit(X, y)
    # Compute prediction std via individual trees for confidence interval
    return rf, features, df

def _load_and_train_spotify():
    df = pd.read_csv("spotify_synthetic.csv")
    df["explicit"] = df["explicit"].astype(int)
    features = ["danceability", "energy", "loudness", "speechiness",
                "acousticness", "instrumentalness", "valence", "tempo", "explicit"]
    X = df[features].dropna()
    y = df.loc[X.index, "popularity"]
    rf = RandomForestRegressor(n_estimators=150, random_state=42)
    rf.fit(X, y)
    return rf, features, df

try:
    rf_amz, features_amz, df_amz = _load_and_train_amazon()
    AMZ_OK = True
    print("✓ Amazon model ready")
except Exception as e:
    AMZ_OK = False
    print(f"✗ Amazon model failed: {e}")

try:
    rf_spot, features_spot, df_spot = _load_and_train_spotify()
    SPOT_OK = True
    print("✓ Spotify model ready")
except Exception as e:
    SPOT_OK = False
    print(f"✗ Spotify model failed: {e}")

analyzer = SentimentIntensityAnalyzer()

# Session history
session_history = []


# ════════════════════════════════════════════════════════════
# GPT HELPER — called directly from the app
# ════════════════════════════════════════════════════════════

def call_gpt_in_app(system_prompt: str, user_prompt: str, max_tokens=500) -> str:
    """
    Call GPT-4o-mini directly from within the Gradio app.
    Falls back to a template report if API key is not set.
    """
    if not OPENAI_KEY or not REQUESTS_OK:
        return None   # will use fallback below

    headers = {
        "Authorization": f"Bearer {OPENAI_KEY}",
        "Content-Type": "application/json",
    }
    payload = {
        "model": GPT_MODEL,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user",   "content": user_prompt},
        ],
        "temperature": 0.4,
        "max_tokens": max_tokens,
    }
    try:
        r = requests.post(
            "https://api.openai.com/v1/chat/completions",
            headers=headers, json=payload, timeout=25
        )
        r.raise_for_status()
        return r.json()["choices"][0]["message"]["content"]
    except Exception as e:
        return f"[GPT unavailable: {e}]"


def get_amazon_gpt_insight(category, actual_price, discounted_price, discount_pct,
                           rating, sentiment_score, sentiment_label, sales_pred, score):
    system = (
        "You are a senior e-commerce performance analyst. Given Amazon product metrics, "
        "write a concise 4-section report: (1) Performance verdict in 1 sentence, "
        "(2) Pricing strategy assessment referencing the exact discount%, "
        "(3) Sentiment interpretation referencing the exact score, "
        "(4) Two specific, actionable recommendations. "
        "Be data-driven. Reference every number provided. Keep total response under 200 words."
    )
    user = (
        f"Category: {category} | Actual price: ₹{actual_price:.0f} | "
        f"Discounted price: ₹{discounted_price:.0f} | Discount: {discount_pct}% | "
        f"Rating: {rating}/5 | Sentiment score: {sentiment_score:.3f} ({sentiment_label}) | "
        f"Predicted rating count: ~{sales_pred:,} | Performance score: {score}/100"
    )
    result = call_gpt_in_app(system, user)
    if result and not result.startswith("[GPT"):
        return "🤖 AI Analysis (GPT-4o-mini)\n" + "─" * 36 + "\n" + result
    # Fallback
    return (
        "🤖 AI Analysis (template fallback — set OPENAI_API_KEY for live GPT)\n"
        + "─" * 36 + "\n"
        f"1. Performance: This {category} product scores {score}/100 — "
        f"{'strong' if score >= 75 else 'average' if score >= 45 else 'underperforming'}.\n"
        f"2. Pricing: A {discount_pct}% discount brings the price from ₹{actual_price:.0f} to "
        f"₹{discounted_price:.0f}. {'This aggressive discount may signal lower quality.' if discount_pct > 50 else 'Moderate discount maintains perceived value.'}\n"
        f"3. Sentiment: Score of {sentiment_score:.3f} is {sentiment_label}. "
        f"{'Strong reviews support organic growth.' if sentiment_label == 'Positive' else 'Negative sentiment risks algorithmic deprioritisation.'}\n"
        f"4. Recommendations:\n"
        f"   • {'Leverage positive reviews in sponsored ads' if sentiment_label == 'Positive' else 'Address negative feedback within 48h'}\n"
        f"   • {'Reduce discount to 20–30% to protect margin' if discount_pct > 50 else 'Maintain current pricing strategy'}"
    )


def get_spotify_gpt_insight(genre, danceability, energy, loudness, tempo,
                             valence, acousticness, pop_pred, tier):
    system = (
        "You are a music industry data analyst. Given Spotify audio features, "
        "write a concise 4-section report: (1) Commercial potential verdict in 1 sentence, "
        "(2) Audio profile assessment — is it radio-friendly? Reference exact feature values, "
        "(3) Genre fit analysis, "
        "(4) Two specific promotional or production recommendations. "
        "Be data-driven. Reference every number. Under 200 words total."
    )
    user = (
        f"Genre: {genre} | Popularity prediction: {pop_pred:.1f}/100 ({tier}) | "
        f"Danceability: {danceability:.2f} | Energy: {energy:.2f} | Loudness: {loudness:.1f} dB | "
        f"Tempo: {tempo:.0f} BPM | Valence: {valence:.2f} | Acousticness: {acousticness:.2f}"
    )
    result = call_gpt_in_app(system, user)
    if result and not result.startswith("[GPT"):
        return "🤖 AI Analysis (GPT-4o-mini)\n" + "─" * 36 + "\n" + result
    return (
        "🤖 AI Analysis (template fallback — set OPENAI_API_KEY for live GPT)\n"
        + "─" * 36 + "\n"
        f"1. Commercial potential: This {genre} track scores {pop_pred:.1f}/100 — {tier}.\n"
        f"2. Audio profile: Danceability {danceability:.2f} + energy {energy:.2f} at {loudness:.1f} dB. "
        f"{'Radio-friendly profile.' if danceability > 0.6 and energy > 0.6 else 'Niche profile — limited mainstream appeal.'}\n"
        f"3. Genre fit: {'Aligns with' if pop_pred >= 50 else 'Partially aligns with'} {genre} conventions.\n"
        f"4. Recommendations:\n"
        f"   • {'Pitch to editorial playlists — strong commercial profile' if pop_pred >= 60 else 'Consider a remix to boost danceability'}\n"
        f"   • {'Capitalize on high energy for live and sync licensing' if energy >= 0.7 else 'Explore streaming-first promotional strategy'}"
    )


# ════════════════════════════════════════════════════════════
# VISUALISATION HELPERS
# ════════════════════════════════════════════════════════════

def _radar_chart(labels, values, title, color):
    """Create a radar (spider) chart for audio features."""
    n = len(labels)
    angles = np.linspace(0, 2 * np.pi, n, endpoint=False).tolist()
    values_loop = values + [values[0]]
    angles += angles[:1]

    fig, ax = plt.subplots(figsize=(4.5, 4.5), subplot_kw={"polar": True})
    fig.patch.set_facecolor("#FAFAFA")
    ax.set_facecolor("#F0F4F8")
    ax.plot(angles, values_loop, color=color, linewidth=2)
    ax.fill(angles, values_loop, color=color, alpha=0.25)
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(labels, fontsize=9)
    ax.set_ylim(0, 1)
    ax.set_yticks([0.25, 0.5, 0.75])
    ax.set_yticklabels(["0.25", "0.50", "0.75"], fontsize=7, color="gray")
    ax.set_title(title, fontsize=11, fontweight="bold", pad=15)
    ax.grid(color="white", linewidth=0.8)
    plt.tight_layout()
    return fig


def make_amazon_chart(rating, sentiment_score, discount_pct, score, sales_pred):
    import tempfile
    fig, axes = plt.subplots(1, 3, figsize=(14, 4.5))
    fig.patch.set_facecolor("#FAFAFA")
    fig.suptitle("Amazon Product — Performance Dashboard", fontsize=13, fontweight="bold", y=1.01)

    # Panel 1: Feature bars
    ax = axes[0]
    ax.set_facecolor("#F8F9FA")
    metrics  = ["Rating (/5)", "Sentiment", "Discount (%/100)", "Score (/100)"]
    values   = [rating / 5, (sentiment_score + 1) / 2, discount_pct / 100, score / 100]
    bar_cols = [PALETTE["blue"], PALETTE["teal"], PALETTE["amber"], PALETTE["pink"]]
    bars = ax.bar(metrics, values, color=bar_cols, edgecolor="white", width=0.6)
    ax.set_ylim(0, 1.15)
    ax.set_title("Key Metrics (normalised)", fontweight="bold")
    for bar, val in zip(bars, values):
        ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.025,
                f"{val:.2f}", ha="center", fontsize=10, fontweight="bold")
    ax.set_xticklabels(metrics, fontsize=9)

    # Panel 2: Gauge
    ax2 = axes[1]
    ax2.set_facecolor("#F8F9FA")
    tier_color = (PALETTE["teal"] if score >= 75 else
                  PALETTE["amber"] if score >= 45 else PALETTE["red"])
    tier = "Top Performer" if score >= 75 else "Average" if score >= 45 else "Underperformer"
    wedge_colors = [tier_color, "#E8E8E8"]
    ax2.pie([score, 100 - score], colors=wedge_colors, startangle=90,
            wedgeprops={"edgecolor": "white", "linewidth": 2})
    ax2.text(0, 0, f"{score}", ha="center", va="center",
             fontsize=28, fontweight="bold", color=tier_color)
    ax2.set_title(f"Score: {tier}", fontweight="bold")

    # Panel 3: Est. rating count vs category benchmarks (synthetic)
    ax3 = axes[2]
    ax3.set_facecolor("#F8F9FA")
    benchmarks = {
        "This product":     sales_pred,
        "Category avg":    int(df_amz["rating_count"].mean()) if AMZ_OK else 15000,
        "Top 10%":         int(df_amz["rating_count"].quantile(0.9)) if AMZ_OK else 50000,
    }
    bc = [PALETTE["pink"], PALETTE["blue"], PALETTE["blue"]]
    ax3.barh(list(benchmarks.keys()), list(benchmarks.values()),
             color=bc, edgecolor="white")
    ax3.set_title("Est. Sales vs Benchmarks", fontweight="bold")
    ax3.set_xlabel("Predicted Rating Count")

    plt.tight_layout()
    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
    plt.savefig(tmp.name, dpi=130, bbox_inches="tight", facecolor="#FAFAFA")
    plt.close()
    return tmp.name


def make_spotify_chart(danceability, energy, loudness, tempo, valence,
                       acousticness, speechiness, pop_pred, genre):
    import tempfile
    fig = plt.figure(figsize=(14, 4.5))
    fig.patch.set_facecolor("#FAFAFA")
    fig.suptitle("Spotify Track — Audio Profile Dashboard", fontsize=13, fontweight="bold")

    # Panel 1: Radar
    ax1 = fig.add_subplot(1, 3, 1, polar=True)
    labels = ["Dance", "Energy", "Valence", "Acoust.", "Speech"]
    vals   = [danceability, energy, valence, acousticness, speechiness]
    n = len(labels)
    angles = np.linspace(0, 2 * np.pi, n, endpoint=False).tolist()
    vals_loop   = vals + [vals[0]]
    angles_loop = angles + angles[:1]
    ax1.plot(angles_loop, vals_loop, color=PALETTE["blue"], linewidth=2)
    ax1.fill(angles_loop, vals_loop, color=PALETTE["blue"], alpha=0.25)
    ax1.set_xticks(angles)
    ax1.set_xticklabels(labels, fontsize=9)
    ax1.set_ylim(0, 1)
    ax1.set_yticks([0.25, 0.5, 0.75])
    ax1.set_yticklabels(["", "", ""], fontsize=7)
    ax1.set_title("Audio Radar", fontweight="bold", pad=14)
    ax1.set_facecolor("#F0F4F8")
    ax1.grid(color="white")

    # Panel 2: Gauge
    ax2 = fig.add_subplot(1, 3, 2)
    ax2.set_facecolor("#F8F9FA")
    tier = ("Hit 🔥" if pop_pred >= 70 else "Popular" if pop_pred >= 50
            else "Mid-tier" if pop_pred >= 30 else "Niche")
    tier_color = (PALETTE["red"] if pop_pred >= 70 else
                  PALETTE["teal"] if pop_pred >= 50 else
                  PALETTE["amber"] if pop_pred >= 30 else "#888")
    ax2.pie([pop_pred, 100 - pop_pred], colors=[tier_color, "#E8E8E8"],
            startangle=90, wedgeprops={"edgecolor": "white", "linewidth": 2})
    ax2.text(0, 0, f"{pop_pred:.0f}", ha="center", va="center",
             fontsize=28, fontweight="bold", color=tier_color)
    ax2.set_title(f"Popularity: {tier}", fontweight="bold")

    # Panel 3: Feature importance comparison (from model)
    ax3 = fig.add_subplot(1, 3, 3)
    ax3.set_facecolor("#F8F9FA")
    if SPOT_OK:
        imp = pd.Series(rf_spot.feature_importances_, index=features_spot).sort_values()
        ax3.barh(imp.index, imp.values, color=PALETTE["blue"], edgecolor="white")
        ax3.set_title("Feature Importance\n(model weights)", fontweight="bold")
        ax3.set_xlabel("Importance")
    else:
        ax3.text(0.5, 0.5, "Model not loaded", ha="center")

    plt.tight_layout()
    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
    plt.savefig(tmp.name, dpi=130, bbox_inches="tight", facecolor="#FAFAFA")
    plt.close()
    return tmp.name


# ════════════════════════════════════════════════════════════
# AMAZON ANALYSIS FUNCTION
# ════════════════════════════════════════════════════════════

def analyze_amazon(category, actual_price, discount_pct, rating, review_text, use_gpt):
    discounted_price = actual_price * (1 - discount_pct / 100)
    sentiment_score  = analyzer.polarity_scores(review_text)["compound"] if review_text else 0.0
    sentiment_label  = ("Positive" if sentiment_score >= 0.05
                        else "Negative" if sentiment_score <= -0.05 else "Neutral")

    if AMZ_OK:
        X = np.array([[actual_price, discounted_price, discount_pct, rating, sentiment_score]])
        # Confidence interval via individual tree predictions
        tree_preds = np.array([t.predict(X)[0] for t in rf_amz.estimators_])
        log_pred   = tree_preds.mean()
        log_std    = tree_preds.std()
        sales_pred = int(np.expm1(log_pred))
        sales_low  = int(np.expm1(max(0, log_pred - log_std)))
        sales_high = int(np.expm1(log_pred + log_std))
    else:
        sales_pred = int(rating * 1000 * (1 + sentiment_score))
        sales_low  = int(sales_pred * 0.7)
        sales_high = int(sales_pred * 1.3)

    score = min(100, int(
        25 * (rating / 5) +
        25 * ((sentiment_score + 1) / 2) +
        25 * min(sales_pred / 50000, 1) +
        25 * min(discount_pct / 70, 1)
    ))
    tier = ("Top Performer" if score >= 75 else "Average" if score >= 45 else "Underperformer")

    # Chart
    chart_path = make_amazon_chart(rating, sentiment_score, discount_pct, score, sales_pred)

    # Text report
    report = (
        f"📦  AMAZON PRODUCT ANALYSIS\n{'═'*42}\n"
        f"Category:          {category}\n"
        f"Actual Price:      ₹{actual_price:.0f}\n"
        f"Discounted Price:  ₹{discounted_price:.0f}  (−{discount_pct}%)\n"
        f"Rating:            {rating}/5\n"
        f"{'─'*42}\n"
        f"SENTIMENT\n"
        f"  Score:  {sentiment_score:+.3f}   Label: {sentiment_label}\n"
        f"{'─'*42}\n"
        f"PREDICTED SALES\n"
        f"  Est. Reviews: ~{sales_pred:,}\n"
        f"  90% Range:    {sales_low:,} – {sales_high:,}\n"
        f"{'─'*42}\n"
        f"PERFORMANCE SCORE:  {score}/100  ({tier})\n"
    )

    # GPT or fallback
    gpt_section = ""
    if use_gpt:
        gpt_section = "\n" + get_amazon_gpt_insight(
            category, actual_price, discounted_price, discount_pct,
            rating, sentiment_score, sentiment_label, sales_pred, score
        )

    session_history.append({
        "platform": "Amazon", "category": category,
        "score": score, "tier": tier,
        "timestamp": time.strftime("%H:%M:%S"),
    })

    return report.strip() + gpt_section, chart_path


# ════════════════════════════════════════════════════════════
# SPOTIFY ANALYSIS FUNCTION
# ════════════════════════════════════════════════════════════

def analyze_spotify(genre, danceability, energy, loudness, tempo, valence,
                    acousticness, speechiness, instrumentalness, explicit, use_gpt):
    exp = int(explicit)

    if SPOT_OK:
        X = np.array([[danceability, energy, loudness, speechiness, acousticness,
                       instrumentalness, valence, tempo, exp]])
        tree_preds = np.array([t.predict(X)[0] for t in rf_spot.estimators_])
        pop_pred   = float(np.clip(tree_preds.mean(), 0, 100))
        pop_std    = tree_preds.std()
    else:
        pop_pred = float(np.clip(20 + 30*danceability + 15*energy + 0.5*(loudness+20), 0, 100))
        pop_std  = 5.0

    tier = ("Hit 🔥" if pop_pred >= 70 else "Popular" if pop_pred >= 50
            else "Mid-tier" if pop_pred >= 30 else "Niche")
    pop_low  = max(0,   pop_pred - pop_std)
    pop_high = min(100, pop_pred + pop_std)

    chart_path = make_spotify_chart(
        danceability, energy, loudness, tempo, valence,
        acousticness, speechiness, pop_pred, genre
    )

    report = (
        f"🎵  SPOTIFY TRACK ANALYSIS\n{'═'*42}\n"
        f"Genre:          {genre}\n"
        f"Tempo:          {tempo:.0f} BPM\n"
        f"Explicit:       {'Yes' if explicit else 'No'}\n"
        f"{'─'*42}\n"
        f"AUDIO FEATURES\n"
        f"  Danceability:   {danceability:.3f}\n"
        f"  Energy:         {energy:.3f}\n"
        f"  Loudness:       {loudness:.1f} dB\n"
        f"  Valence:        {valence:.3f}\n"
        f"  Acousticness:   {acousticness:.3f}\n"
        f"  Speechiness:    {speechiness:.3f}\n"
        f"{'─'*42}\n"
        f"PREDICTED POPULARITY\n"
        f"  Score:  {pop_pred:.1f}/100  ({tier})\n"
        f"  Range:  {pop_low:.1f} – {pop_high:.1f}  (±1 std dev)\n"
    )

    gpt_section = ""
    if use_gpt:
        gpt_section = "\n" + get_spotify_gpt_insight(
            genre, danceability, energy, loudness, tempo,
            valence, acousticness, pop_pred, tier
        )

    session_history.append({
        "platform": "Spotify", "genre": genre,
        "score": round(pop_pred, 1), "tier": tier,
        "timestamp": time.strftime("%H:%M:%S"),
    })

    return report.strip() + gpt_section, chart_path


# ════════════════════════════════════════════════════════════
# SESSION HISTORY & PIPELINE TRIGGER
# ════════════════════════════════════════════════════════════

def get_history():
    if not session_history:
        return "No analyses run yet this session."
    lines = [f"{'#':<4} {'Time':<10} {'Platform':<10} {'Detail':<25} {'Score':<8} {'Tier'}"]
    lines.append("─" * 70)
    for i, h in enumerate(session_history[-10:], 1):
        detail = h.get("category", h.get("genre", "—"))
        lines.append(f"{i:<4} {h['timestamp']:<10} {h['platform']:<10} {detail:<25} {h['score']:<8} {h['tier']}")
    return "\n".join(lines)


def run_pipeline():
    """Trigger the agentic pipeline from the UI."""
    if not os.path.exists("agentic_pipeline.py"):
        return "agentic_pipeline.py not found in current directory."
    try:
        result = subprocess.run(
            ["python3", "agentic_pipeline.py", "--mode", "both"],
            capture_output=True, text=True, timeout=120
        )
        out = result.stdout[-2000:] if len(result.stdout) > 2000 else result.stdout
        if result.returncode == 0:
            return f"✓ Pipeline completed successfully.\n\n{out}"
        else:
            return f"✗ Pipeline error:\n{result.stderr[:1000]}"
    except subprocess.TimeoutExpired:
        return "✗ Pipeline timed out after 120s."
    except Exception as e:
        return f"✗ Could not run pipeline: {e}"


# ════════════════════════════════════════════════════════════
# GRADIO INTERFACE
# ════════════════════════════════════════════════════════════

CUSTOM_CSS = """
.gr-button-primary { background: #2E86AB !important; border: none !important; }
.gr-button-secondary { border: 1px solid #2E86AB !important; color: #2E86AB !important; }
footer { display: none !important; }
"""

with gr.Blocks(
    title="AI Performance Analyzer — Amazon × Spotify",
    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="pink"),
    css=CUSTOM_CSS,
) as demo:

    gr.Markdown("""
    # 🤖 AI Performance Analyzer
    ### Amazon Products × Spotify Tracks
    *Real-time ML predictions + GPT-4o-mini insights from a single interface*
    """)

    with gr.Tabs():

        # ── TAB 1: AMAZON ────────────────────────────────────
        with gr.TabItem("🛒 Amazon Product"):
            gr.Markdown("### Predict product sales performance and get AI-powered strategy insights")
            with gr.Row():
                with gr.Column(scale=1):
                    amz_category = gr.Dropdown(
                        ["Electronics", "Clothing", "HomeKitchen", "Books",
                         "Sports", "Beauty", "Toys", "OfficeProducts", "MusicalInstruments"],
                        label="Product Category", value="Electronics")
                    amz_actual   = gr.Slider(50, 80000, value=999, step=50,
                                             label="Actual Price (₹)")
                    amz_discount = gr.Slider(0, 80, value=30, step=1,
                                             label="Discount %")
                    amz_rating   = gr.Slider(1.0, 5.0, value=4.2, step=0.1,
                                             label="Star Rating (/5)")
                    amz_review   = gr.Textbox(
                        label="Sample Review Text",
                        value="Great product, works perfectly and arrived on time!",
                        lines=3, placeholder="Enter a customer review for sentiment analysis...")
                    amz_gpt = gr.Checkbox(label="🤖 Generate GPT-4o-mini AI insight", value=True)
                    amz_btn = gr.Button("Analyze Product", variant="primary", size="lg")

                with gr.Column(scale=2):
                    amz_output = gr.Textbox(label="Analysis Report", lines=22)
                    amz_plot   = gr.Image(label="Performance Dashboard", type="filepath")

            amz_btn.click(
                analyze_amazon,
                inputs=[amz_category, amz_actual, amz_discount, amz_rating, amz_review, amz_gpt],
                outputs=[amz_output, amz_plot],
            )

        # ── TAB 2: SPOTIFY ───────────────────────────────────
        with gr.TabItem("🎵 Spotify Track"):
            gr.Markdown("### Predict commercial success and get AI-powered music industry insights")
            with gr.Row():
                with gr.Column(scale=1):
                    sp_genre  = gr.Dropdown(
                        ["pop", "hip-hop", "rock", "electronic", "jazz",
                         "r-n-b", "country", "latin", "indie", "classical"],
                        label="Genre", value="pop")
                    sp_dance  = gr.Slider(0.0, 1.0, value=0.70, step=0.01, label="Danceability")
                    sp_energy = gr.Slider(0.0, 1.0, value=0.80, step=0.01, label="Energy")
                    sp_loud   = gr.Slider(-40, 0, value=-7, step=0.5, label="Loudness (dB)")
                    sp_tempo  = gr.Slider(60, 200, value=120, step=1, label="Tempo (BPM)")
                    sp_val    = gr.Slider(0.0, 1.0, value=0.60, step=0.01, label="Valence (mood positivity)")
                    sp_acou   = gr.Slider(0.0, 1.0, value=0.10, step=0.01, label="Acousticness")
                    sp_speech = gr.Slider(0.0, 1.0, value=0.05, step=0.01, label="Speechiness")
                    sp_instr  = gr.Slider(0.0, 1.0, value=0.00, step=0.01, label="Instrumentalness")
                    sp_exp    = gr.Checkbox(label="Explicit content", value=False)
                    sp_gpt    = gr.Checkbox(label="🤖 Generate GPT-4o-mini AI insight", value=True)
                    sp_btn    = gr.Button("Analyze Track", variant="primary", size="lg")

                with gr.Column(scale=2):
                    sp_output = gr.Textbox(label="Analysis Report", lines=22)
                    sp_plot   = gr.Image(label="Audio Profile Dashboard", type="filepath")

            sp_btn.click(
                analyze_spotify,
                inputs=[sp_genre, sp_dance, sp_energy, sp_loud, sp_tempo,
                        sp_val, sp_acou, sp_speech, sp_instr, sp_exp, sp_gpt],
                outputs=[sp_output, sp_plot],
            )

        # ── TAB 3: SESSION HISTORY ───────────────────────────
        with gr.TabItem("📋 Session History"):
            gr.Markdown("### All analyses run this session")
            hist_output = gr.Textbox(label="Session Log", lines=15)
            hist_btn = gr.Button("Refresh History", variant="secondary")
            hist_btn.click(get_history, inputs=[], outputs=[hist_output])

        # ── TAB 4: PIPELINE ──────────────────────────────────
        with gr.TabItem("⚙️ Agentic Pipeline"):
            gr.Markdown("""
            ### Automated End-to-End Pipeline
            Runs the full agentic pipeline: data ingestion → synthetic generation →
            model training → inference → report generation. Single-command execution.
            """)
            pipe_btn    = gr.Button("▶ Run Agentic Pipeline", variant="primary", size="lg")
            pipe_output = gr.Textbox(label="Pipeline Output", lines=20)
            pipe_btn.click(run_pipeline, inputs=[], outputs=[pipe_output])

    gr.Markdown("""
    ---
    *Built with Gradio · Models: Random Forest (sklearn) · NLP: VADER · AI: GPT-4o-mini*
    *Set `OPENAI_API_KEY` as a Hugging Face Secret to enable live GPT insights*
    """)

if __name__ == "__main__":
    demo.launch(share=True)