"""
NationStates High-Value Trading Card Tracker — Gradio Web App
==============================================================
Deployed to Hugging Face Spaces. Uses core.py for all shared logic.

COMPLIANCE: This tool is purely read-only. No automated trades.
"""

import gradio as gr
import sqlite3
import time
import os
import pandas as pd
from datetime import datetime

from core import (
    init_db, fetch_card_info, fetch_card_market, fetch_full_market,
    fetch_card_trades, check_nation_exists, scan_low_id_cards,
    scan_cte_cards, scan_historical_cards, check_target_prices,
    record_price_snapshot, calculate_trade_score, suggest_bid_price,
    SEASON, RATE_LIMIT_SECONDS, THRESHOLDS, HISTORICAL_NAMES, USER_AGENT
)

# ==========================================
# CONFIGURATION
# ==========================================
DB_PATH = "/tmp/cards_tracker.db"


# ==========================================
# SMART TRADING UI HANDLERS
# ==========================================

def run_smart_analysis(max_cards):
    """Analyze all targets and score them for trading opportunity."""
    init_db(DB_PATH)
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""
        SELECT card_id, season, name, rarity, flag_reason, lowest_ask
        FROM targets
        ORDER BY CASE rarity WHEN 'legendary' THEN 1 WHEN 'epic' THEN 2 ELSE 3 END
        LIMIT ?
    """, (int(max_cards),))
    targets = c.fetchall()
    conn.close()

    if not targets:
        return "No targets found. Run a scan first.", pd.DataFrame()

    results = []
    errors = 0
    for card_id, season, name, rarity, flag_reason, lowest_ask in targets:
        snapshot = record_price_snapshot(DB_PATH, card_id, season)
        if snapshot.get("error"):
            errors += 1

        trades = fetch_card_trades(card_id, season)

        if trades:
            conn = sqlite3.connect(DB_PATH)
            c = conn.cursor()
            for t in trades:
                c.execute("""INSERT OR IGNORE INTO trade_history (card_id, season, timestamp, price, buyer, seller)
                             VALUES (?, ?, ?, ?, ?, ?)""",
                          (card_id, season, t["timestamp"], t["price"], t["buyer"], t["seller"]))
            conn.commit()
            conn.close()

        score = calculate_trade_score(DB_PATH, card_id, season)
        bid_suggestions = suggest_bid_price(DB_PATH, card_id, season)

        suggested_bid = ""
        if bid_suggestions:
            if "aggressive_bid" in bid_suggestions:
                suggested_bid = f"{bid_suggestions['aggressive_bid']:.2f}"
            elif "below_mv_20pct" in bid_suggestions:
                suggested_bid = f"{bid_suggestions['below_mv_20pct']:.2f}"

        results.append({
            "Card ID": card_id,
            "Name": name,
            "Rarity": rarity,
            "Reason": flag_reason or "",
            "Ask": f"{snapshot['lowest_ask']:.2f}" if snapshot["lowest_ask"] else "—",
            "Bid": f"{snapshot['highest_bid']:.2f}" if snapshot["highest_bid"] else "—",
            "Score": score or 0,
            "Suggested Bid": suggested_bid,
            "URL": f"https://www.nationstates.net/page=deck/card={card_id}/season={season}",
        })

    results.sort(key=lambda x: x["Score"], reverse=True)
    df = pd.DataFrame(results)

    top_buys = [r for r in results if r["Score"] >= 70]
    summary = f"**Analyzed {len(results)} cards.**\n\n"
    if errors:
        summary += f"⚠️ {errors} API errors encountered during analysis.\n\n"
    if top_buys:
        summary += f"🎯 **{len(top_buys)} HIGH-OPPORTUNITY cards (score ≥ 70):**\n\n"
        for r in top_buys[:10]:
            summary += f"- **{r['Name']}** (ID:{r['Card ID']}) — {r['Rarity']} | Score: **{r['Score']}** | Ask: {r['Ask']} | Suggest bid: {r['Suggested Bid']}\n"
    else:
        summary += "No high-opportunity cards found at this time. Keep monitoring."

    return summary, df


def run_card_deep_dive(card_id):
    """Deep analysis of a single card."""
    init_db(DB_PATH)
    card_id = int(card_id)

    card_info = fetch_card_info(card_id, SEASON)
    if not card_info:
        return "❌ Card not found. The API may be unavailable or the card ID is invalid.", pd.DataFrame()

    market = fetch_full_market(card_id, SEASON)
    trades = fetch_card_trades(card_id, SEASON)

    # Store data
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("INSERT OR REPLACE INTO cards VALUES (?, ?, ?, ?, ?, ?, ?)",
              (card_info["card_id"], card_info["season"], card_info["name"],
               card_info["rarity"], card_info["region"], card_info["market_value"], card_info.get("flag", "")))

    c.execute("""INSERT INTO price_history (card_id, season, timestamp, lowest_ask, highest_bid, market_value, num_asks, num_bids)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
              (card_id, SEASON, datetime.now().isoformat(),
               market["asks"][0]["price"] if market["asks"] else None,
               market["bids"][0]["price"] if market["bids"] else None,
               card_info["market_value"], len(market["asks"]), len(market["bids"])))

    for t in trades:
        c.execute("""INSERT OR IGNORE INTO trade_history (card_id, season, timestamp, price, buyer, seller)
                     VALUES (?, ?, ?, ?, ?, ?)""",
                  (card_id, SEASON, t["timestamp"], t["price"], t["buyer"], t["seller"]))
    conn.commit()
    conn.close()

    score = calculate_trade_score(DB_PATH, card_id, SEASON)
    bid_suggestions = suggest_bid_price(DB_PATH, card_id, SEASON)

    # Build report
    report = f"## 📊 Deep Dive: {card_info['name']} (ID: {card_id})\n\n"
    report += f"**Rarity:** {card_info['rarity'].upper()} | **Region:** {card_info['region']} | **Market Value:** {card_info['market_value']:.2f}\n\n"

    if market.get("error"):
        report += f"⚠️ *Market data may be incomplete: {market['error']}*\n\n"

    report += f"### Market State\n"
    if market["asks"]:
        report += f"- **Lowest Ask:** {market['asks'][0]['price']:.2f} ({len(market['asks'])} total asks)\n"
    else:
        report += f"- **No asks** (nobody selling)\n"
    if market["bids"]:
        report += f"- **Highest Bid:** {market['bids'][0]['price']:.2f} ({len(market['bids'])} total bids)\n"
    else:
        report += f"- **No bids** (nobody buying)\n"

    if market["asks"] and market["bids"]:
        spread = market["asks"][0]["price"] - market["bids"][0]["price"]
        spread_pct = (spread / market["asks"][0]["price"]) * 100
        report += f"- **Spread:** {spread:.2f} ({spread_pct:.0f}%)\n"

    report += f"\n### Trading Score: **{score}/100**\n"
    if score and score >= 70:
        report += "🎯 **HIGH OPPORTUNITY** — Strong buy signal\n"
    elif score and score >= 50:
        report += "⚡ **MODERATE** — Worth watching\n"
    else:
        report += "⏸️ **LOW** — Not ideal timing\n"

    report += f"\n### Suggested Bid Prices\n"
    if bid_suggestions:
        for label, price in bid_suggestions.items():
            nice_label = label.replace("_", " ").title()
            report += f"- **{nice_label}:** {price:.2f}\n"
    else:
        report += "- Not enough data for suggestions yet.\n"

    report += f"\n### Recent Trades ({len(trades)} found)\n"
    trade_data = []
    if trades:
        for t in trades[:10]:
            ts = t["timestamp"]
            try:
                ts_display = datetime.fromtimestamp(int(ts)).strftime("%Y-%m-%d %H:%M") if ts.isdigit() else ts[:16]
            except (ValueError, TypeError):
                ts_display = str(ts)[:16]
            trade_data.append({
                "Date": ts_display,
                "Price": f"{t['price']:.2f}",
                "Buyer": t["buyer"],
                "Seller": t["seller"],
            })

    report += f"\n[🔗 View on NS](https://www.nationstates.net/page=deck/card={card_id}/season={SEASON})\n"

    df = pd.DataFrame(trade_data) if trade_data else pd.DataFrame(columns=["Date", "Price", "Buyer", "Seller"])
    return report, df


