Update app.py

app.py

@@ -70,7 +70,6 @@ def reset_leaderboard():
         json.dump({"scores": []}, f, indent=2)
 
 # ---------------- Roadmaps & Data ----------------
-# (includes Class 6..10, JEE Main, NEET, B.Tech 1st..Final Year)
 ROADMAPS = {
     "Class 6": {
         "objective": "Build curiosity, logical thinking, basic problem-solving and gentle programming.",
@@ -368,368 +367,6 @@ int main() {
 }""",
             "explanation": "Singly linked list implementation with dynamic memory allocation. Includes node creation, insertion at end, deletion by value, and display functions.",
             "video_url": "https://www.youtube.com/embed/dq3F3e9o2DM"
-        },
-        {
-            "title": "Binary Search Tree",
-            "problem": "Implement BST with insert, search and inorder traversal",
-            "code": """#include <stdio.h>
-#include <stdlib.h>
-
-struct Node {
-    int data;
-    struct Node *left, *right;
-};
-
-struct Node* createNode(int data) {
-    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
-    newNode->data = data;
-    newNode->left = newNode->right = NULL;
-    return newNode;
-}
-
-struct Node* insert(struct Node* root, int data) {
-    if (root == NULL)
-        return createNode(data);
-    
-    if (data < root->data)
-        root->left = insert(root->left, data);
-    else if (data > root->data)
-        root->right = insert(root->right, data);
-    
-    return root;
-}
-
-struct Node* search(struct Node* root, int key) {
-    if (root == NULL || root->data == key)
-        return root;
-    
-    if (key < root->data)
-        return search(root->left, key);
-    
-    return search(root->right, key);
-}
-
-void inorder(struct Node* root) {
-    if (root != NULL) {
-        inorder(root->left);
-        printf("%d ", root->data);
-        inorder(root->right);
-    }
-}
-
-int main() {
-    struct Node* root = NULL;
-    
-    root = insert(root, 50);
-    insert(root, 30);
-    insert(root, 20);
-    insert(root, 40);
-    insert(root, 70);
-    insert(root, 60);
-    insert(root, 80);
-    
-    printf("Inorder traversal: ");
-    inorder(root);
-    printf("\\n");
-    
-    int key = 40;
-    if (search(root, key) != NULL)
-        printf("%d found in BST\\n", key);
-    else
-        printf("%d not found in BST\\n", key);
-    
-    return 0;
-}""",
-            "explanation": "Binary Search Tree implementation with recursive insert, search and inorder traversal. BST property: left < root < right.",
-            "video_url": "https://www.youtube.com/embed/cySVml6e_Fc"
-        }
-    ],
-    "B.Tech 3rd Year": [
-        {
-            "title": "Dijkstra's Algorithm",
-            "problem": "Implement Dijkstra's algorithm for shortest path finding",
-            "code": """#include <stdio.h>
-#include <limits.h>
-
-#define V 6
-
-int minDistance(int dist[], int sptSet[]) {
-    int min = INT_MAX, min_index;
-    
-    for (int v = 0; v < V; v++)
-        if (sptSet[v] == 0 && dist[v] <= min)
-            min = dist[v], min_index = v;
-    
-    return min_index;
-}
-
-void printSolution(int dist[]) {
-    printf("Vertex \\t Distance from Source\\n");
-    for (int i = 0; i < V; i++)
-        printf("%d \\t %d\\n", i, dist[i]);
-}
-
-void dijkstra(int graph[V][V], int src) {
-    int dist[V];
-    int sptSet[V];
-    
-    for (int i = 0; i < V; i++)
-        dist[i] = INT_MAX, sptSet[i] = 0;
-    
-    dist[src] = 0;
-    
-    for (int count = 0; count < V - 1; count++) {
-        int u = minDistance(dist, sptSet);
-        sptSet[u] = 1;
-        
-        for (int v = 0; v < V; v++)
-            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX 
-                && dist[u] + graph[u][v] < dist[v])
-                dist[v] = dist[u] + graph[u][v];
-    }
-    
-    printSolution(dist);
-}
-
-int main() {
-    int graph[V][V] = {
-        {0, 4, 0, 0, 0, 0},
-        {4, 0, 8, 0, 0, 0},
-        {0, 8, 0, 7, 0, 4},
-        {0, 0, 7, 0, 9, 14},
-        {0, 0, 0, 9, 0, 10},
-        {0, 0, 4, 14, 10, 0}
-    };
-    
-    dijkstra(graph, 0);
-    return 0;
-}""",
-            "explanation": "Dijkstra's algorithm finds shortest paths from source to all vertices in a weighted graph. Uses greedy approach with priority queue.",
-            "video_url": "https://www.youtube.com/embed/GazC3A4OQTE"
-        },
-        {
-            "title": "Producer-Consumer Problem",
-            "problem": "Implement producer-consumer problem using semaphores",
-            "code": """#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <semaphore.h>
-
-#define BUFFER_SIZE 5
-
-int buffer[BUFFER_SIZE];
-int in = 0, out = 0;
-
-sem_t empty, full;
-pthread_mutex_t mutex;
-
-void* producer(void* arg) {
-    int item;
-    for (int i = 0; i < 10; i++) {
-        item = rand() % 100;
-        
-        sem_wait(&empty);
-        pthread_mutex_lock(&mutex);
-        
-        buffer[in] = item;
-        printf("Producer produced: %d\\n", item);
-        in = (in + 1) % BUFFER_SIZE;
-        
-        pthread_mutex_unlock(&mutex);
-        sem_post(&full);
-    }
-    return NULL;
-}
-
-void* consumer(void* arg) {
-    int item;
-    for (int i = 0; i < 10; i++) {
-        sem_wait(&full);
-        pthread_mutex_lock(&mutex);
-        
-        item = buffer[out];
-        printf("Consumer consumed: %d\\n", item);
-        out = (out + 1) % BUFFER_SIZE;
-        
-        pthread_mutex_unlock(&mutex);
-        sem_post(&empty);
-    }
-    return NULL;
-}
-
-int main() {
-    pthread_t prod_thread, cons_thread;
-    
-    sem_init(&empty, 0, BUFFER_SIZE);
-    sem_init(&full, 0, 0);
-    pthread_mutex_init(&mutex, NULL);
-    
-    pthread_create(&prod_thread, NULL, producer, NULL);
-    pthread_create(&cons_thread, NULL, consumer, NULL);
-    
-    pthread_join(prod_thread, NULL);
-    pthread_join(cons_thread, NULL);
-    
-    sem_destroy(&empty);
-    sem_destroy(&full);
-    pthread_mutex_destroy(&mutex);
-    
-    return 0;
-}""",
-            "explanation": "Producer-Consumer problem solution using semaphores for synchronization. Empty semaphore tracks empty slots, full semaphore tracks filled slots.",
-            "video_url": "https://www.youtube.com/embed/ltXjAtncKeo"
-        }
-    ],
-    "B.Tech Final Year": [
-        {
-            "title": "Machine Learning - Linear Regression",
-            "problem": "Implement linear regression from scratch in Python",
-            "code": """import numpy as np
-import matplotlib.pyplot as plt
-
-class LinearRegression:
-    def __init__(self, learning_rate=0.01, iterations=1000):
-        self.learning_rate = learning_rate
-        self.iterations = iterations
-        self.weights = None
-        self.bias = None
-        self.loss_history = []
-    
-    def fit(self, X, y):
-        n_samples, n_features = X.shape
-        self.weights = np.zeros(n_features)
-        self.bias = 0
-        
-        for i in range(self.iterations):
-            y_pred = np.dot(X, self.weights) + self.bias
-            
-            # Calculate gradients
-            dw = (1/n_samples) * np.dot(X.T, (y_pred - y))
-            db = (1/n_samples) * np.sum(y_pred - y)
-            
-            # Update parameters
-            self.weights -= self.learning_rate * dw
-            self.bias -= self.learning_rate * db
-            
-            # Calculate loss
-            loss = np.mean((y_pred - y) ** 2)
-            self.loss_history.append(loss)
-            
-            if i % 100 == 0:
-                print(f"Iteration {i}, Loss: {loss:.4f}")
-    
-    def predict(self, X):
-        return np.dot(X, self.weights) + self.bias
-
-# Example usage
-if __name__ == "__main__":
-    # Generate sample data
-    np.random.seed(42)
-    X = 2 * np.random.rand(100, 1)
-    y = 4 + 3 * X + np.random.randn(100, 1)
-    
-    # Create and train model
-    model = LinearRegression(learning_rate=0.1, iterations=1000)
-    model.fit(X, y.ravel())
-    
-    # Make predictions
-    X_new = np.array([[0], [2]])
-    y_pred = model.predict(X_new)
-    
-    print(f"Predicted for x=0: {y_pred[0]:.2f}")
-    print(f"Predicted for x=2: {y_pred[1]:.2f}")
-    
-    # Plot results
-    plt.scatter(X, y)
-    plt.plot(X_new, y_pred, 'r-')
-    plt.title('Linear Regression')
-    plt.xlabel('X')
-    plt.ylabel('y')
-    plt.show()""",
-            "explanation": "Linear regression implementation from scratch using gradient descent. Updates weights and bias to minimize mean squared error.",
-            "video_url": "https://www.youtube.com/embed/4b4MUYve_U8"
-        },
-        {
-            "title": "Blockchain Implementation",
-            "problem": "Simple blockchain implementation in Python",
-            "code": """import hashlib
-import time
-import json
-
-class Block:
-    def __init__(self, index, transactions, timestamp, previous_hash):
-        self.index = index
-        self.transactions = transactions
-        self.timestamp = timestamp
-        self.previous_hash = previous_hash
-        self.nonce = 0
-        self.hash = self.calculate_hash()
-    
-    def calculate_hash(self):
-        block_string = json.dumps({
-            "index": self.index,
-            "transactions": self.transactions,
-            "timestamp": self.timestamp,
-            "previous_hash": self.previous_hash,
-            "nonce": self.nonce
-        }, sort_keys=True)
-        return hashlib.sha256(block_string.encode()).hexdigest()
-    
-    def mine_block(self, difficulty):
-        target = "0" * difficulty
-        while self.hash[:difficulty] != target:
-            self.nonce += 1
-            self.hash = self.calculate_hash()
-        print(f"Block mined: {self.hash}")
-
-class Blockchain:
-    def __init__(self):
-        self.chain = [self.create_genesis_block()]
-        self.difficulty = 2
-        self.pending_transactions = []
-    
-    def create_genesis_block(self):
-        return Block(0, ["Genesis Block"], time.time(), "0")
-    
-    def get_latest_block(self):
-        return self.chain[-1]
-    
-    def add_transaction(self, transaction):
-        self.pending_transactions.append(transaction)
-    
-    def mine_pending_transactions(self):
-        block = Block(len(self.chain), self.pending_transactions, time.time(), self.get_latest_block().hash)
-        block.mine_block(self.difficulty)
-        self.chain.append(block)
-        self.pending_transactions = []
-    
-    def is_chain_valid(self):
-        for i in range(1, len(self.chain)):
-            current_block = self.chain[i]
-            previous_block = self.chain[i-1]
-            
-            if current_block.hash != current_block.calculate_hash():
-                return False
-            if current_block.previous_hash != previous_block.hash:
-                return False
-        return True
-
-# Example usage
-if __name__ == "__main__":
-    blockchain = Blockchain()
-    
-    print("Mining block 1...")
-    blockchain.add_transaction("Transaction 1")
-    blockchain.mine_pending_transactions()
-    
-    print("Mining block 2...")
-    blockchain.add_transaction("Transaction 2")
-    blockchain.mine_pending_transactions()
-    
-    print(f"Blockchain valid: {blockchain.is_chain_valid()}")
-    print(f"Blockchain length: {len(blockchain.chain)}")""",
-            "explanation": "Simple blockchain implementation with mining, transaction adding, and chain validation. Uses SHA-256 hashing and proof-of-work.",
-            "video_url": "https://www.youtube.com/embed/zVqczFZr124"
         }
     ]
 }
@@ -741,11 +378,10 @@ HACKATHONS = [
 ]
 INTERNSHIPS = [
     {"name":"Software Engineering Intern","deadline":"2025-10-30","duration":"12 weeks","stipend":"₹30,000/month","skills":["Python"],"url":"https://jobs.careers.microsoft.com/us/en/job/1880847/Software-Engineering-Intern","type":"B.Tech","level":"Class 11-12"},
-    {"name":"Software Application Development Apprenticeship, March 2026","deadline":"20245-10-10","duration":"12 weeks","stipend":"50000k","skills":["Open Source"],"url":"https://www.geekscodes.com/2025/08/google-software-development.html","type":"Open Source","level":"B.Tech 2nd-4th Year"},
-    {"name":"Full Stack Development Intern","deadline":"2025-09-30","duration":"12 weeks","stipend":"30000k","skills":["Open Source"],"url":"https://www.linkedin.com/jobs/view/full-stack-development-intern-at-sony-research-india-4301264932/","type":"Open Source","level":"B.Tech 2nd-4th Year"}
+    {"name":"Software Application Development Apprenticeship, March 2026","deadline":"2025-10-10","duration":"12 weeks","stipend":"50000k","skills":["Open Source"],"url":"https://www.geekscodes.com/2025/08/google-software-development.html","type":"Open Source","level":"B.Tech 2nd-4th Year"}
 ]
 SCHOLARSHIPS = [
-    {"name":"Reliance Foundation Scholarships","deadline":"2026-01-15","amount":"₹10000/month","eligibility":"Secondaty,Undergraduate,Postgraduate","url":"https://www.scholarships.reliancefoundation.org/","type":"Merit-based","level":"Secondaty,Undergraduate,Postgraduate"}
+    {"name":"Reliance Foundation Scholarships","deadline":"2026-01-15","amount":"₹10000/month","eligibility":"Secondary,Undergraduate,Postgraduate","url":"https://www.scholarships.reliancefoundation.org/","type":"Merit-based","level":"Secondary,Undergraduate,Postgraduate"}
 ]
 
 # ---------------- AI Mentor (lightweight) ----------------
@@ -814,4 +450,392 @@ def mark_session_completed(level, session_title):
 
 def create_dashboard_stats(level):
     p = load_progress()
-    sessions = ROADMAPS.get(
+    sessions = ROADMAPS.get(level, {}).get("study_sessions", [])
+    completed_sessions = sum(1 for s in sessions if p.get("study_sessions_completed", {}).get(f"{level}_{s['title']}", False))
+    total_sessions = len(sessions)
+    percent = (completed_sessions / total_sessions * 100) if total_sessions > 0 else 0
+    last = p.get("last_study_date", datetime.now().isoformat())[:10]
+    html_block = f"""
+    <div style='background:linear-gradient(135deg,#dbeafe,#bde4ff);color:#0b3d91;padding:16px;border-radius:10px;'>
+      <h3>🎯 {level} Learning Dashboard</h3>
+      <div style='display:flex;justify-content:space-around;flex-wrap:wrap;margin-top:10px;'>
+        <div><h4>📚 {completed_sessions}/{total_sessions}</h4><small>Sessions</small></div>
+        <div><h4>⏰ {p.get('total_hours_studied',0):.1f}</h4><small>Total Hours</small></div>
+        <div><h4>📅 {last}</h4><small>Last Study</small></div>
+      </div>
+      <p style='margin-top:12px;'>Overall Progress: <strong>{percent:.1f}%</strong></p>
+      <div style='background:#ddd;border-radius:8px;height:10px;'><div style='background:#28a745;height:100%;width:{percent}%;border-radius:8px;'></div></div>
+    </div>
+    """
+    return html_block
+
+def get_code_snippets_interface(level):
+    if level not in CODE_SNIPPETS:
+        return "<div style='text-align:center;padding:20px;'><h4>No code snippets available for this level</h4></div>"
+    
+    snippets = CODE_SNIPPETS[level]
+    progress_data = load_progress()
+    snippets_html = "<div style='max-height:520px;overflow-y:auto;'>"
+    snippets_html += "<h3>💻 Code Snippets & Practice Problems</h3>"
+    
+    for i, snippet in enumerate(snippets):
+        snippet_key = f"{level}_{snippet['title']}"
+        is_completed = progress_data.get("code_snippets_completed", {}).get(snippet_key, False)
+        status_icon = "✅" if is_completed else "💻"
+        status_color = "#28a745" if is_completed else "#007bff"
+        
+        snippets_html += f"""
+        <div style='padding:12px;margin:8px 0;background:{'#d4edda' if is_completed else '#f8f9fa'};border-radius:8px;border-left:4px solid {status_color};'>
+            <h4 style="color:#0b3d91">{status_icon} {html.escape(snippet['title'])}</h4>
+            <p><strong>Problem:</strong> {html.escape(snippet['problem'])}</p>
+            <details>
+                <summary><strong>View Code Solution</strong></summary>
+                <pre style='background:#f5f5f5;padding:10px;border-radius:5px;overflow-x:auto;'>{html.escape(snippet['code'])}</pre>
+            </details>
+            <p><strong>Explanation:</strong> {html.escape(snippet['explanation'])}</p>
+            <div style='margin-top:10px;'>
+                <iframe width="100%" height="200" src="{snippet['video_url']}" frameborder="0" allowfullscreen></iframe>
+            </div>
+        </div>
+        """
+    snippets_html += "</div>"
+    return snippets_html
+
+def mark_code_snippet_completed(level, snippet_title):
+    if not level or not snippet_title:
+        return "❌ Level and snippet title required."
+    p = load_progress()
+    key = f"{level}_{snippet_title}"
+    p.setdefault("code_snippets_completed", {})
+    current = p["code_snippets_completed"].get(key, False)
+    p["code_snippets_completed"][key] = not current
+    save_progress(p)
+    action = "completed" if not current else "unmarked"
+    return f"✅ Code snippet '{snippet_title}' {action}!"
+
+# ---------------- Opportunities & Reminders ----------------
+def get_upcoming_deadlines_html():
+    today = datetime.now().date()
+    items = HACKATHONS + INTERNSHIPS + SCHOLARSHIPS
+    deadlines = []
+    for it in items:
+        dl = it.get("deadline")
+        try:
+            d = datetime.strptime(dl, "%Y-%m-%d").date()
+            days = (d - today).days
+        except:
+            days = None
+        deadlines.append({"name":it.get("name"), "deadline":dl, "days_left":days, "url":it.get("url","#")})
+    deadlines = sorted([d for d in deadlines if d['days_left'] is None or d['days_left']>=0], key=lambda x: (x['days_left'] if x['days_left'] is not None else 999))
+    if not deadlines:
+        return "<div style='padding:12px;text-align:center;'><h4>No upcoming deadlines</h4></div>"
+    html_block = "<div style='max-height:420px;overflow-y:auto;'>"
+    for d in deadlines[:12]:
+        left = f"{d['days_left']} days left" if d['days_left'] is not None else "N/A"
+        html_block += f"<div style='padding:10px;margin:8px 0;background:white;border-radius:8px;'><h4>{html.escape(d['name'])}</h4><p>📅 {d['deadline']} | {left}</p><a href='{d['url']}' target='_blank'>More</a></div>"
+    html_block += "</div>"
+    return html_block
+
+def create_hackathon_interface_html():
+    html_block = "<div style='max-height:420px;overflow-y:auto;'>"
+    for h in HACKATHONS:
+        try:
+            days = (datetime.strptime(h['deadline'],'%Y-%m-%d').date() - datetime.now().date()).days
+        except:
+            days = "N/A"
+        html_block += f"<div style='padding:12px;margin:8px 0;background:linear-gradient(135deg,#dbeafe,#bde4ff);color:#0b3d91;border-radius:8px;'><h4>🏆 {h['name']}</h4><p>📅 {h['deadline']} | {days} days left</p><p>Eligibility: {h['eligibility']}</p><a href='{h['url']}' style='color:#0b3d91' target='_blank'>Apply</a></div>"
+    html_block += "</div>"
+    return html_block
+
+def create_internship_interface_html():
+    html_block = "<div style='max-height:420px;overflow-y:auto;'>"
+    for it in INTERNSHIPS:
+        try:
+            days = (datetime.strptime(it['deadline'],'%Y-%m-%d').date() - datetime.now().date()).days
+        except:
+            days = "N/A"
+        html_block += f"<div style='padding:12px;margin:8px 0;background:linear-gradient(135deg,#e6f4ff,#cfeeff);color:#0b3d91;border-radius:8px;'><h4>💼 {it['name']}</h4><p>📅 {it['deadline']} | {days} days left</p><p>Duration: {it.get('duration')}</p><a href='{it['url']}' style='color:#0b3d91' target='_blank'>Apply</a></div>"
+    html_block += "</div>"
+    return html_block
+
+def create_scholarship_interface_html():
+    html_block = "<div style='max-height:420px;overflow-y:auto;'>"
+    for s in SCHOLARSHIPS:
+        try:
+            days = (datetime.strptime(s['deadline'],'%Y-%m-%d').date() - datetime.now().date()).days
+        except:
+            days = "N/A"
+        html_block += f"<div style='padding:12px;margin:8px 0;background:linear-gradient(135deg,#e0f7ff,#cdeeff);color:#0b3d91;border-radius:8px;'><h4>🎓 {s['name']}</h4><p>📅 {s['deadline']} | {days} days left</p><p>Amount: {s.get('amount')}</p><a href='{s['url']}' style='color:#0b3d91' target='_blank'>Apply</a></div>"
+    html_block += "</div>"
+    return html_block
+
+def set_custom_reminder(reminder_type, reminder_name, reminder_date, reminder_notes):
+    if not reminder_name or not reminder_date:
+        return "❌ Name and date required."
+    try:
+        datetime.strptime(reminder_date, "%Y-%m-%d")
+    except ValueError:
+        return "❌ Invalid date format. Use YYYY-MM-DD."
+    data = load_opportunities()
+    data.setdefault("reminders", [])
+    new = {
+        "type": reminder_type or "Personal",
+        "name": reminder_name,
+        "date": reminder_date,
+        "notes": reminder_notes or "",
+        "set_date": datetime.now().isoformat(),
+        "completed": False
+    }
+    data["reminders"].append(new)
+    save_opportunities(data)
+    return f"✅ Reminder set for {reminder_date}: {reminder_name}"
+
+def get_custom_reminders_html():
+    data = load_opportunities()
+    rems = data.get("reminders", [])
+    if not rems:
+        return "<div style='text-align:center;padding:12px;'><h4>No custom reminders.</h4></div>"
+    html_block = "<div style='max-height:420px;overflow-y:auto;'>"
+    for idx, r in enumerate(rems):
+        try:
+            d = datetime.strptime(r['date'], "%Y-%m-%d").date()
+            days_left = (d - datetime.now().date()).days
+            left_text = f"{days_left} days left"
+        except:
+            left_text = "N/A"
+        color = "#28a745" if r.get("completed") else "#ff6b6b"
+        status = "✅" if r.get("completed") else "⏳"
+        html_block += f"""
+        <div style='padding:10px;margin:8px 0;background:white;border-left:6px solid {color};border-radius:8px;'>
+            <h4>{status} [{idx}] {html.escape(r['type'])}: {html.escape(r['name'])}</h4>
+            <p>📅 {r['date']} | {left_text}</p>
+            <p>📝 {html.escape(r.get('notes',''))}</p>
+            <p style='font-size:12px;color:#666;'>Set on: {r['set_date'][:10]}</p>
+        </div>
+        """
+    html_block += "</div>"
+    return html_block
+
+def mark_reminder_completed(index):
+    data = load_opportunities()
+    rems = data.get("reminders", [])
+    try:
+        idx = int(index)
+        if idx < 0 or idx >= len(rems):
+            return "❌ Invalid index"
+    except:
+        return "❌ Invalid index"
+    rems[idx]['completed'] = True
+    save_opportunities(data)
+    return "✅ Reminder marked completed."
+
+def delete_reminder(index):
+    data = load_opportunities()
+    rems = data.get("reminders", [])
+    try:
+        idx = int(index)
+        if idx < 0 or idx >= len(rems):
+            return "❌ Invalid index"
+    except:
+        return "❌ Invalid index"
+    name = rems[idx].get("name","")
+    rems.pop(idx)
+    save_opportunities(data)
+    return f"🗑️ Reminder '{name}' deleted."
+
+# ---------------- GRADIO UI ----------------
+custom_css = """
+.gradio-container {
+    background: linear-gradient(135deg, #eaf6ff 0%, #d5efff 100%);
+    min-height: 100vh;
+    padding: 24px;
+    color: #0b3d91;
+}
+.gradio-container .container {
+    background: rgba(255,255,255,0.04);
+    border-radius: 12px;
+    padding: 16px;
+}
+"""
+
+with gr.Blocks(title="Road2Success — Learning Dashboard", theme=gr.themes.Soft(), css=custom_css) as app:
+    gr.Markdown("# 🚀 Road2Success — Learning Dashboard")
+    gr.Markdown("*Professional roadmap, AI mentor, hackathon prep & leaderboard*")
+
+    with gr.Tabs():
+        # Learning Dashboard
+        with gr.TabItem("🏠 Learning Dashboard"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("### Select Level")
+                    level_choice = gr.Radio(choices=list(ROADMAPS.keys()), value=list(ROADMAPS.keys())[0], label="Level")
+                    refresh_btn = gr.Button("🔄 Refresh")
+                    stats_display = gr.HTML()
+                with gr.Column(scale=3):
+                    progress_plot = gr.Plot()
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("### Study Materials")
+                    materials_html = gr.HTML()
+                with gr.Column(scale=1):
+                    gr.Markdown("### Quick Actions")
+                    session_dropdown = gr.Dropdown(label="Session", choices=[])
+                    mark_session_btn = gr.Button("Mark Session Complete")
+                    action_status = gr.Textbox(interactive=False, label="Action status")
+                    
+                    gr.Markdown("### Code Snippets")
+                    code_snippets_html = gr.HTML()
+                    snippet_dropdown = gr.Dropdown(label="Code Snippet", choices=[])
+                    mark_snippet_btn = gr.Button("Mark Snippet Complete")
+                    snippet_status = gr.Textbox(interactive=False, label="Snippet status")
+                    
+                    reset_btn = gr.Button("⚠️ Reset Dashboard", variant="danger")
+                    reset_status = gr.Textbox(interactive=False, label="Reset status")
+
+        # Study Roadmaps
+        with gr.TabItem("📚 Study Roadmaps"):
+            gr.Markdown("## 🗺️ Study Roadmaps")
+            roadmap_level = gr.Dropdown(choices=list(ROADMAPS.keys()), value=list(ROADMAPS.keys())[0], label="Select Level")
+            show_roadmap_btn = gr.Button("Show Roadmap")
+            roadmap_html = gr.HTML()
+
+        # Opportunities & Reminders
+        with gr.TabItem("🚀 Opportunities & Reminders"):
+            gr.Markdown("## 🌟 Opportunities Hub")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    opp_overview = gr.HTML()
+                    gr.Markdown("### Hackathons")
+                    hack_html = gr.HTML()
+                    gr.Markdown("### Internships")
+                    intern_html = gr.HTML()
+                    gr.Markdown("### Scholarships")
+                    schol_html = gr.HTML()
+                with gr.Column(scale=1):
+                    gr.Markdown("### Set Custom Reminder")
+                    r_type = gr.Dropdown(["Hackathon","Internship","Scholarship","Exam","Project","Personal"], label="Type")
+                    r_name = gr.Textbox(label="Name")
+                    r_date = gr.Textbox(label="Date (YYYY-MM-DD)")
+                    r_notes = gr.Textbox(label="Notes", lines=2)
+                    set_reminder_btn = gr.Button("Set Reminder")
+                    set_out = gr.Textbox(interactive=False, label="Set status")
+                    gr.Markdown("### Your Reminders (0-based index shown)")
+                    reminders_html = gr.HTML()
+                    rem_index = gr.Textbox(label="Reminder index (0-based)")
+                    mark_done_btn = gr.Button("Mark Done")
+                    del_btn = gr.Button("Delete Reminder")
+                    rem_action_status = gr.Textbox(interactive=False, label="Reminder action status")
+
+        # AI Mentor
+        with gr.TabItem("🤖 AI Mentor"):
+            gr.Markdown("## 💬 AI Mentor (simple fallback)")
+            prompt = gr.Textbox(label="Ask a question", lines=3)
+            short_toggle = gr.Checkbox(label="Short answer", value=True)
+            eli5_toggle = gr.Checkbox(label="Explain simply", value=False)
+            ask_btn = gr.Button("Ask Mentor")
+            mentor_out = gr.Textbox(lines=6, label="Mentor output")
+
+    # -- Core update function
+    def update_dashboard(level):
+        sessions = ROADMAPS.get(level, {}).get("study_sessions", [])
+        session_titles = [s['title'] for s in sessions]
+        
+        # Get code snippets for the level
+        snippet_titles = []
+        if level in CODE_SNIPPETS:
+            snippet_titles = [s['title'] for s in CODE_SNIPPETS[level]]
+        
+        stats = create_dashboard_stats(level)
+        completed_sessions = sum(1 for s in sessions if load_progress().get("study_sessions_completed", {}).get(f"{level}_{s['title']}", False))
+        fig = create_progress_chart(level, completed_sessions, len(sessions))
+        
+        materials = get_study_materials_interface(level)
+        code_snippets = get_code_snippets_interface(level)
+        opps = get_upcoming_deadlines_html()
+        
+        return (gr.update(choices=session_titles, value=(session_titles[0] if session_titles else None)),
+                gr.update(choices=snippet_titles, value=(snippet_titles[0] if snippet_titles else None)),
+                stats, fig, materials, code_snippets, opps)
+
+    def refresh_all(level):
+        session_update, snippet_update, stats, fig, materials, code_snippets, opps = update_dashboard(level)
+        reminders = get_custom_reminders_html()
+        hack = create_hackathon_interface_html()
+        intern = create_internship_interface_html()
+        schol = create_scholarship_interface_html()
+        return session_update, snippet_update, stats, fig, materials, code_snippets, opps, reminders, hack, intern, schol
+
+    def reset_dashboard():
+        save_progress(default_progress_data())
+        save_opportunities(default_opportunities_data())
+        reset_leaderboard()
+        return "✅ Dashboard reset to defaults."
+
+    # Wire events
+    level_choice.change(update_dashboard, inputs=[level_choice], 
+                       outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview])
+    
+    refresh_btn.click(update_dashboard, inputs=[level_choice], 
+                     outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview])
+
+    mark_session_btn.click(mark_session_completed, inputs=[level_choice, session_dropdown], outputs=[action_status]).then(
+        update_dashboard, inputs=[level_choice], 
+        outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview]
+    )
+
+    mark_snippet_btn.click(mark_code_snippet_completed, inputs=[level_choice, snippet_dropdown], outputs=[snippet_status]).then(
+        update_dashboard, inputs=[level_choice], 
+        outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview]
+    )
+
+    reset_btn.click(reset_dashboard, outputs=[reset_status]).then(
+        refresh_all, inputs=[level_choice], 
+        outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview, reminders_html, hack_html, intern_html, schol_html]
+    )
+
+    # Study roadmap
+    def show_roadmap(level):
+        r = ROADMAPS.get(level, {})
+        html_block = f"<div style='padding:16px;background:linear-gradient(135deg,#dbeafe,#bde4ff);color:#0b3d91;border-radius:10px;'><h2>{level} - Learning Path</h2>"
+        html_block += f"<h4>Objective</h4><p>{r.get('objective','')}</p>"
+        html_block += "<h4>Subjects</h4><ul>"
+        for sub in r.get('subjects', []):
+            html_block += f"<li>{sub}</li>"
+        html_block += "</ul><h4>Projects</h4><ul>"
+        for proj in r.get('projects', []):
+            html_block += f"<li>{proj}</li>"
+        html_block += "</ul>"
+        html_block += f"<p><strong>Weekly hours:</strong> {r.get('weekly_hours','N/A')}</p></div>"
+        return html_block
+
+    show_roadmap_btn.click(show_roadmap, inputs=[roadmap_level], outputs=[roadmap_html])
+
+    # Opportunities and reminders
+    app.load(lambda: get_upcoming_deadlines_html(), outputs=[opp_overview])
+    app.load(lambda: create_hackathon_interface_html(), outputs=[hack_html])
+    app.load(lambda: create_internship_interface_html(), outputs=[intern_html])
+    app.load(lambda: create_scholarship_interface_html(), outputs=[schol_html])
+    app.load(lambda: get_custom_reminders_html(), outputs=[reminders_html])
+
+    set_reminder_btn.click(set_custom_reminder, inputs=[r_type, r_name, r_date, r_notes], outputs=[set_out]).then(
+        lambda: get_custom_reminders_html(), outputs=[reminders_html]
+    ).then(lambda: get_upcoming_deadlines_html(), outputs=[opp_overview])
+
+    mark_done_btn.click(mark_reminder_completed, inputs=[rem_index], outputs=[rem_action_status]).then(
+        lambda: get_custom_reminders_html(), outputs=[reminders_html]
+    ).then(lambda: get_upcoming_deadlines_html(), outputs=[opp_overview])
+
+    del_btn.click(delete_reminder, inputs=[rem_index], outputs=[rem_action_status]).then(
+        lambda: get_custom_reminders_html(), outputs=[reminders_html]
+    ).then(lambda: get_upcoming_deadlines_html(), outputs=[opp_overview])
+
+    ask_btn.click(ai_mentor_query, inputs=[prompt, short_toggle, eli5_toggle], outputs=[mentor_out])
+
+    # Initial load
+    app.load(lambda: update_dashboard(list(ROADMAPS.keys())[0]), 
+             outputs=[session_dropdown, snippet_dropdown, stats_display, progress_plot, materials_html, code_snippets_html, opp_overview])
+
+# Launch Gradio app
+if __name__ == "__main__":
+    app.launch(share=True)