Update app.py

app.py

@@ -18,7 +18,8 @@ def default_progress_data():
         "total_hours_studied": 0,
         "last_study_date": datetime.now().isoformat(),
         "daily_goals": {},
-        "achievements": []
+        "achievements": [],
+        "code_snippets_completed": {}
     }
 
 def default_opportunities_data():
@@ -205,6 +206,534 @@ ROADMAPS = {
     }
 }
 
+# ---------------- Code Snippets for B.Tech Students ----------------
+CODE_SNIPPETS = {
+    "B.Tech 1st Year": [
+        {
+            "title": "Factorial Calculator",
+            "problem": "Write a C program to calculate factorial of a number using recursion",
+            "code": """#include <stdio.h>
+
+long factorial(int n) {
+    if (n == 0 || n == 1)
+        return 1;
+    else
+        return n * factorial(n - 1);
+}
+
+int main() {
+    int num;
+    printf("Enter a positive integer: ");
+    scanf("%d", &num);
+    
+    if (num < 0)
+        printf("Factorial is not defined for negative numbers.\\n");
+    else
+        printf("Factorial of %d = %ld\\n", num, factorial(num));
+    
+    return 0;
+}""",
+            "explanation": "This program uses recursion to calculate factorial. The base case is when n=0 or n=1, returning 1. Otherwise, it calls itself with n-1.",
+            "video_url": "https://www.youtube.com/embed/4agL-MQq05E"
+        },
+        {
+            "title": "Matrix Multiplication",
+            "problem": "Write a C program for matrix multiplication",
+            "code": """#include <stdio.h>
+
+int main() {
+    int a[10][10], b[10][10], result[10][10];
+    int r1, c1, r2, c2;
+    
+    printf("Enter rows and columns for first matrix: ");
+    scanf("%d %d", &r1, &c1);
+    printf("Enter rows and columns for second matrix: ");
+    scanf("%d %d", &r2, &c2);
+    
+    if (c1 != r2) {
+        printf("Matrix multiplication not possible!\\n");
+        return 0;
+    }
+    
+    printf("Enter elements of matrix 1:\\n");
+    for(int i=0; i<r1; i++)
+        for(int j=0; j<c1; j++)
+            scanf("%d", &a[i][j]);
+    
+    printf("Enter elements of matrix 2:\\n");
+    for(int i=0; i<r2; i++)
+        for(int j=0; j<c2; j++)
+            scanf("%d", &b[i][j]);
+    
+    // Multiply matrices
+    for(int i=0; i<r1; i++) {
+        for(int j=0; j<c2; j++) {
+            result[i][j] = 0;
+            for(int k=0; k<c1; k++)
+                result[i][j] += a[i][k] * b[k][j];
+        }
+    }
+    
+    printf("Result matrix:\\n");
+    for(int i=0; i<r1; i++) {
+        for(int j=0; j<c2; j++)
+            printf("%d\\t", result[i][j]);
+        printf("\\n");
+    }
+    
+    return 0;
+}""",
+            "explanation": "Matrix multiplication requires that columns of first matrix equal rows of second matrix. Uses triple nested loops for calculation.",
+            "video_url": "https://www.youtube.com/embed/jzdQ-5hry98"
+        }
+    ],
+    "B.Tech 2nd Year": [
+        {
+            "title": "Linked List Implementation",
+            "problem": "Implement a singly linked list with insert, delete and display operations",
+            "code": """#include <stdio.h>
+#include <stdlib.h>
+
+struct Node {
+    int data;
+    struct Node* next;
+};
+
+struct Node* createNode(int data) {
+    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
+    newNode->data = data;
+    newNode->next = NULL;
+    return newNode;
+}
+
+void insertAtEnd(struct Node** head, int data) {
+    struct Node* newNode = createNode(data);
+    
+    if (*head == NULL) {
+        *head = newNode;
+        return;
+    }
+    
+    struct Node* temp = *head;
+    while (temp->next != NULL)
+        temp = temp->next;
+    
+    temp->next = newNode;
+}
+
+void deleteNode(struct Node** head, int key) {
+    struct Node *temp = *head, *prev = NULL;
+    
+    if (temp != NULL && temp->data == key) {
+        *head = temp->next;
+        free(temp);
+        return;
+    }
+    
+    while (temp != NULL && temp->data != key) {
+        prev = temp;
+        temp = temp->next;
+    }
+    
+    if (temp == NULL) return;
+    
+    prev->next = temp->next;
+    free(temp);
+}
+
+void displayList(struct Node* head) {
+    struct Node* temp = head;
+    while (temp != NULL) {
+        printf("%d -> ", temp->data);
+        temp = temp->next;
+    }
+    printf("NULL\\n");
+}
+
+int main() {
+    struct Node* head = NULL;
+    
+    insertAtEnd(&head, 10);
+    insertAtEnd(&head, 20);
+    insertAtEnd(&head, 30);
+    
+    printf("Linked list: ");
+    displayList(head);
+    
+    deleteNode(&head, 20);
+    printf("After deleting 20: ");
+    displayList(head);
+    
+    return 0;
+}""",
+            "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"
+        }
+    ]
+}
+
 # ---------------- Opportunities (H/I/S) ----------------
 HACKATHONS = [
     {"name":"Smart India Hackathon 2025","deadline":"2025-09-30","eligibility":"College Students (All Years)","prizes":"₹5 Lakhs + Incubation","skills":["Programming","Problem Solving"],"url":"https://sih.gov.in","category":"National","level":"B.Tech All Years"},
@@ -285,325 +814,4 @@ def mark_session_completed(level, session_title):
 
 def create_dashboard_stats(level):
     p = load_progress()
-    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
-
-# ---------------- 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 = """
-/* Light blue background gradient for the whole app */
-.gradio-container {
-    background: linear-gradient(135deg, #eaf6ff 0%, #d5efff 100%);
-    min-height: 100vh;
-    padding: 24px;
-    color: #0b3d91;
-}
-/* Slightly transparent panels so the light-blue shows through */
-.gradio-container .container {
-    background: rgba(255,255,255,0.04);
-    border-radius: 12px;
-    padding: 16px;
-}
-"""
-
-with gr.Blocks(title="Road2Success — Learning Dashboard (light blue)", 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()
-            gr.Markdown("### Study Materials")
-            with gr.Row():
-                with gr.Column(scale=2):
-                    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")
-                    schedule_html = gr.HTML()
-                    # Reset button
-                    reset_status = gr.Textbox(interactive=False, label="Reset status")
-                    reset_btn = gr.Button("⚠️ Reset Dashboard", variant="danger")
-
-        # 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 used by several handlers
-    def update_dashboard(level):
-        sessions = ROADMAPS.get(level, {}).get("study_sessions", [])
-        session_titles = [s['title'] for s in sessions]
-        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))
-        schedule = "<div style='padding:12px;background:rgba(255,255,255,0.04);border-radius:8px;'><h4>Weekly Plan</h4>"
-        schedule += f"<p>Target: {ROADMAPS.get(level,{}).get('weekly_hours', 'N/A')} hours per week</p>"
-        schedule += f"<p>Focus: {', '.join(ROADMAPS.get(level,{}).get('subjects', []))}</p></div>"
-        materials = get_study_materials_interface(level)
-        opps = get_upcoming_deadlines_html()
-        return gr.update(choices=session_titles, value=(session_titles[0] if session_titles else None)), stats, fig, schedule, materials, opps
-
-    # Helper to refresh multiple UI parts (used after reset)
-    def refresh_all(level):
-        session_update, stats, fig, schedule, materials, 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, stats, fig, schedule, materials, opps, reminders, hack, intern, schol
-
-    # Reset handler
-    def reset_dashboard():
-        save_progress(default_progress_data())
-        save_opportunities(default_opportunities_data())
-        reset_leaderboard()
-        return "✅ Dashboard reset to defaults."
-
-    # Wire events (use inputs rather than .value)
-    level_choice.change(update_dashboard, inputs=[level_choice], outputs=[session_dropdown, stats_display, progress_plot, schedule_html, materials_html, opp_overview])
-    refresh_btn.click(update_dashboard, inputs=[level_choice], outputs=[session_dropdown, stats_display, progress_plot, schedule_html, materials_html, opp_overview])
-    app.load(lambda: update_dashboard(list(ROADMAPS.keys())[0]), outputs=[session_dropdown, stats_display, progress_plot, schedule_html, materials_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, stats_display, progress_plot, schedule_html, materials_html, opp_overview]
-    )
-
-    # Reset button wiring: run reset_dashboard then refresh entire UI
-    reset_btn.click(reset_dashboard, outputs=[reset_status]).then(
-        refresh_all, inputs=[level_choice], outputs=[session_dropdown, stats_display, progress_plot, schedule_html, materials_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 initial loads
-    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])
-
-# Launch Gradio app
-app.launch()
+    sessions = ROADMAPS.get(