def add_to_watchlist(card_id, max_bid, notes):
    """Add a card to the watchlist."""
    init_db(DB_PATH)
    card_id = int(card_id)
    max_bid = float(max_bid) if max_bid else 0

    card_info = fetch_card_info(card_id, SEASON)
    if not card_info:
        return "❌ Card not found. Check the ID or try again later.", get_watchlist()

    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""INSERT OR REPLACE INTO watchlist (card_id, season, name, rarity, max_bid, notes, added_at)
                 VALUES (?, ?, ?, ?, ?, ?, ?)""",
              (card_id, SEASON, card_info["name"], card_info["rarity"], max_bid, notes, datetime.now().isoformat()))
    conn.commit()
    conn.close()

    return f"✅ Added **{card_info['name']}** (ID:{card_id}) to watchlist. Max bid: {max_bid:.2f}", get_watchlist()


def remove_from_watchlist(card_id):
    """Remove a card from the watchlist."""
    init_db(DB_PATH)
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("DELETE FROM watchlist WHERE card_id = ? AND season = ?", (int(card_id), SEASON))
    conn.commit()
    conn.close()
    return f"✅ Removed card {card_id} from watchlist.", get_watchlist()


def get_watchlist():
    """Get current watchlist."""
    init_db(DB_PATH)
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""SELECT card_id, name, rarity, max_bid, notes, added_at FROM watchlist
                 ORDER BY CASE rarity WHEN 'legendary' THEN 1 WHEN 'epic' THEN 2 ELSE 3 END""")
    rows = c.fetchall()
    conn.close()

    if rows:
        return pd.DataFrame(rows, columns=["Card ID", "Name", "Rarity", "Max Bid", "Notes", "Added"])
    return pd.DataFrame(columns=["Card ID", "Name", "Rarity", "Max Bid", "Notes", "Added"])


