app.py

import gradio as gr
import numpy as np
import pandas as pd
import os
import datetime
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

plt.style.use('dark_background')

# --- PERSISTENT STORAGE & LEADERBOARD ---
DATA_DIR = "/data"
if not os.path.exists(DATA_DIR):
    DATA_DIR = "."
DB_FILE = os.path.join(DATA_DIR, "galactic_leaderboard.csv")

def load_leaderboard():
    if os.path.exists(DB_FILE):
        df = pd.read_csv(DB_FILE)
        # THE 3-TIER TIE-BREAKER:
        # 1. Score (Highest first) -> ascending=False
        # 2. Power Draw (Lowest first) -> ascending=True
        # 3. Timestamp (Earliest first) -> ascending=True
        df = df.sort_values(by=["Score", "Power Draw", "Timestamp"], ascending=[False, True, True]).reset_index(drop=True)
        df.insert(0, "Rank", range(1, len(df) + 1))
        # Format the display slightly
        df["Score"] = df["Score"].apply(lambda x: f"{x:.2f}%")
        return df
    return pd.DataFrame(columns=["Rank", "Commander Name", "Score", "Power Draw", "Grade", "Timestamp"])

def get_grade(score):
    if score >= 90.0: return "🏆 S-Tier"
    if score >= 85.0: return "🥇 A-Tier"
    if score >= 75.0: return "🥈 B-Tier"
    if score >= 65.0: return "🥉 C-Tier"
    return "💀 F-Tier"

def submit_score(name, score_text, power_text, grade_text):
    if not name.strip() or score_text == "0.00%":
        return "⚠️ Awaiting valid targeting data!", load_leaderboard()
    
    commander = name.strip()
    score_val = float(score_text.replace('%', ''))
    power_val = int(power_text)
    timestamp = datetime.datetime.now().strftime("%H:%M:%S")

    if os.path.exists(DB_FILE):
        df = pd.read_csv(DB_FILE)
    else:
        df = pd.DataFrame(columns=["Commander Name", "Score", "Power Draw", "Grade", "Timestamp"])
    
    if commander in df["Commander Name"].values:
        idx = df.index[df["Commander Name"] == commander].tolist()[0]
        current_best_score = float(df.at[idx, "Score"])
        current_best_power = int(df.at[idx, "Power Draw"])
        
        should_update = False
        msg = ""
        
        # Check if they beat their score
        if score_val > current_best_score:
            should_update = True
            msg = f"🔥 NEW PERSONAL BEST! Score improved to {score_val}%."
        # If score is tied, check if they improved their efficiency!
        elif score_val == current_best_score and power_val < current_best_power:
            should_update = True
            msg = f"⚡ EFFICIENCY UPGRADE! Same score, but lower Power Draw."
        else:
            msg = f"📉 Your previous system ({current_best_score}% at {current_best_power} Power) is still superior."
            
        if should_update:
            df.loc[idx, ["Score", "Power Draw", "Grade", "Timestamp"]] = [score_val, power_val, grade_text, timestamp]
    else:
        new_entry = pd.DataFrame([{
            "Commander Name": commander, "Score": score_val, 
            "Power Draw": power_val, "Grade": grade_text, "Timestamp": timestamp
        }])
        df = pd.concat([df, new_entry], ignore_index=True)
        msg = "✅ Commander registered to the Galactic Leaderboard."
        
    df.to_csv(DB_FILE, index=False)
    return msg, load_leaderboard()

# --- THE GAME DATA (1000 points for granular accuracy scores) ---
X, y = make_classification(
    n_samples=1000, n_features=2, n_informative=2, n_redundant=0, 
    n_classes=4, n_clusters_per_class=1, class_sep=1.05, random_state=42
)
# Split 1: 300 for the UI, 700 for the SECRET Leaderboard Trap!
X_ui, X_secret, y_ui, y_secret = train_test_split(X, y, test_size=700, random_state=42)
# Split 2: The 300 UI points split into Train and Validation
X_train, X_val, y_train, y_val = train_test_split(X_ui, y_ui, test_size=100, random_state=42)

