Update app.py

app.py

@@ -1,285 +1,375 @@
 import gradio as gr
 import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.animation import FuncAnimation
 from io import BytesIO
-import time
 import networkx as nx
 from collections import deque
+import traceback
 
 class DSAVisualizer:
     def __init__(self):
+        self.reset_state()
+    
+    def reset_state(self):
         self.current_data = []
         self.steps = []
         self.current_step = 0
-        self.pseudocode = ""
+        self.pseudocode = []
         self.active_lines = []
-        self.graph = None
-        self.graph_type = ""
-
+        self.graph_dict = {}
+        self.error_message = ""
+        
     def generate_data(self, data_size=10, data_type="Random"):
-        if data_type == "Random":
-            self.current_data = np.random.randint(1, 100, data_size)
-        elif data_type == "Ascending":
-            self.current_data = np.arange(1, data_size + 1)
-        elif data_type == "Descending":
-            self.current_data = np.arange(data_size, 0, -1)
-        elif data_type == "Nearly Sorted":
-            self.current_data = np.arange(1, data_size + 1)
-            for _ in range(max(1, data_size // 10)):
-                i, j = np.random.randint(0, data_size, 2)
-                self.current_data[i], self.current_data[j] = self.current_data[j], self.current_data[i]
-        return list(self.current_data)
+        try:
+            if data_size < 5:
+                data_size = 5
+            elif data_size > 50:
+                data_size = 50
+                
+            if data_type == "Random":
+                self.current_data = np.random.randint(1, 100, data_size)
+            elif data_type == "Ascending":
+                self.current_data = np.arange(1, data_size + 1)
+            elif data_type == "Descending":
+                self.current_data = np.arange(data_size, 0, -1)
+            elif data_type == "Nearly Sorted":
+                self.current_data = np.arange(1, data_size + 1)
+                for _ in range(max(1, data_size // 10)):
+                    i, j = np.random.randint(0, data_size, 2)
+                    self.current_data[i], self.current_data[j] = self.current_data[j], self.current_data[i]
+            return list(self.current_data)
+        except Exception as e:
+            self.error_message = f"Data generation error: {str(e)}"
+            return []
 
     def bubble_sort(self, arr):
-        n = len(arr)
-        steps = [arr.copy()]
-        pseudocode = [
-            "procedure bubbleSort(A : list)",
-            "    n = length(A)",
-            "    repeat",
-            "        swapped = false",
-            "        for i from 1 to n-1:",
-            "            if A[i-1] > A[i]:",
-            "                swap(A[i-1], A[i])",
-            "                swapped = true",
-            "    until not swapped"
-        ]
-        active_line = [0]
-        
-        swapped = True
-        while swapped:
-            swapped = False
+        try:
+            arr = [int(x) for x in arr]  # Ensure integers
+            n = len(arr)
+            steps = [arr.copy()]
+            pseudocode = [
+                "procedure bubbleSort(A : list)",
+                "    n = length(A)",
+                "    repeat",
+                "        swapped = false",
+                "        for i from 1 to n-1:",
+                "            if A[i-1] > A[i]:",
+                "                swap(A[i-1], A[i])",
+                "                swapped = true",
+                "    until not swapped"
+            ]
+            active_line = [0]
+            
+            swapped = True
+            while swapped:
+                swapped = False
+                for j in range(1, n):
+                    active_line.append(5)
+                    if steps[-1][j-1] > steps[-1][j]:
+                        active_line.append(6)
+                        new_step = steps[-1].copy()
+                        new_step[j-1], new_step[j] = new_step[j], new_step[j-1]
+                        steps.append(new_step)
+                        swapped = True
+                        active_line.append(7)
+                    active_line.append(4)
+                active_line.append(3)
+            
+            return steps, pseudocode, active_line
+        except Exception as e:
+            self.error_message = f"Bubble sort error: {str(e)}"
+            return [], [], []
+
+    def insertion_sort(self, arr):
+        try:
+            arr = [int(x) for x in arr]  # Ensure integers
+            steps = [arr.copy()]
+            pseudocode = [
+                "procedure insertionSort(A : list)",
+                "    for j from 1 to length(A)-1:",
+                "        key = A[j]",
+                "        i = j-1",
+                "        while i >= 0 and A[i] > key:",
+                "            A[i+1] = A[i]",
+                "            i = i-1",
+                "        A[i+1] = key"
+            ]
+            active_line = [0]
+
+            arr = arr.copy()
+            n = len(arr)
             for j in range(1, n):
-                active_line.append(5)
-                if steps[-1][j-1] > steps[-1][j]:
+                active_line.append(1)
+                key = arr[j]
+                active_line.append(2)
+                i = j-1
+                active_line.append(3)
+                while i >= 0 and arr[i] > key:
+                    active_line.append(5)
+                    arr[i+1] = arr[i]
+                    steps.append(arr.copy())
                     active_line.append(6)
-                    new_step = steps[-1].copy()
-                    new_step[j-1], new_step[j] = new_step[j], new_step[j-1]
-                    steps.append(new_step)
-                    swapped = True
-                    active_line.append(7)
-                active_line.append(4)
-            active_line.append(3)
-        
-        return steps, pseudocode, active_line
+                    i = i-1
+                    active_line.append(3)
+                active_line.append(7)
+                arr[i+1] = key
+                steps.append(arr.copy())
+            
+            return steps, pseudocode, active_line
+        except Exception as e:
+            self.error_message = f"Insertion sort error: {str(e)}"
+            return [], [], []
 
     def dfs(self, graph_dict, start):
-        graph = self.parse_graph(graph_dict)
-        visited = set()
-        stack = [start]
-        steps = []
-        pseudocode = [
-            "procedure DFS(G, start):",
-            "    visited = set()",
-            "    stack = [start]",
-            "    while stack not empty:",
-            "        vertex = stack.pop()",
-            "        if vertex not in visited:",
-            "            visited.add(vertex)",
-            "            for neighbor in G[vertex]:",
-            "                if neighbor not in visited:",
-            "                    stack.push(neighbor)"
-        ]
-        active_line = [0]
-        
-        steps.append({"visited": set(), "current": None, "stack": stack.copy(), "graph": graph.copy()})
-        active_line.append(1)
-        
-        while stack:
-            active_line.append(3)
-            vertex = stack.pop()
-            active_line.append(4)
-            if vertex not in visited:
-                active_line.append(5)
-                visited.add(vertex)
-                active_line.append(6)
-                for neighbor in graph.get(vertex, []):
-                    active_line.append(7)
-                    if neighbor not in visited:
-                        stack.append(neighbor)
-                steps.append({"visited": visited.copy(), 
-                              "current": vertex, 
-                              "stack": stack.copy(),
-                              "graph": graph.copy()})
+        try:
+            graph = self.parse_graph(graph_dict)
+            if not graph:
+                return [], [], []
+                
+            visited = set()
+            stack = [start]
+            steps = []
+            pseudocode = [
+                "procedure DFS(G, start):",
+                "    visited = set()",
+                "    stack = [start]",
+                "    while stack not empty:",
+                "        vertex = stack.pop()",
+                "        if vertex not in visited:",
+                "            visited.add(vertex)",
+                "            for neighbor in G[vertex]:",
+                "                if neighbor not in visited:",
+                "                    stack.push(neighbor)"
+            ]
+            active_line = [0]
+            
+            steps.append({"visited": set(), "current": None, "stack": stack.copy(), "graph": graph})
+            active_line.append(1)
+            
+            while stack:
                 active_line.append(3)
-        
-        return steps, pseudocode, active_line
+                vertex = stack.pop()
+                active_line.append(4)
+                if vertex not in visited:
+                    active_line.append(5)
+                    visited.add(vertex)
+                    active_line.append(6)
+                    for neighbor in graph.get(vertex, []):
+                        active_line.append(7)
+                        if neighbor not in visited:
+                            stack.append(neighbor)
+                    steps.append({"visited": visited.copy(), 
+                                  "current": vertex, 
+                                  "stack": stack.copy(),
+                                  "graph": graph})
+                active_line.append(3)
+            
+            return steps, pseudocode, active_line
+        except Exception as e:
+            self.error_message = f"DFS error: {str(e)}"
+            return [], [], []
 
     def bfs(self, graph_dict, start):
-        graph = self.parse_graph(graph_dict)
-        visited = set()
-        queue = deque([start])
-        steps = []
-        pseudocode = [
-            "procedure BFS(G, start):",
-            "    visited = set()",
-            "    queue = deque([start])",
-            "    while queue not empty:",
-            "        vertex = queue.popleft()",
-            "        if vertex not in visited:",
-            "            visited.add(vertex)",
-            "            for neighbor in G[vertex]:",
-            "                if neighbor not in visited:",
-            "                    queue.append(neighbor)"
-        ]
-        active_line = [0]
-        
-        steps.append({"visited": set(), "current": None, "queue": list(queue), "graph": graph.copy()})
-        active_line.append(1)
-        
-        while queue:
-            active_line.append(3)
-            vertex = queue.popleft()
-            active_line.append(4)
-            if vertex not in visited:
-                active_line.append(5)
-                visited.add(vertex)
-                active_line.append(6)
-                for neighbor in graph.get(vertex, []):
-                    active_line.append(7)
-                    if neighbor not in visited:
-                        queue.append(neighbor)
-                steps.append({"visited": visited.copy(), 
-                              "current": vertex, 
-                              "queue": list(queue),
-                              "graph": graph.copy()})
+        try:
+            graph = self.parse_graph(graph_dict)
+            if not graph:
+                return [], [], []
+                
+            visited = set()
+            queue = deque([start])
+            steps = []
+            pseudocode = [
+                "procedure BFS(G, start):",
+                "    visited = set()",
+                "    queue = deque([start])",
+                "    while queue not empty:",
+                "        vertex = queue.popleft()",
+                "        if vertex not in visited:",
+                "            visited.add(vertex)",
+                "            for neighbor in G[vertex]:",
+                "                if neighbor not in visited:",
+                "                    queue.append(neighbor)"
+            ]
+            active_line = [0]
+            
+            steps.append({"visited": set(), "current": None, "queue": list(queue), "graph": graph})
+            active_line.append(1)
+            
+            while queue:
                 active_line.append(3)
-        
-        return steps, pseudocode, active_line
+                vertex = queue.popleft()
+                active_line.append(4)
+                if vertex not in visited:
+                    active_line.append(5)
+                    visited.add(vertex)
+                    active_line.append(6)
+                    for neighbor in graph.get(vertex, []):
+                        active_line.append(7)
+                        if neighbor not in visited:
+                            queue.append(neighbor)
+                    steps.append({"visited": visited.copy(), 
+                                  "current": vertex, 
+                                  "queue": list(queue),
+                                  "graph": graph})
+                active_line.append(3)
+            
+            return steps, pseudocode, active_line
+        except Exception as e:
+            self.error_message = f"BFS error: {str(e)}"
+            return [], [], []
 
-    def visualize_sorting(self, algorithm, arr):
-        if algorithm == "Bubble Sort":
-            self.steps, self.pseudocode, self.active_lines = self.bubble_sort(arr)
-        # Add other sorting algorithms here
-        self.current_step = 0
-        return self.create_plot(), self.create_pseudocode(0)
+    def visualize_sorting(self, algorithm, data):
+        try:
+            # Convert data to list of integers
+            if isinstance(data, str):
+                data = [int(x.strip()) for x in data.strip('[]').split(',') if x.strip()]
+            elif not isinstance(data, list):
+                data = list(data)
+                
+            if algorithm == "Bubble Sort":
+                self.steps, self.pseudocode, self.active_lines = self.bubble_sort(data)
+            elif algorithm == "Insertion Sort":
+                self.steps, self.pseudocode, self.active_lines = self.insertion_sort(data)
+            else:
+                self.error_message = f"Algorithm '{algorithm}' not implemented yet"
+                return None, self.create_pseudocode(0), self.error_message
+                
+            self.current_step = 0
+            return self.create_plot(), self.create_pseudocode(0), ""
+        except Exception as e:
+            self.error_message = f"Visualization error: {str(e)}"
+            return None, "", self.error_message
 
     def visualize_graph(self, algorithm, graph_input, start):
-        if algorithm == "DFS":
-            self.steps, self.pseudocode, self.active_lines = self.dfs(graph_input, start)
-        elif algorithm == "BFS":
-            self.steps, self.pseudocode, self.active_lines = self.bfs(graph_input, start)
-        self.current_step = 0
-        return self.create_graph_plot(), self.create_pseudocode(0)
+        try:
+            self.steps, self.pseudocode, self.active_lines = (
+                self.dfs(graph_input, start) if algorithm == "DFS" 
+                else self.bfs(graph_input, start)
+            )
+            self.current_step = 0
+            return self.create_graph_plot(), self.create_pseudocode(0), ""
+        except Exception as e:
+            self.error_message = f"Graph visualization error: {str(e)}"
+            return None, "", self.error_message
 
     def create_plot(self):
-        fig, ax = plt.subplots(figsize=(10, 6))
-        if self.steps:
-            current_data = self.steps[self.current_step]
-            colors = ['#1f77b4' for _ in current_data]
-            
-            # Highlight recently swapped elements
-            if self.current_step > 0:
-                prev = self.steps[self.current_step-1]
-                for i in range(len(current_data)):
-                    if i < len(prev) and current_data[i] != prev[i]:
-                        colors[i] = '#ff7f0e'
-            
-            # Highlight current comparison
-            if self.current_step < len(self.active_lines):
-                line_num = self.active_lines[self.current_step]
-                if line_num == 5 or line_num == 6:
-                    if self.current_step > 0:
-                        # Find the indices being compared
-                        prev = self.steps[self.current_step-1]
-                        current = self.steps[self.current_step]
-                        diff_indices = [i for i in range(min(len(prev), len(current))) 
-                                       if prev[i] != current[i]]
-                        if diff_indices:
-                            i = diff_indices[0]
-                            colors[i] = '#d62728'
-                            if i+1 < len(colors):
-                                colors[i+1] = '#d62728'
+        try:
+            fig, ax = plt.subplots(figsize=(10, 6))
+            if self.steps and self.current_step < len(self.steps):
+                current_data = self.steps[self.current_step]
+                colors = ['#1f77b4' for _ in current_data]
+                
+                # Highlight recently swapped elements
+                if self.current_step > 0 and self.current_step < len(self.steps):
+                    prev = self.steps[self.current_step-1]
+                    for i in range(len(current_data)):
+                        if i < len(prev) and current_data[i] != prev[i]:
+                            colors[i] = '#ff7f0e'
+                
+                ax.bar(range(len(current_data)), current_data, color=colors)
+                ax.set_title(f'Step {self.current_step}/{len(self.steps)-1}')
+                ax.set_xlabel('Index')
+                ax.set_ylabel('Value')
+                ax.grid(axis='y', linestyle='--', alpha=0.7)
+            else:
+                ax.text(0.5, 0.5, "No data to visualize", 
+                        ha='center', va='center', fontsize=16)
             
-            ax.bar(range(len(current_data)), current_data, color=colors)
-            ax.set_title(f'Sorting Visualization - Step {self.current_step}/{len(self.steps)-1}')
-            ax.set_xlabel('Index')
-            ax.set_ylabel('Value')
-            ax.grid(axis='y', linestyle='--', alpha=0.7)
-        else:
-            ax.text(0.5, 0.5, "No data to visualize", 
-                    ha='center', va='center', fontsize=16)
-        
-        buf = BytesIO()
-        plt.savefig(buf, format='png', dpi=100)
-        plt.close(fig)
-        return buf.getvalue()
+            buf = BytesIO()
+            plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
+            plt.close(fig)
+            return buf.getvalue()
+        except Exception as e:
+            self.error_message = f"Plot creation error: {str(e)}"
+            return None
 
     def create_graph_plot(self):
-        if not self.steps:
+        try:
+            if not self.steps or self.current_step >= len(self.steps):
+                fig, ax = plt.subplots(figsize=(10, 8))
+                ax.text(0.5, 0.5, "No graph data to visualize", 
+                        ha='center', va='center', fontsize=16)
+                buf = BytesIO()
+                plt.savefig(buf, format='png')
+                plt.close(fig)
+                return buf.getvalue()
+                
+            state = self.steps[self.current_step]
+            graph_dict = state["graph"]
+            
+            G = nx.Graph()
+            for node, neighbors in graph_dict.items():
+                for neighbor in neighbors:
+                    if neighbor in graph_dict:  # Ensure neighbor exists
+                        G.add_edge(node, neighbor)
+            
+            # Add isolated nodes
+            for node in graph_dict:
+                if node not in G:
+                    G.add_node(node)
+            
+            pos = nx.spring_layout(G, seed=42)
             fig, ax = plt.subplots(figsize=(10, 8))
-            ax.text(0.5, 0.5, "No graph data to visualize", 
-                    ha='center', va='center', fontsize=16)
+            
+            node_colors = []
+            for node in G.nodes():
+                if node == state.get('current'):
+                    node_colors.append('#d62728')  # Current node
+                elif node in state.get('visited', set()):
+                    node_colors.append('#2ca02c')  # Visited nodes
+                elif node in state.get('stack', []) or node in state.get('queue', []):
+                    node_colors.append('#ff7f0e')  # Nodes in stack/queue
+                else:
+                    node_colors.append('#1f77b4')  # Unexplored nodes
+            
+            nx.draw_networkx_nodes(G, pos, node_size=800, 
+                                   node_color=node_colors, alpha=0.9, ax=ax)
+            nx.draw_networkx_edges(G, pos, width=1.5, alpha=0.5, ax=ax)
+            nx.draw_networkx_labels(G, pos, font_size=12, 
+                                   font_weight='bold', font_color='white', ax=ax)
+            
+            algorithm = "DFS" if 'stack' in state else "BFS"
+            title = f"{algorithm} Traversal - Step {self.current_step}/{len(self.steps)-1}\n"
+            title += f"Current: {state.get('current', 'None')} | "
+            
+            if 'stack' in state:
+                title += f"Stack: {state['stack']}"
+            elif 'queue' in state:
+                title += f"Queue: {state['queue']}"
+                
+            ax.set_title(title, fontsize=14)
+            ax.set_axis_off()
+            
             buf = BytesIO()
-            plt.savefig(buf, format='png')
+            plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
             plt.close(fig)
             return buf.getvalue()
+        except Exception as e:
+            self.error_message = f"Graph plot error: {str(e)}"
+            return None
+
+    def create_pseudocode(self, step):
+        try:
+            if not self.pseudocode or not self.active_lines:
+                return ""
             
-        state = self.steps[self.current_step]
-        graph_dict = state["graph"]
-        
-        G = nx.Graph()
-        for node, neighbors in graph_dict.items():
-            for neighbor in neighbors:
-                G.add_edge(node, neighbor)
-                
-        pos = nx.spring_layout(G, seed=42)
-        fig, ax = plt.subplots(figsize=(10, 8))
-        
-        node_colors = []
-        for node in G.nodes():
-            if node == state['current']:
-                node_colors.append('#d62728')  # Current node
-            elif node in state['visited']:
-                node_colors.append('#2ca02c')  # Visited nodes
-            elif 'stack' in state and node in state['stack']:
-                node_colors.append('#ff7f0e')  # Nodes in stack
-            elif 'queue' in state and node in state['queue']:
-                node_colors.append('#ff7f0e')  # Nodes in queue
+            # Find the active line for this step
+            if step < len(self.active_lines):
+                active_line = self.active_lines[step]
             else:
-                node_colors.append('#1f77b4')  # Unexplored nodes
-        
-        nx.draw_networkx_nodes(G, pos, node_size=800, 
-                               node_color=node_colors, alpha=0.9, ax=ax)
-        nx.draw_networkx_edges(G, pos, width=1.5, alpha=0.5, ax=ax)
-        nx.draw_networkx_labels(G, pos, font_size=12, 
-                               font_weight='bold', font_color='white', ax=ax)
-        
-        algorithm = "DFS" if 'stack' in state else "BFS"
-        title = f"{algorithm} Traversal - Step {self.current_step}/{len(self.steps)-1}\n"
-        title += f"Current: {state['current']} | "
-        if 'stack' in state:
-            title += f"Stack: {state['stack']}"
-        else:
-            title += f"Queue: {state['queue']}"
+                active_line = self.active_lines[-1] if self.active_lines else 0
             
-        ax.set_title(title, fontsize=14)
-        ax.set_axis_off()
-        
-        buf = BytesIO()
-        plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
-        plt.close(fig)
-        return buf.getvalue()
-
-    def create_pseudocode(self, step):
-        if not self.pseudocode or not self.active_lines:
+            html = "<div style='font-family: monospace; background: #2d2d2d; color: #f8f8f2; padding: 15px; border-radius: 8px; line-height: 1.5;'>"
+            for i, line in enumerate(self.pseudocode):
+                if i == active_line:
+                    html += f"<div style='background: #44475a; padding: 8px; border-left: 3px solid #bd93f9;'><b>{line}</b></div>"
+                else:
+                    html += f"<div style='padding: 8px;'>{line}</div>"
+            html += "</div>"
+            return html
+        except Exception as e:
+            self.error_message = f"Pseudocode error: {str(e)}"
             return ""
-        
-        # Find the active line for this step
-        if step < len(self.active_lines):
-            active_line = self.active_lines[step]
-        else:
-            active_line = self.active_lines[-1] if self.active_lines else 0
-        
-        html = "<div style='font-family: \"Fira Code\", monospace; background: #2d2d2d; color: #f8f8f2; padding: 15px; border-radius: 8px; line-height: 1.5;'>"
-        for i, line in enumerate(self.pseudocode):
-            if i == active_line:
-                html += f"<div style='background: #44475a; padding: 8px; border-left: 3px solid #bd93f9;'><b>{line}</b></div>"
-            else:
-                html += f"<div style='padding: 8px;'>{line}</div>"
-        html += "</div>"
-        return html
 
     def next_step(self):
         if self.current_step < len(self.steps) - 1:
@@ -292,25 +382,39 @@ class DSAVisualizer:
         return self.update_display()
     
     def update_display(self):
-        if not self.steps:
-            return None, ""
-        
-        if isinstance(self.steps[0], list):  # Sorting visualization
-            plot = self.create_plot()
-        else:  # Graph visualization
-            plot = self.create_graph_plot()
-        
-        return plot, self.create_pseudocode(self.current_step)
+        try:
+            if not self.steps:
+                return None, "", "No steps available"
+            
+            if isinstance(self.steps[0], list):  # Sorting visualization
+                plot = self.create_plot()
+            else:  # Graph visualization
+                plot = self.create_graph_plot()
+            
+            return plot, self.create_pseudocode(self.current_step), ""
+        except Exception as e:
+            return None, "", f"Update error: {str(e)}"
 
     def parse_graph(self, graph_str):
-        graph = {}
-        for line in graph_str.strip().split('\n'):
-            if ':' in line:
-                node, neighbors = line.split(':', 1)
-                node = node.strip()
-                neighbors = [n.strip() for n in neighbors.split(',') if n.strip()]
-                graph[node] = neighbors
-        return graph
+        try:
+            graph = {}
+            for line in graph_str.strip().split('\n'):
+                if ':' in line:
+                    node, neighbors = line.split(':', 1)
+                    node = node.strip()
+                    if node not in graph:
+                        graph[node] = []
+                    neighbors = [n.strip() for n in neighbors.split(',') if n.strip()]
+                    graph[node].extend(neighbors)
+                    
+                    # Add neighbors that might not be defined yet
+                    for neighbor in neighbors:
+                        if neighbor not in graph:
+                            graph[neighbor] = []
+            return graph
+        except Exception as e:
+            self.error_message = f"Graph parse error: {str(e)}"
+            return {}
 
 # Initialize visualizer
 visualizer = DSAVisualizer()
@@ -323,6 +427,8 @@ custom_css = """
     --accent: #ff4081;
     --dark: #2d2d2d;
     --light: #f8f8f8;
+    --success: #4CAF50;
+    --error: #f44336;
 }
 
 body {
@@ -355,6 +461,7 @@ h1, h2, h3 {
     text-transform: uppercase !important;
     letter-spacing: 0.5px !important;
     transition: all 0.3s ease !important;
+    color: white !important;
 }
 
 .btn-primary:hover {
@@ -374,6 +481,25 @@ h1, h2, h3 {
     border-radius: 12px;
     padding: 20px;
     border: 1px solid rgba(255,255,255,0.1);
+    min-height: 500px;
+}
+
+.error-box {
+    background: var(--error) !important;
+    color: white !important;
+    padding: 10px;
+    border-radius: 8px;
+    margin-top: 10px;
+    font-weight: bold;
+}
+
+.success-box {
+    background: var(--success) !important;
+    color: white !important;
+    padding: 10px;
+    border-radius: 8px;
+    margin-top: 10px;
+    font-weight: bold;
 }
 
 footer {
@@ -400,6 +526,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         </div>
         """)
     
+    # Error display
+    error_output = gr.HTML(visible=False, elem_classes=["error-box"])
+    success_output = gr.HTML(visible=False, elem_classes=["success-box"])
+    
     # Main Content
     with gr.Tab("🧮 Sorting Algorithms"):
         with gr.Row():
@@ -412,12 +542,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
                 data_size = gr.Slider(5, 50, value=10, step=1, label="Data Size")
                 gen_btn = gr.Button("♻️ Generate Data", variant="primary")
                 algorithm = gr.Dropdown(
-                    ["Bubble Sort", "Merge Sort", "Quick Sort", "Insertion Sort"],
+                    ["Bubble Sort", "Insertion Sort"],
                     value="Bubble Sort", label="Algorithm"
                 )
                 sort_btn = gr.Button("▶️ Run Algorithm", variant="primary")
                 
-                data_output = gr.Textbox(label="Generated Data", interactive=False)
+                data_output = gr.Textbox(label="Generated Data", interactive=True)
                 
                 gen_btn.click(
                     visualizer.generate_data, 
@@ -438,7 +568,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         sort_btn.click(
             visualizer.visualize_sorting,
             inputs=[algorithm, data_output],
-            outputs=[plot_output, pseudocode]
+            outputs=[plot_output, pseudocode, error_output]
         )
     
     with gr.Tab("📊 Graph Algorithms"):
@@ -473,7 +603,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         graph_btn.click(
             visualizer.visualize_graph,
             inputs=[algorithm, graph_input, start_node],
-            outputs=[graph_plot, graph_pseudocode]
+            outputs=[graph_plot, graph_pseudocode, error_output]
         )
     
     with gr.Tab("📚 Complexity Analysis"):
@@ -483,6 +613,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         | Algorithm       | Time (Best)   | Time (Avg)    | Time (Worst)  | Space         | Use Cases                     |
         |-----------------|---------------|---------------|---------------|---------------|-------------------------------|
         | **Bubble Sort** | O(n)          | O(n²)         | O(n²)         | O(1)          | Educational, small datasets  |
+        | **Insertion Sort** | O(n)       | O(n²)         | O(n²)         | O(1)          | Small datasets, nearly sorted|
         | **Merge Sort**  | O(n log n)    | O(n log n)    | O(n log n)    | O(n)          | General purpose, stable      |
         | **Quick Sort**  | O(n log n)    | O(n log n)    | O(n²)         | O(log n)      | Large datasets, in-place     |
         | **DFS**         | O(V+E)        | O(V+E)        | O(V+E)        | O(V)          | Pathfinding, cycle detection |
@@ -492,7 +623,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         - **Sorting Algorithms**: 
             - Use **QuickSort** for average-case performance
             - Use **MergeSort** for guaranteed O(n log n) performance
-            - **BubbleSort** is educational but impractical for large data
+            - **BubbleSort** and **InsertionSort** are efficient for small datasets
         
         - **Graph Algorithms**:
             - **DFS** is better for pathfinding in deep graphs
@@ -513,11 +644,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         - Multiple algorithm implementations
         - Pseudocode with execution highlighting
         - Customizable input data
+        - Comprehensive error handling
         - Complexity analysis reference
         
+        **Algorithms Implemented**:
+        - Sorting: Bubble Sort, Insertion Sort
+        - Graph Traversal: DFS, BFS
+        
         **Future Enhancements**:
-        - Add more algorithms (Dijkstra, A*, etc.)
-        - Code generation for implementations
+        - Add more algorithms (Merge Sort, Dijkstra, etc.)
         - Speed control for animations
         - Comparison mode for algorithms
         - Export visualizations as GIF
@@ -526,17 +661,41 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"),
         """)
     
     # Navigation events
-    next_btn.click(visualizer.next_step, outputs=[plot_output, pseudocode])
-    prev_btn.click(visualizer.prev_step, outputs=[plot_output, pseudocode])
-    graph_next.click(visualizer.next_step, outputs=[graph_plot, graph_pseudocode])
-    graph_prev.click(visualizer.prev_step, outputs=[graph_plot, graph_pseudocode])
+    next_btn.click(
+        visualizer.next_step, 
+        outputs=[plot_output, pseudocode, error_output]
+    )
+    prev_btn.click(
+        visualizer.prev_step, 
+        outputs=[plot_output, pseudocode, error_output]
+    )
+    graph_next.click(
+        visualizer.next_step, 
+        outputs=[graph_plot, graph_pseudocode, error_output]
+    )
+    graph_prev.click(
+        visualizer.prev_step, 
+        outputs=[graph_plot, graph_pseudocode, error_output]
+    )
     
     # Footer
     gr.Markdown("""
     <footer>
-        <p>AlgoViz Pro v1.0 | Created with Gradio | For educational purposes</p>
+        <p>AlgoViz Pro v1.1 | Robust & Error-Resistant | For educational purposes</p>
     </footer>
     """)
+    
+    # Error handling display
+    def show_error(error_msg):
+        if error_msg:
+            return gr.update(value=f"⚠️ ERROR: {error_msg}", visible=True)
+        return gr.update(visible=False)
+    
+    error_output.change(
+        show_error, 
+        inputs=[error_output], 
+        outputs=[error_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()