def check_watchlist_alerts():
    """Check watchlist cards for buy opportunities."""
    init_db(DB_PATH)
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT card_id, season, name, rarity, max_bid FROM watchlist")
    items = c.fetchall()
    conn.close()

    if not items:
        return "Watchlist is empty. Add cards first.", pd.DataFrame()

    alerts = []
    errors = 0
    for card_id, season, name, rarity, max_bid in items:
        market = fetch_full_market(card_id, season)
        if market.get("error"):
            errors += 1

        lowest_ask = market["asks"][0]["price"] if market["asks"] else None

        if lowest_ask and max_bid and lowest_ask <= max_bid:
            alerts.append({
                "Card ID": card_id,
                "Name": name,
                "Rarity": rarity,
                "Lowest Ask": f"{lowest_ask:.2f}",
                "Your Max Bid": f"{max_bid:.2f}",
                "Status": "🚨 BUY NOW",
                "URL": f"https://www.nationstates.net/page=deck/card={card_id}/season={season}",
            })
        elif lowest_ask:
            alerts.append({
                "Card ID": card_id,
                "Name": name,
                "Rarity": rarity,
                "Lowest Ask": f"{lowest_ask:.2f}",
                "Your Max Bid": f"{max_bid:.2f}" if max_bid else "—",
                "Status": "⏳ Waiting",
                "URL": f"https://www.nationstates.net/page=deck/card={card_id}/season={season}",
            })
        else:
            alerts.append({
                "Card ID": card_id,
                "Name": name,
                "Rarity": rarity,
                "Lowest Ask": "No asks",
                "Your Max Bid": f"{max_bid:.2f}" if max_bid else "—",
                "Status": "📭 No sellers",
                "URL": f"https://www.nationstates.net/page=deck/card={card_id}/season={season}",
            })

    df = pd.DataFrame(alerts)
    buy_now = [a for a in alerts if "BUY NOW" in a["Status"]]

    summary = f"**Checked {len(items)} watchlist cards.**\n\n"
    if errors:
        summary += f"⚠️ {errors} API errors encountered.\n\n"
    if buy_now:
        summary += f"🚨 **{len(buy_now)} cards available at or below your max bid!**\n\n"
        for a in buy_now:
            summary += f"- **{a['Name']}** — Ask: {a['Lowest Ask']} ≤ Your max: {a['Your Max Bid']} → [🛒 BUY]({a['URL']})\n"
    else:
        summary += "No cards at your target price yet. Keep checking."

    return summary, df