# --- THE GAME ENGINE ---
def train_and_plot(model_type, knn_k, knn_weight, rf_trees, rf_depth, rf_criterion, 
                   nn_layers, nn_neurons, nn_activation, nn_lr, nn_solver, nn_alpha):
    
    power_draw = 0 

    if model_type == "📡 Proximity Radar (KNN)":
        weight_map = {"Standard (Uniform)": "uniform", "Distance Focus": "distance"}
        clf = KNeighborsClassifier(n_neighbors=knn_k, weights=weight_map[knn_weight])
        power_draw = knn_k * 5
        
    elif model_type == "🛸 Swarm Drones (Random Forest)":
        crit_map = {"Standard (Gini)": "gini", "Chaotic (Entropy)": "entropy"}
        clf = RandomForestClassifier(n_estimators=rf_trees, max_depth=rf_depth, criterion=crit_map[rf_criterion], random_state=42)
        power_draw = rf_trees * rf_depth
        
    elif model_type == "🧠 Quantum Brain (Neural Network)":
        architecture = tuple([nn_neurons] * nn_layers)
        lr_map = {"Cautious (0.001)": 0.001, "Normal (0.01)": 0.01, "Aggressive (0.1)": 0.1}
        solver_map = {"Warp Drive (Adam)": "adam", "Impulse Drive (SGD)": "sgd"}
        alpha_map = {"None": 0.0001, "Light": 0.01, "Heavy": 0.1}
        
        clf = MLPClassifier(
            hidden_layer_sizes=architecture, activation=nn_activation, 
            learning_rate_init=lr_map[nn_lr], solver=solver_map[nn_solver], 
            alpha=alpha_map[nn_alpha], max_iter=150, random_state=42
        )
        power_draw = (nn_layers * nn_neurons) * 10
    else:
        return "0.00%", "0", "F-Tier", None

    # Train on the UI Train set, Test on the SECRET set! (The Kaggle Trap)
    clf.fit(X_train, y_train)
    preds = clf.predict(X_secret)
    acc = accuracy_score(y_secret, preds)
    acc_text = f"{acc * 100:.2f}%"
    grade_text = get_grade(acc * 100)
    
    # Visualization generated using the UI Validation set (so they don't see the secret data)
    fig, ax = plt.subplots(figsize=(7, 6))
    fig.patch.set_facecolor('#0b0f19') 
    ax.set_facecolor('#0b0f19')
    
    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.05), np.arange(y_min, y_max, 0.05))
    
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    cmap_custom = plt.cm.get_cmap('magma', 4)
    ax.contourf(xx, yy, Z, alpha=0.5, cmap=cmap_custom, antialiased=True)
    ax.scatter(X_val[:, 0], X_val[:, 1], c=y_val, cmap=cmap_custom, edgecolors='#ffffff', linewidths=0.5, s=40, zorder=3)
    
    ax.grid(color='#1e293b', linestyle='--', linewidth=0.5, alpha=0.5, zorder=0)
    ax.set_title(f"TACTICAL MAP: {model_type.split('(')[0].strip()}", color='#38bdf8', fontsize=14, fontweight='bold', pad=15)
    ax.set_xticks([])
    ax.set_yticks([])
    
    for spine in ax.spines.values():
        spine.set_color('#1e293b')
        spine.set_linewidth(2)

    plt.tight_layout()
    return acc_text, str(power_draw), grade_text, fig

# --- UI VISIBILITY LOGIC ---
def show_knn(): return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
def show_rf(): return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
def show_nn(): return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)