# ==========================================
# SCAN UI HANDLERS
# ==========================================

def run_low_id_scan(max_id):
    """UI handler for Low ID scan."""
    init_db(DB_PATH)
    found = scan_low_id_cards(DB_PATH, int(max_id))

    if found:
        df = pd.DataFrame(found)
        df["URL"] = df["card_id"].apply(lambda x: f"https://www.nationstates.net/page=deck/card={x}/season={SEASON}")
        df = df[["card_id", "name", "rarity", "region", "market_value", "URL"]]
        df.columns = ["Card ID", "Name", "Rarity", "Region", "Market Value", "URL"]
        return f"✅ Found **{len(found)}** Legendary/Epic cards with ID ≤ {int(max_id)}", df
    return "No Legendary/Epic cards found in that range.", pd.DataFrame(columns=["Card ID", "Name", "Rarity", "Region", "Market Value", "URL"])


def run_cte_scan():
    """UI handler for CTE scan."""
    init_db(DB_PATH)
    cte = scan_cte_cards(DB_PATH)
    if cte:
        df = pd.DataFrame(cte)
        return f"✅ Found **{len(cte)}** CTE (dead nation) cards", df
    return "No CTE cards found (all nations still active or no cards in DB). Run a Low ID scan first.", pd.DataFrame(columns=["card_id", "name", "rarity"])


def run_historical_scan():
    """UI handler for Historical name scan."""
    init_db(DB_PATH)
    hist = scan_historical_cards(DB_PATH)
    if hist:
        df = pd.DataFrame(hist)
        return f"✅ Found **{len(hist)}** cards matching historical names", df
    return "No historical name matches found. Run a Low ID scan first to populate the card database.", pd.DataFrame(columns=["card_id", "name", "rarity", "match"])


def run_price_check(max_checks):
    """UI handler for price check."""
    init_db(DB_PATH)
    alerts, errors = check_target_prices(DB_PATH, int(max_checks))

    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""
        SELECT card_id, name, rarity, flag_reason, lowest_ask, last_checked, card_url
        FROM targets WHERE last_checked IS NOT NULL
        ORDER BY lowest_ask ASC
    """)
    rows = c.fetchall()
    conn.close()

    df = pd.DataFrame(rows, columns=["Card ID", "Name", "Rarity", "Flag Reason", "Ask Price", "Last Checked", "URL"])

    alert_text = f"**Checked prices for targets.**\n\n"
    if errors:
        alert_text += f"⚠️ {errors} API errors encountered (some cards may have incomplete data).\n\n"
    if alerts:
        alert_text += f"🚨 **{len(alerts)} UNDERVALUED CARDS!**\n\n"
        for a in alerts:
            alert_text += f"- **{a['name']}** (ID: {a['card_id']}) — {a['rarity'].upper()}\n"
            alert_text += f"  Reason: {a['reason']} | Ask: **{a['ask']:.2f}** (threshold: {a['threshold']})\n"
            alert_text += f"  [🛒 Buy Link]({a['url']})\n\n"
    else:
        alert_text += "✅ No undervalued cards below threshold."

    return alert_text, df


def get_all_targets():
    """Get all current targets from DB."""
    init_db(DB_PATH)
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""
        SELECT card_id, name, rarity, flag_reason, lowest_ask, last_checked, card_url
        FROM targets
        ORDER BY CASE rarity WHEN 'legendary' THEN 1 WHEN 'epic' THEN 2 ELSE 3 END, card_id
    """)
    rows = c.fetchall()
    conn.close()

    if rows:
        return pd.DataFrame(rows, columns=["Card ID", "Name", "Rarity", "Flag Reason", "Ask Price", "Last Checked", "URL"])
    return pd.DataFrame(columns=["Card ID", "Name", "Rarity", "Flag Reason", "Ask Price", "Last Checked", "URL"])


# ==========================================
# BUILD APP
# ==========================================

with gr.Blocks(title="NS High-Value Card Tracker", theme=gr.themes.Soft()) as app:
    gr.Markdown("# 🏆 NationStates High-Value Trading Card Tracker")
    gr.Markdown("Identifies elite-tier undervalued cards via the NationStates API. **No automated trades** — manual purchase only via links.")
    gr.Markdown(f"*Season {SEASON} | Rate limit: {RATE_LIMIT_SECONDS}s/request | Compliance: Read-only*")

    with gr.Tab("🔍 Low ID Scan"):
        gr.Markdown("Scan cards by ID range to find Legendary/Epic cards with low IDs (rare & valuable).")
        max_id_input = gr.Number(label="Scan cards 1 to:", value=10000, minimum=1, maximum=10000, precision=0)
        gr.Markdown("*⏱️ Estimated time: ~1.2 seconds per card ID*")
        scan_btn = gr.Button("🔍 Start Low ID Scan", variant="primary")
        scan_status = gr.Markdown("")
        scan_results = gr.Dataframe(label="Found Cards", interactive=False)
        scan_btn.click(fn=run_low_id_scan, inputs=[max_id_input], outputs=[scan_status, scan_results])

    with gr.Tab("💀 CTE Scan"):
        gr.Markdown("Check if flagged cards belong to dead/deleted nations (Ceased to Exist). These are scarcer and more valuable.")
        gr.Markdown("*Requires Low ID scan to be run first to populate the card database.*")
        cte_btn = gr.Button("💀 Check for CTE Cards", variant="primary")
        cte_status = gr.Markdown("")
        cte_results = gr.Dataframe(label="CTE Cards", interactive=False)
        cte_btn.click(fn=run_cte_scan, outputs=[cte_status, cte_results])

    with gr.Tab("📜 Historical Names"):
        gr.Markdown("Find cards matching famous NationStates names (regions, moderators, historic players).")
        gr.Markdown(f"*Monitoring {len(HISTORICAL_NAMES)} names: {', '.join(HISTORICAL_NAMES[:10])}...*")
        hist_btn = gr.Button("📜 Scan Historical Names", variant="primary")
        hist_status = gr.Markdown("")
        hist_results = gr.Dataframe(label="Historical Cards", interactive=False)
        hist_btn.click(fn=run_historical_scan, outputs=[hist_status, hist_results])

    with gr.Tab("💰 Price Check"):
        gr.Markdown("Check live market prices for all flagged targets. Alerts if price is below threshold.")
        gr.Markdown(f"*Thresholds: Legendary < {THRESHOLDS['legendary']}, Epic < {THRESHOLDS['epic']}, Ultra-Rare < {THRESHOLDS['ultra-rare']}*")
        max_price_input = gr.Number(label="Max cards to check:", value=30, minimum=1, maximum=200, precision=0)
        price_btn = gr.Button("💰 Check Live Prices", variant="primary")
        price_alerts = gr.Markdown("")
        price_table = gr.Dataframe(label="Targets with Prices", interactive=False)
        price_btn.click(fn=run_price_check, inputs=[max_price_input], outputs=[price_alerts, price_table])

    with gr.Tab("📋 All Targets"):
        gr.Markdown("View all currently flagged high-value targets.")
        refresh_btn = gr.Button("🔄 Refresh")
        targets_table = gr.Dataframe(label="All Targets", interactive=False)
        refresh_btn.click(fn=get_all_targets, outputs=[targets_table])

    with gr.Tab("🧠 Smart Trading"):
        gr.Markdown("""### Smart Trading Advisor
Analyzes targets using multiple factors to score buy opportunities (0-100):
- **Price vs Market Value** — Is it undervalued?
- **Price Trend** — Is the price dropping?
- **Spread Analysis** — Room to negotiate?
- **Rarity & Scarcity** — CTE/Historical bonuses
- **Suggested Bids** — Optimal bid prices based on trade history
        """)
        smart_max = gr.Number(label="Max cards to analyze:", value=20, minimum=1, maximum=100, precision=0)
        gr.Markdown("*⏱️ ~3.6s per card (3 API calls each)*")
        smart_btn = gr.Button("🧠 Run Smart Analysis", variant="primary")
        smart_summary = gr.Markdown("")
        smart_table = gr.Dataframe(label="Trading Opportunities (sorted by score)", interactive=False)
        smart_btn.click(fn=run_smart_analysis, inputs=[smart_max], outputs=[smart_summary, smart_table])

    with gr.Tab("🔬 Card Deep Dive"):
        gr.Markdown("Get detailed analysis of a specific card — market state, trade history, score, and bid suggestions.")
        dive_card_id = gr.Number(label="Card ID:", value=1, minimum=1, precision=0)
        dive_btn = gr.Button("🔬 Analyze Card", variant="primary")
        dive_report = gr.Markdown("")
        dive_trades = gr.Dataframe(label="Recent Trades", interactive=False)
        dive_btn.click(fn=run_card_deep_dive, inputs=[dive_card_id], outputs=[dive_report, dive_trades])

    with gr.Tab("👁️ Watchlist"):
        gr.Markdown("""### Personal Watchlist
Add specific cards you want to buy. Set your max bid price and get alerted when asks drop to your target.
        """)
        with gr.Row():
            wl_card_id = gr.Number(label="Card ID:", minimum=1, precision=0)
            wl_max_bid = gr.Number(label="Max bid price:", minimum=0, value=5.0)
            wl_notes = gr.Textbox(label="Notes:", placeholder="e.g. CTE legendary, want for collection")
        with gr.Row():
            wl_add_btn = gr.Button("➕ Add to Watchlist", variant="primary")
            wl_remove_id = gr.Number(label="Remove Card ID:", minimum=1, precision=0)
            wl_remove_btn = gr.Button("🗑️ Remove", variant="secondary")
        wl_status = gr.Markdown("")
        wl_table = gr.Dataframe(label="Your Watchlist", interactive=False)
        wl_add_btn.click(fn=add_to_watchlist, inputs=[wl_card_id, wl_max_bid, wl_notes], outputs=[wl_status, wl_table])
        wl_remove_btn.click(fn=remove_from_watchlist, inputs=[wl_remove_id], outputs=[wl_status, wl_table])

        gr.Markdown("---")
        gr.Markdown("### Check Watchlist Prices")
        wl_check_btn = gr.Button("👁️ Check Watchlist Alerts", variant="primary")
        wl_alerts = gr.Markdown("")
        wl_alert_table = gr.Dataframe(label="Watchlist Status", interactive=False)
        wl_check_btn.click(fn=check_watchlist_alerts, outputs=[wl_alerts, wl_alert_table])

        wl_refresh = gr.Button("🔄 Refresh Watchlist")
        wl_refresh.click(fn=get_watchlist, outputs=[wl_table])

    with gr.Tab("⚙️ Config"):
        gr.Markdown(f"""
### Settings
- **Season:** {SEASON}
- **Rate Limit:** {RATE_LIMIT_SECONDS}s between API requests
- **User-Agent:** `{USER_AGENT}`
- **Max Scan ID:** 10,000

### Price Alert Thresholds
| Rarity | Alert if Ask Below |
|---|---|
| Legendary | {THRESHOLDS['legendary']} |
| Epic | {THRESHOLDS['epic']} |
| Ultra-Rare | {THRESHOLDS['ultra-rare']} |

### Smart Trading Score Factors
| Factor | Max Points | Description |
|---|---|---|
| Price vs MV | 25 | Lower ask relative to market value = higher score |
| Price Trend | 15 | Dropping prices = buy opportunity |
| Spread | 10 | Larger ask-bid gap = negotiation room |
| Rarity | 15 | Legendary > Epic > Ultra-Rare |
| CTE Bonus | 10 | Dead nation = scarcer supply |
| Historical | 5 | Famous NS names |

### Historical Names ({len(HISTORICAL_NAMES)} total)
{', '.join(HISTORICAL_NAMES)}

### Compliance
⚠️ This tool is **read-only**. No automated trades, buys, or bids are executed.
All purchases must be completed manually via the generated URL links.
        """)

app.launch()