# --- THE GRADIO "CONSOLE" UI ---
with gr.Blocks(theme=gr.themes.Glass()) as demo:
    gr.Markdown("# 🌌 GALACTIC TARGETING COMMAND")
    
    with gr.Tabs():
        with gr.Tab("🎮 Tactical Console"):
            gr.Markdown("> **INCOMING TRANSMISSION:** Four alien factions are warping into our sector. Calibrate the defense algorithms. Build the most accurate model to secure an S-Tier rank!")
            
            with gr.Row():
                with gr.Column(scale=1):
                    model_dropdown = gr.Dropdown(
                        choices=["📡 Proximity Radar (KNN)", "🛸 Swarm Drones (Random Forest)", "🧠 Quantum Brain (Neural Network)"],
                        value="📡 Proximity Radar (KNN)",
                        label="1. Select Hardware Component"
                    )
                    
                    with gr.Column(visible=True) as knn_block:
                        knn_k = gr.Slider(minimum=1, maximum=50, step=1, value=5, label="Sensor Scan Radius (Neighbors)")
                        knn_weight = gr.Dropdown(choices=["Standard (Uniform)", "Distance Focus"], value="Standard (Uniform)", label="Sensor Priority")
                    
                    with gr.Column(visible=False) as rf_block:
                        rf_trees = gr.Slider(minimum=1, maximum=50, step=1, value=25, label="Drone Fleet Size (Trees)")
                        rf_depth = gr.Slider(minimum=1, maximum=20, step=1, value=5, label="Drone Autonomy (Max Depth)")
                        rf_criterion = gr.Dropdown(choices=["Standard (Gini)", "Chaotic (Entropy)"], value="Standard (Gini)", label="Logic Core")
                    
                    with gr.Column(visible=False) as nn_block:
                        nn_layers = gr.Slider(minimum=1, maximum=4, step=1, value=2, label="Synaptic Layers")
                        nn_neurons = gr.Slider(minimum=5, maximum=50, step=5, value=20, label="Neurons per Layer")
                        with gr.Row():
                            nn_activation = gr.Dropdown(choices=["relu", "tanh", "logistic"], value="relu", label="Thinking Style")
                            nn_solver = gr.Dropdown(choices=["Warp Drive (Adam)", "Impulse Drive (SGD)"], value="Warp Drive (Adam)", label="Engine")
                        with gr.Row():
                            nn_lr = gr.Dropdown(choices=["Cautious (0.001)", "Normal (0.01)", "Aggressive (0.1)"], value="Normal (0.01)", label="Learning Speed")
                            nn_alpha = gr.Dropdown(choices=["None", "Light", "Heavy"], value="None", label="L2 Shielding")

                    gr.Markdown("---")
                    train_btn = gr.Button("⚡ INITIATE CALIBRATION SEQUENCE ⚡", variant="primary", size="lg")
                    
                    with gr.Row():
                        accuracy_display = gr.Textbox(label="Radar Accuracy", value="0.00%", text_align="center")
                        grade_display = gr.Textbox(label="Combat Rank", value="Pending", text_align="center")
                        power_display = gr.Textbox(label="Power Draw (Cost)", value="0", text_align="center")
                    
                    gr.Markdown("---")
                    player_name = gr.Textbox(label="3. Submit Calibration to Fleet Command", placeholder="Enter Callsign / Name...")
                    submit_btn = gr.Button("Transmit Score")
                    status_msg = gr.Markdown("")
                    
                with gr.Column(scale=2):
                    plot_display = gr.Plot(label="Tactical Display")
        
        with gr.Tab("🏆 Galactic Leaderboard"):
            gr.Markdown("### 📜 Rules of Combat:\n1. Highest **Accuracy** takes the lead.\n2. In a tie, the lowest **Power Draw** wins.\n3. If power is also tied, the **Earliest Submission** takes the prize.")
            refresh_btn = gr.Button("🔄 Sync Data with Command")
            leaderboard_df = gr.Dataframe(value=load_leaderboard, interactive=False)

    model_dropdown.change(fn=lambda x: show_knn() if "KNN" in x else (show_rf() if "Random Forest" in x else show_nn()), 
                          inputs=model_dropdown, outputs=[knn_block, rf_block, nn_block])
    
    train_btn.click(fn=train_and_plot, 
                    inputs=[model_dropdown, knn_k, knn_weight, rf_trees, rf_depth, rf_criterion, 
                            nn_layers, nn_neurons, nn_activation, nn_lr, nn_solver, nn_alpha], 
                    outputs=[accuracy_display, power_display, grade_display, plot_display])
    
    submit_btn.click(fn=submit_score, inputs=[player_name, accuracy_display, power_display, grade_display], outputs=[status_msg, leaderboard_df])
    refresh_btn.click(fn=load_leaderboard, inputs=None, outputs=leaderboard_df)

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