Update app.py

app.py

@@ -2,101 +2,209 @@ import gradio as gr
 import os
 import json
 import time
+import uuid
 from datetime import datetime
 from groq import Groq
 import pandas as pd
 from typing import Dict, List, Tuple, Optional
 import re
-import uuid
+import hashlib
+import sqlite3
+from diagram_generator import DiagramGenerator
+from rag_system import EnhancedRAGSystem
 
-# Initialize Groq client
+# Initialize components
 def get_groq_client():
     api_key = os.getenv("GROQ_API_KEY")
     if not api_key:
         raise ValueError("GROQ_API_KEY environment variable not set")
     return Groq(api_key=api_key)
 
-class PowerSystemsConsultant:
+class UserManager:
     def __init__(self):
-        self.groq_client = get_groq_client()
-        self.knowledge_base = self.load_knowledge_base()
-        self.conversation_history = []
+        self.db_path = 'users.db'
+        self.init_database()
+    
+    def init_database(self):
+        """Initialize SQLite database for users"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                username TEXT UNIQUE NOT NULL,
+                email TEXT UNIQUE NOT NULL,
+                password_hash TEXT NOT NULL,
+                full_name TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_login TIMESTAMP
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS chat_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER,
+                session_id TEXT UNIQUE,
+                title TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users (id)
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT,
+                role TEXT,
+                content TEXT,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (session_id) REFERENCES chat_sessions (session_id)
+            )
+        ''')
         
-    def load_knowledge_base(self):
-        """Load the power systems knowledge base"""
+        conn.commit()
+        conn.close()
+    
+    def hash_password(self, password: str) -> str:
+        """Hash password using SHA-256"""
+        return hashlib.sha256(password.encode()).hexdigest()
+    
+    def create_user(self, username: str, email: str, password: str, full_name: str = "") -> Tuple[bool, str]:
+        """Create new user account"""
         try:
-            with open('data/knowledge_base.json', 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except FileNotFoundError:
-            return self.get_default_knowledge_base()
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            password_hash = self.hash_password(password)
+            cursor.execute(
+                "INSERT INTO users (username, email, password_hash, full_name) VALUES (?, ?, ?, ?)",
+                (username, email, password_hash, full_name)
+            )
+            
+            conn.commit()
+            conn.close()
+            return True, "Account created successfully!"
+            
+        except sqlite3.IntegrityError as e:
+            if "username" in str(e):
+                return False, "Username already exists"
+            elif "email" in str(e):
+                return False, "Email already registered"
+            else:
+                return False, "Registration failed"
+        except Exception as e:
+            return False, f"Error: {str(e)}"
     
-    def get_default_knowledge_base(self):
-        """Default knowledge base with power systems content"""
-        return {
-            "faults": {
-                "symmetrical_faults": {
-                    "description": "Three-phase faults where all phases are equally affected",
-                    "characteristics": "Balanced conditions, easiest to analyze",
-                    "analysis_method": "Single-phase equivalent circuit"
-                },
-                "unsymmetrical_faults": {
-                    "line_to_ground": "Most common fault (70-80% of all faults)",
-                    "line_to_line": "Second most common fault (15-20%)",
-                    "double_line_to_ground": "Less common but severe"
+    def authenticate_user(self, username: str, password: str) -> Tuple[bool, Optional[Dict]]:
+        """Authenticate user login"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            password_hash = self.hash_password(password)
+            cursor.execute(
+                "SELECT id, username, email, full_name FROM users WHERE username = ? AND password_hash = ?",
+                (username, password_hash)
+            )
+            
+            user = cursor.fetchone()
+            
+            if user:
+                # Update last login
+                cursor.execute(
+                    "UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?",
+                    (user[0],)
+                )
+                conn.commit()
+                
+                user_data = {
+                    'id': user[0],
+                    'username': user[1],
+                    'email': user[2],
+                    'full_name': user[3] or user[1]
                 }
-            },
-            "protection": {
-                "overcurrent_protection": "Time-current characteristic curves, coordination",
-                "differential_protection": "Used for transformers, generators, buses",
-                "distance_protection": "Impedance-based protection for transmission lines"
-            },
-            "standards": {
-                "IEEE_standards": ["IEEE C37", "IEEE 1547", "IEEE 519"],
-                "IEC_standards": ["IEC 61850", "IEC 60909", "IEC 61131"]
-            },
-            "diagrams": {
-                "single_line_diagram": "Shows electrical connections and components",
-                "protection_coordination": "Time-current curves for protective devices",
-                "fault_analysis": "Sequence networks for fault calculations"
-            }
-        }
+                conn.close()
+                return True, user_data
+            
+            conn.close()
+            return False, None
+            
+        except Exception as e:
+            return False, None
     
-    def retrieve_relevant_context(self, query: str) -> str:
-        """Simple keyword-based retrieval from knowledge base"""
-        query_lower = query.lower()
-        relevant_info = []
-        
-        # Search through knowledge base
-        for category, content in self.knowledge_base.items():
-            if any(keyword in query_lower for keyword in [category]):
-                if isinstance(content, dict):
-                    for key, value in content.items():
-                        if any(keyword in query_lower for keyword in key.split('_')):
-                            relevant_info.append(f"{category.title()} - {key}: {value}")
-                else:
-                    relevant_info.append(f"{category.title()}: {content}")
-        
-        return "\n".join(relevant_info[:5])  # Limit to top 5 matches
+    def get_user_sessions(self, user_id: int) -> List[Dict]:
+        """Get chat sessions for user"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute(
+                "SELECT session_id, title, created_at FROM chat_sessions WHERE user_id = ? ORDER BY updated_at DESC",
+                (user_id,)
+            )
+            
+            sessions = cursor.fetchall()
+            conn.close()
+            
+            return [
+                {
+                    'session_id': session[0],
+                    'title': session[1] or f"Chat {session[0][:8]}",
+                    'created_at': session[2]
+                }
+                for session in sessions
+            ]
+            
+        except Exception as e:
+            return []
+
+class PowerSystemsConsultant:
+    def __init__(self):
+        self.groq_client = get_groq_client()
+        self.rag_system = EnhancedRAGSystem()
+        self.diagram_generator = DiagramGenerator()
+        self.user_manager = UserManager()
+        self.current_user = None
+        self.current_session = None
     
-    def generate_response(self, user_query: str, chat_history: List[Tuple[str, str]]) -> str:
+    def generate_response(self, user_query: str, chat_history: List[Tuple[str, str]], session_id: str = None) -> Tuple[str, str]:
         """Generate response using Groq LLM with RAG context"""
         try:
+            # Check if query is asking for a diagram
+            diagram_type = self.detect_diagram_request(user_query)
+            diagram_svg = None
+            
+            if diagram_type:
+                diagram_svg = self.generate_diagram(diagram_type, user_query)
+            
             # Retrieve relevant context
-            context = self.retrieve_relevant_context(user_query)
+            context = self.rag_system.retrieve_context(user_query)
             
             # Prepare system prompt
             system_prompt = f"""You are a Power Systems Mini-Consultant AI assistant specializing in electrical power systems. 
             You help with:
             1. Fault analysis and calculations
             2. Protection system design
-            3. Standards interpretation
+            3. Standards interpretation (IEEE, IEC, ANSI)
             4. Study materials and exam preparation
             5. Practice problem generation
+            6. Engineering diagrams and visualizations
             
             Use the following context from the knowledge base:
             {context}
             
-            Provide clear, technical explanations with practical examples. Include relevant formulas, standards references, and safety considerations when appropriate."""
+            Provide clear, technical explanations with practical examples. Include relevant formulas, standards references, and safety considerations when appropriate.
+            
+            If a user asks for diagrams or visual representations, mention that you can generate professional engineering diagrams including:
+            - Single line diagrams
+            - Fault analysis diagrams  
+            - Protection coordination curves
+            - Phasor diagrams
+            - Impedance diagrams
+            """
             
             # Prepare conversation context
             messages = [{"role": "system", "content": system_prompt}]
@@ -117,58 +225,147 @@ class PowerSystemsConsultant:
                 temperature=0.8
             )
             
-            return response.choices[0].message.content
+            text_response = response.choices[0].message.content
+            
+            # Save to database if session exists
+            if session_id and self.current_user:
+                self.save_message(session_id, "user", user_query)
+                self.save_message(session_id, "assistant", text_response)
+            
+            return text_response, diagram_svg
             
         except Exception as e:
-            return f"Error generating response: {str(e)}. Please check your GROQ_API_KEY and try again."
-
-    def generate_practice_pack(self, topic: str, difficulty: str, num_questions: int) -> str:
-        """Generate practice questions for power systems topics"""
+            error_msg = f"Error generating response: {str(e)}. Please check your GROQ_API_KEY and try again."
+            return error_msg, None
+    
+    def detect_diagram_request(self, query: str) -> Optional[str]:
+        """Detect if user is requesting a diagram"""
+        query_lower = query.lower()
+        
+        diagram_keywords = {
+            'single line': 'single_line',
+            'single-line': 'single_line',
+            'fault analysis': 'fault_analysis',
+            'fault diagram': 'fault_analysis',
+            'protection coordination': 'protection_coordination',
+            'coordination curve': 'protection_coordination',
+            'phasor diagram': 'phasor',
+            'phasor': 'phasor',
+            'impedance diagram': 'impedance',
+            'distance protection': 'impedance',
+            'r-x diagram': 'impedance'
+        }
+        
+        for keyword, diagram_type in diagram_keywords.items():
+            if keyword in query_lower:
+                return diagram_type
+        
+        return None
+    
+    def generate_diagram(self, diagram_type: str, query: str) -> str:
+        """Generate appropriate diagram based on type"""
+        try:
+            if diagram_type == 'single_line':
+                return self.diagram_generator.generate_single_line_diagram({})
+            elif diagram_type == 'fault_analysis':
+                fault_type = 'line_to_ground'
+                if 'line to line' in query.lower() or 'l-l' in query.lower():
+                    fault_type = 'line_to_line'
+                elif 'three phase' in query.lower() or '3-phase' in query.lower():
+                    fault_type = 'three_phase'
+                return self.diagram_generator.generate_fault_analysis_diagram(fault_type)
+            elif diagram_type == 'protection_coordination':
+                return self.diagram_generator.generate_protection_coordination_diagram()
+            elif diagram_type == 'phasor':
+                condition = 'balanced'
+                if 'unbalanced' in query.lower() or 'fault' in query.lower():
+                    condition = 'unbalanced'
+                return self.diagram_generator.generate_phasor_diagram(condition)
+            elif diagram_type == 'impedance':
+                return self.diagram_generator.generate_impedance_diagram()
+        except Exception as e:
+            return f"<text>Error generating diagram: {str(e)}</text>"
+        
+        return None
+    
+    def create_chat_session(self, user_id: int, title: str = None) -> str:
+        """Create new chat session"""
+        session_id = str(uuid.uuid4())
+        
         try:
-            prompt = f"""Generate {num_questions} practice questions about {topic} in power systems 
-            with {difficulty} difficulty level. Include:
+            conn = sqlite3.connect(self.user_manager.db_path)
+            cursor = conn.cursor()
             
-            1. Multiple choice questions with 4 options
-            2. Short answer questions
-            3. Calculation problems with given data
-            4. Provide answers and brief explanations
+            cursor.execute(
+                "INSERT INTO chat_sessions (user_id, session_id, title) VALUES (?, ?, ?)",
+                (user_id, session_id, title or f"Chat {datetime.now().strftime('%m/%d %H:%M')}")
+            )
             
-            Format as a structured practice pack suitable for exam preparation."""
+            conn.commit()
+            conn.close()
             
-            response = self.groq_client.chat.completions.create(
-                model="llama3-70b-8192",
-                messages=[{"role": "user", "content": prompt}],
-                max_tokens=2000,
-                temperature=0.8
-            )
+            return session_id
             
-            return response.choices[0].message.content
         except Exception as e:
-            return f"Error generating practice pack: {str(e)}"
-
-    def explain_standard(self, standard_name: str) -> str:
-        """Explain power system standards"""
+            return str(uuid.uuid4())  # Fallback to temporary session
+    
+    def save_message(self, session_id: str, role: str, content: str):
+        """Save message to database"""
         try:
-            prompt = f"""Provide a comprehensive explanation of the {standard_name} standard in power systems.
-            Include:
-            1. Purpose and scope
-            2. Key requirements
-            3. Applications
-            4. Related standards
-            5. Practical implementation notes
+            conn = sqlite3.connect(self.user_manager.db_path)
+            cursor = conn.cursor()
             
-            Keep it technically accurate but accessible."""
+            cursor.execute(
+                "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
+                (session_id, role, content)
+            )
             
-            response = self.groq_client.chat.completions.create(
-                model="llama3-70b-8192",
-                messages=[{"role": "user", "content": prompt}],
-                max_tokens=2000,
-                temperature=0.8
+            # Update session timestamp
+            cursor.execute(
+                "UPDATE chat_sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
+                (session_id,)
             )
             
-            return response.choices[0].message.content
+            conn.commit()
+            conn.close()
+            
         except Exception as e:
-            return f"Error explaining standard: {str(e)}"
+            pass  # Continue without saving if database error
+    
+    def load_chat_history(self, session_id: str) -> List[Tuple[str, str]]:
+        """Load chat history from database"""
+        try:
+            conn = sqlite3.connect(self.user_manager.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute(
+                "SELECT role, content FROM messages WHERE session_id = ? ORDER BY timestamp",
+                (session_id,)
+            )
+            
+            messages = cursor.fetchall()
+            conn.close()
+            
+            # Convert to chat history format
+            history = []
+            current_pair = [None, None]
+            
+            for role, content in messages:
+                if role == "user":
+                    if current_pair[0] is not None:
+                        history.append((current_pair[0], current_pair[1] or ""))
+                    current_pair = [content, None]
+                elif role == "assistant":
+                    current_pair[1] = content
+            
+            # Add the last pair if complete
+            if current_pair[0] is not None:
+                history.append((current_pair[0], current_pair[1] or ""))
+            
+            return history
+            
+        except Exception as e:
+            return []
 
 # Initialize the consultant
 try:
@@ -178,312 +375,411 @@ except Exception as e:
     consultant = None
     initialization_status = f"❌ Initialization failed: {str(e)}"
 
-def chat_interface(message, history):
+# Global state management
+current_user = gr.State(None)
+current_session = gr.State(None)
+chat_sessions = gr.State([])
+
+# UI Functions
+def login_user(username, password):
+    """Handle user login"""
+    if not consultant:
+        return False, None, "System not initialized", gr.update(), gr.update()
+    
+    success, user_data = consultant.user_manager.authenticate_user(username, password)
+    
+    if success:
+        consultant.current_user = user_data
+        sessions = consultant.user_manager.get_user_sessions(user_data['id'])
+        
+        # Create session list for sidebar
+        session_choices = [(f"{s['title']} ({s['created_at'][:10]})", s['session_id']) for s in sessions]
+        
+        return (
+            True, 
+            user_data, 
+            f"Welcome back, {user_data['full_name']}!",
+            gr.update(choices=session_choices, value=session_choices[0][1] if session_choices else None),
+            gr.update(visible=True)
+        )
+    else:
+        return False, None, "Invalid username or password", gr.update(), gr.update()
+
+def register_user(username, email, password, confirm_password, full_name):
+    """Handle user registration"""
+    if not consultant:
+        return False, "System not initialized"
+    
+    if password != confirm_password:
+        return False, "Passwords do not match"
+    
+    if len(password) < 6:
+        return False, "Password must be at least 6 characters"
+    
+    success, message = consultant.user_manager.create_user(username, email, password, full_name)
+    return success, message
+
+def start_new_chat(user_data):
+    """Start a new chat session"""
+    if not consultant or not user_data:
+        return None, []
+    
+    session_id = consultant.create_chat_session(user_data['id'])
+    consultant.current_session = session_id
+    
+    # Update sessions list
+    sessions = consultant.user_manager.get_user_sessions(user_data['id'])
+    session_choices = [(f"{s['title']} ({s['created_at'][:10]})", s['session_id']) for s in sessions]
+    
+    return session_id, session_choices
+
+def load_selected_chat(session_id, user_data):
+    """Load selected chat session"""
+    if not consultant or not session_id:
+        return []
+    
+    consultant.current_session = session_id
+    history = consultant.load_chat_history(session_id)
+    
+    return history
+
+def chat_interface(message, history, user_data, session_id):
     """Main chat interface function"""
-    if consultant is None:
-        return history + [["", "❌ System not initialized. Please check GROQ_API_KEY."]]
+    if not consultant:
+        return history + [["", "❌ System not initialized. Please check GROQ_API_KEY."]], "", None
+    
+    if not user_data:
+        return history + [["", "Please log in to continue."]], "", None
     
     if not message.strip():
-        return history + [[message, "Please enter a question about power systems."]]
+        return history + [[message, "Please enter a question about power systems."]], "", None
     
     try:
-        response = consultant.generate_response(message, history)
-        history = history + [[message, response]]
-        return history
+        # Generate response and potential diagram
+        response, diagram_svg = consultant.generate_response(message, history, session_id)
+        
+        # Update history
+        new_history = history + [[message, response]]
+        
+        return new_history, "", diagram_svg
+        
     except Exception as e:
-        return history + [[message, f"Error: {str(e)}"]]
+        return history + [[message, f"Error: {str(e)}"]], "", None
 
-def generate_practice_questions(topic, difficulty, num_questions):
+def generate_practice_questions(topic, difficulty, num_questions, user_data):
     """Generate practice pack interface"""
-    if consultant is None:
+    if not consultant:
         return "❌ System not initialized. Please check GROQ_API_KEY."
     
+    if not user_data:
+        return "Please log in to access this feature."
+    
     try:
         practice_pack = consultant.generate_practice_pack(topic, difficulty, int(num_questions))
         return practice_pack
     except Exception as e:
         return f"Error generating practice pack: {str(e)}"
 
-def explain_standard_interface(standard):
+def explain_standard_interface(standard, user_data):
     """Standards explanation interface"""
-    if consultant is None:
+    if not consultant:
         return "❌ System not initialized. Please check GROQ_API_KEY."
     
+    if not user_data:
+        return "Please log in to access this feature."
+    
     try:
         explanation = consultant.explain_standard(standard)
         return explanation
     except Exception as e:
         return f"Error explaining standard: {str(e)}"
 
-# Create Gradio interface
-with gr.Blocks(
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="cyan",
-        neutral_hue="slate"
-    ),
-    title="Power Systems Mini-Consultant",
-    css="""
-        .header-text { 
-            text-align: center; 
-            font-size: 2.5em; 
-            font-weight: bold; 
-            color: #1f4e79; 
-            margin-bottom: 0.5em;
-        }
-        .subtitle-text { 
-            text-align: center; 
-            font-size: 1.2em; 
-            color: #666; 
-            margin-bottom: 2em;
-        }
-        .status-box {
-            padding: 1em;
-            border-radius: 8px;
-            margin: 1em 0;
-        }
-        .feature-box {
-            border: 2px solid #e0e7ff;
-            border-radius: 12px;
-            padding: 1.5em;
-            margin: 1em 0;
-            background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
-        }
-    """
-) as app:
-    
-    # Header
-    gr.HTML("""
-        <div class="header-text">⚡ Power Systems Mini-Consultant</div>
-        <div class="subtitle-text">
-            Advanced AI Assistant for Fault Analysis, Protection Systems & Standards
-        </div>
-    """)
-    
-    # Status display
-    gr.HTML(f"""
-        <div class="status-box" style="background-color: {'#d4edda' if '✅' in initialization_status else '#f8d7da'}; 
-                                      color: {'#155724' if '✅' in initialization_status else '#721c24'};">
-            <strong>System Status:</strong> {initialization_status}
-        </div>
-    """)
-    
-    with gr.Tabs():
-        # Main Chat Tab
-        with gr.TabItem("💬 AI Consultant Chat"):
-            gr.HTML("""
-                <div class="feature-box">
-                    <h3>🤖 Intelligent Power Systems Consultant</h3>
-                    <p>Ask questions about fault analysis, protection systems, standards, calculations, and more!</p>
-                    <ul>
-                        <li>Fault analysis and calculations</li>
-                        <li>Protection system design</li>
-                        <li>Standards interpretation (IEEE, IEC)</li>
-                        <li>Study guidance and explanations</li>
-                    </ul>
-                </div>
-            """)
-            
-            chatbot = gr.Chatbot(
-                height=400,
-                placeholder="Your Power Systems AI Consultant will appear here...",
-                show_label=False
-            )
-            
-            msg = gr.Textbox(
-                placeholder="Ask about faults, protection, standards, calculations...",
-                show_label=False,
-                container=False
-            )
-            
-            with gr.Row():
-                submit_btn = gr.Button("Send 📤", variant="primary")
-                clear_btn = gr.Button("Clear Chat 🗑️", variant="secondary")
-            
-            # Example questions
-            gr.HTML("""
-                <div class="feature-box">
-                    <h4>💡 Example Questions:</h4>
-                    <ul>
-                        <li>"Explain symmetrical vs unsymmetrical faults"</li>
-                        <li>"How to calculate short circuit current?"</li>
-                        <li>"What is IEEE C37 standard about?"</li>
-                        <li>"Design overcurrent protection for a 33kV feeder"</li>
-                    </ul>
-                </div>
-            """)
-            
-            submit_btn.click(
-                chat_interface,
-                inputs=[msg, chatbot],
-                outputs=[chatbot]
-            ).then(
-                lambda: "",
-                outputs=[msg]
-            )
-            
-            msg.submit(
-                chat_interface,
-                inputs=[msg, chatbot],
-                outputs=[chatbot]
-            ).then(
-                lambda: "",
-                outputs=[msg]
-            )
-            
-            clear_btn.click(lambda: None, outputs=[chatbot])
+# Create the main application interface
+def create_app():
+    with gr.Blocks(
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="cyan", 
+            neutral_hue="slate"
+        ),
+        title="Power Systems Mini-Consultant",
+        css="""
+            .header-container {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                padding: 2rem;
+                border-radius: 15px;
+                margin-bottom: 2rem;
+                text-align: center;
+            }
+            .header-text { 
+                color: white;
+                font-size: 2.5em; 
+                font-weight: bold; 
+                margin: 0;
+                text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+            }
+            .subtitle-text { 
+                color: rgba(255,255,255,0.9);
+                font-size: 1.2em; 
+                margin: 0.5rem 0 0 0;
+            }
+            .status-box {
+                padding: 1rem;
+                border-radius: 10px;
+                margin: 1rem 0;
+                border-left: 4px solid;
+            }
+            .status-success {
+                background-color: #d4edda;
+                border-color: #28a745;
+                color: #155724;
+            }
+            .status-error {
+                background-color: #f8d7da;
+                border-color: #dc3545;
+                color: #721c24;
+            }
+            .feature-box {
+                background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
+                border: 1px solid #e2e8f0;
+                border-radius: 15px;
+                padding: 1.5rem;
+                margin: 1rem 0;
+                box-shadow: 0 4px 6px rgba(0,0,0,0.05);
+            }
+            .chat-container {
+                border-radius: 15px;
+                border: 1px solid #e2e8f0;
+                overflow: hidden;
+            }
+            .sidebar {
+                background: #f8f9fa;
+                border-right: 1px solid #e2e8f0;
+                min-height: 600px;
+            }
+            .login-container {
+                max-width: 400px;
+                margin: 0 auto;
+                background: white;
+                padding: 2rem;
+                border-radius: 15px;
+                box-shadow: 0 10px 25px rgba(0,0,0,0.1);
+            }
+            .main-content {
+                padding: 2rem;
+            }
+            .diagram-container {
+                border: 2px solid #e2e8f0;
+                border-radius: 10px;
+                padding: 1rem;
+                background: white;
+                margin: 1rem 0;
+            }
+        """
+    ) as app:
         
-        # Practice Pack Generator
-        with gr.TabItem("📚 Practice Pack Generator"):
-            gr.HTML("""
-                <div class="feature-box">
-                    <h3>📝 AI-Generated Practice Questions</h3>
-                    <p>Generate customized practice packs for power systems topics with varying difficulty levels.</p>
-                </div>
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    topic_input = gr.Dropdown(
-                        choices=[
-                            "Fault Analysis", "Protection Systems", "Power Flow",
-                            "Stability Studies", "Relay Coordination", "Transformers",
-                            "Transmission Lines", "Load Flow", "Short Circuit Analysis",
-                            "Harmonics", "Power Quality", "SCADA Systems"
-                        ],
-                        label="📋 Select Topic",
-                        value="Fault Analysis"
-                    )
-                    
-                    difficulty_input = gr.Radio(
-                        choices=["Beginner", "Intermediate", "Advanced"],
-                        label="🎯 Difficulty Level",
-                        value="Intermediate"
-                    )
-                    
-                    num_questions_input = gr.Slider(
-                        minimum=5,
-                        maximum=20,
-                        step=1,
-                        value=10,
-                        label="🔢 Number of Questions"
-                    )
-                    
-                    generate_btn = gr.Button("Generate Practice Pack 🎓", variant="primary")
-                
-                with gr.Column(scale=2):
-                    practice_output = gr.Textbox(
-                        label="📖 Generated Practice Pack",
-                        lines=20,
-                        placeholder="Your practice questions will appear here..."
-                    )
-            
-            generate_btn.click(
-                generate_practice_questions,
-                inputs=[topic_input, difficulty_input, num_questions_input],
-                outputs=[practice_output]
-            )
+        # State management
+        user_state = gr.State(None)
+        session_state = gr.State(None)
+        sessions_state = gr.State([])
         
-        # Standards Explorer
-        with gr.TabItem("📋 Standards Explorer"):
-            gr.HTML("""
-                <div class="feature-box">
-                    <h3>📚 Power Systems Standards Guide</h3>
-                    <p>Get detailed explanations of IEEE, IEC, and other international standards.</p>
-                </div>
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    standard_input = gr.Dropdown(
-                        choices=[
-                            "IEEE C37.2", "IEEE 1547", "IEEE 519", "IEEE C57.12.00",
-                            "IEC 61850", "IEC 60909", "IEC 61131", "IEC 60255",
-                            "ANSI C84.1", "IEEE 242", "IEEE 399", "IEEE C37.010"
-                        ],
-                        label="📑 Select Standard",
-                        value="IEEE C37.2"
-                    )
-                    
-                    explain_btn = gr.Button("Explain Standard 📖", variant="primary")
+        # Header
+        gr.HTML("""
+            <div class="header-container">
+                <h1 class="header-text">⚡ Power Systems Mini-Consultant</h1>
+                <p class="subtitle-text">Advanced AI Assistant for Fault Analysis, Protection Systems & Standards</p>
+            </div>
+        """)
+        
+        # Status display
+        status_class = "status-success" if "✅" in initialization_status else "status-error"
+        gr.HTML(f"""
+            <div class="status-box {status_class}">
+                <strong>System Status:</strong> {initialization_status}
+            </div>
+        """)
+        
+        # Authentication Section
+        with gr.Row():
+            with gr.Column(visible=True) as login_section:
+                gr.HTML("<h2 style='text-align: center; margin-bottom: 2rem;'>🔐 Please Login or Register</h2>")
                 
-                with gr.Column(scale=2):
-                    standard_output = gr.Textbox(
-                        label="📋 Standard Explanation",
-                        lines=15,
-                        placeholder="Standard explanation will appear here..."
-                    )
-            
-            explain_btn.click(
-                explain_standard_interface,
-                inputs=[standard_input],
-                outputs=[standard_output]
-            )
+                with gr.Tabs():
+                    with gr.TabItem("🔑 Login"):
+                        with gr.Column(elem_classes=["login-container"]):
+                            login_username = gr.Textbox(label="Username", placeholder="Enter your username")
+                            login_password = gr.Textbox(label="Password", type="password", placeholder="Enter your password")
+                            login_btn = gr.Button("Login", variant="primary", size="lg")
+                            login_status = gr.Textbox(label="Status", interactive=False)
+                    
+                    with gr.TabItem("📝 Register"):
+                        with gr.Column(elem_classes=["login-container"]):
+                            reg_username = gr.Textbox(label="Username", placeholder="Choose a username")
+                            reg_email = gr.Textbox(label="Email", placeholder="Enter your email")
+                            reg_full_name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
+                            reg_password = gr.Textbox(label="Password", type="password", placeholder="Choose a password (min 6 chars)")
+                            reg_confirm_password = gr.Textbox(label="Confirm Password", type="password", placeholder="Confirm your password")
+                            register_btn = gr.Button("Create Account", variant="primary", size="lg")
+                            register_status = gr.Textbox(label="Status", interactive=False)
         
-        # Study Resources
-        with gr.TabItem("📚 Study Resources"):
-            gr.HTML("""
-                <div class="feature-box">
-                    <h3>📖 Power Systems Study Guide</h3>
-                    <p>Essential formulas, concepts, and quick reference materials.</p>
-                </div>
-            """)
-            
-            with gr.Accordion("⚡ Fault Analysis Formulas", open=False):
-                gr.HTML("""
-                    <h4>Three-Phase Fault Current:</h4>
-                    <p><code>I_fault = V_nominal / Z_total</code></p>
+        # Main Application (hidden initially)
+        with gr.Column(visible=False) as main_section:
+            # User welcome
+            user_welcome = gr.HTML()
+            
+            with gr.Tabs():
+                # Chat Interface Tab
+                with gr.TabItem("💬 AI Consultant Chat"):
+                    with gr.Row():
+                        # Sidebar for chat history
+                        with gr.Column(scale=1, elem_classes=["sidebar"]):
+                            gr.HTML("<h3 style='text-align: center; margin: 1rem 0;'>📜 Chat History</h3>")
+                            new_chat_btn = gr.Button("➕ New Chat", variant="primary", size="sm")
+                            chat_sessions_dropdown = gr.Dropdown(
+                                label="Previous Chats",
+                                choices=[],
+                                value=None,
+                                interactive=True
+                            )
+                        
+                        # Main chat area
+                        with gr.Column(scale=3, elem_classes=["main-content"]):
+                            gr.HTML("""
+                                <div class="feature-box">
+                                    <h3>🤖 Intelligent Power Systems Consultant</h3>
+                                    <p>Ask questions about fault analysis, protection systems, standards, calculations, and more!</p>
+                                </div>
+                            """)
+                            
+                            chatbot = gr.Chatbot(
+                                height=500,
+                                placeholder="Your Power Systems AI Consultant will appear here...",
+                                show_label=False,
+                                elem_classes=["chat-container"]
+                            )
+                            
+                            msg = gr.Textbox(
+                                placeholder="Ask about faults, protection, standards, calculations, or request diagrams...",
+                                show_label=False,
+                                container=False,
+                                scale=4
+                            )
+                            
+                            with gr.Row():
+                                submit_btn = gr.Button("Send 📤", variant="primary", scale=1)
+                                clear_btn = gr.Button("Clear Chat 🗑️", variant="secondary", scale=1)
+                            
+                            # Diagram display
+                            with gr.Column(visible=True):
+                                gr.HTML("<h4>📊 Generated Engineering Diagrams</h4>")
+                                diagram_display = gr.HTML(
+                                    value="<div class='diagram-container'><p style='text-align: center; color: #666;'>Engineering diagrams will appear here when requested.</p></div>",
+                                    elem_classes=["diagram-container"]
+                                )
+                
+                # Practice Pack Generator Tab
+                with gr.TabItem("📚 Practice Pack Generator"):
+                    gr.HTML("""
+                        <div class="feature-box">
+                            <h3>🔬 AI-Generated Practice Questions</h3>
+                            <p>Generate customized practice packs for power systems topics with varying difficulty levels.</p>
+                        </div>
+                    """)
                     
-                    <h4>Line-to-Ground Fault:</h4>
-                    <p><code>I_fault = 3 * V_nominal / (Z1 + Z2 + Z0)</code></p>
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            topic_input = gr.Dropdown(
+                                choices=[
+                                    "Fault Analysis", "Protection Systems", "Power Flow",
+                                    "Stability Studies", "Relay Coordination", "Transformers",
+                                    "Transmission Lines", "Load Flow", "Short Circuit Analysis",
+                                    "Harmonics", "Power Quality", "SCADA Systems"
+                                ],
+                                label="📋 Select Topic",
+                                value="Fault Analysis"
+                            )
+                            
+                            difficulty_input = gr.Radio(
+                                choices=["Beginner", "Intermediate", "Advanced"],
+                                label="🎯 Difficulty Level",
+                                value="Intermediate"
+                            )
+                            
+                            num_questions_input = gr.Slider(
+                                minimum=5,
+                                maximum=20,
+                                step=1,
+                                value=10,
+                                label="🔢 Number of Questions"
+                            )
+                            
+                            generate_btn = gr.Button("Generate Practice Pack 🎯", variant="primary")
+                        
+                        with gr.Column(scale=2):
+                            practice_output = gr.Textbox(
+                                label="📖 Generated Practice Pack",
+                                lines=20,
+                                placeholder="Your practice questions will appear here..."
+                            )
+                
+                # Standards Explorer Tab
+                with gr.TabItem("📋 Standards Explorer"):
+                    gr.HTML("""
+                        <div class="feature-box">
+                            <h3>📚 Power Systems Standards Guide</h3>
+                            <p>Get detailed explanations of IEEE, IEC, and other international standards.</p>
+                        </div>
+                    """)
                     
-                    <h4>Line-to-Line Fault:</h4>
-                    <p><code>I_fault = √3 * V_nominal / (Z1 + Z2)</code></p>
-                """)
-            
-            with gr.Accordion("🛡️ Protection Principles", open=False):
-                gr.HTML("""
-                    <h4>Overcurrent Protection:</h4>
-                    <ul>
-                        <li>Inverse Time Characteristics</li>
-                        <li>Coordination Time Intervals</li>
-                        <li>Pickup Current Settings</li>
-                    </ul>
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            standard_input = gr.Dropdown(
+                                choices=[
+                                    "IEEE C37.2", "IEEE 1547", "IEEE 519", "IEEE C57.12.00",
+                                    "IEC 61850", "IEC 60909", "IEC 61131", "IEC 60255",
+                                    "ANSI C84.1", "IEEE 242", "IEEE 399", "IEEE C37.010"
+                                ],
+                                label="📑 Select Standard",
+                                value="IEEE C37.2"
+                            )
+                            
+                            explain_btn = gr.Button("Explain Standard 📖", variant="primary")
+                        
+                        with gr.Column(scale=2):
+                            standard_output = gr.Textbox(
+                                label="📋 Standard Explanation",
+                                lines=15,
+                                placeholder="Standard explanation will appear here..."
+                            )
+                
+                # Resources Tab
+                with gr.TabItem("📚 Study Resources"):
+                    gr.HTML("""
+                        <div class="feature-box">
+                            <h3>📖 Power Systems Study Guide</h3>
+                            <p>Essential formulas, concepts, and quick reference materials.</p>
+                        </div>
+                    """)
                     
-                    <h4>Distance Protection:</h4>
-                    <ul>
-                        <li>Zone 1: 80-90% of line length</li>
-                        <li>Zone 2: 120% of protected line + 50% of next line</li>
-                        <li>Zone 3: Backup protection</li>
-                    </ul>
-                """)
-            
-            with gr.Accordion("📊 Key Standards Summary", open=False):
-                gr.HTML("""
-                    <h4>IEEE Standards:</h4>
-                    <ul>
-                        <li><strong>IEEE C37:</strong> Circuit breakers and switchgear</li>
-                        <li><strong>IEEE 1547:</strong> Distributed energy resources</li>
-                        <li><strong>IEEE 519:</strong> Harmonic control</li>
-                        <li><strong>IEEE 242:</strong> Protection and coordination</li>
-                    </ul>
+                    with gr.Accordion("⚡ Fault Analysis Formulas", open=False):
+                        gr.HTML("""
+                            <div style='background: #f8f9fa; padding: 1.5rem; border-radius: 8px; margin: 1rem 0;'>
+                                <h4>Three-Phase Fault Current:</h4>
+                                <p><code style='background: #e9ecef; padding: 0.25rem 0.5rem; border-radius: 4px;'>I_fault = V_nominal / Z_total</code></p>
+                                
+                                <h4>Line-to-Ground Fault:</h4>
+                                <p><code style='background: #e9ecef; padding: 0.25rem 0.5rem; border-radius: 4px;'>I_fault = 3 × V_nominal / (Z1 + Z2 + Z0)</code></p>
+                                
+                                <h4>Line-to-Line Fault:</h4>
+                                <p><code style='background: #e9ecef; padding: 0.25rem 0.5rem; border-radius: 4px;'>I_fault = √3 × V_nominal / (Z1 + Z2)</code></p>
+                            </div>
+                        """)
                     
-                    <h4>IEC Standards:</h4>
-                    <ul>
-                        <li><strong>IEC 61850:</strong> Substation automation</li>
-                        <li><strong>IEC 60909:</strong> Short-circuit calculations</li>
-                        <li><strong>IEC 60255:</strong> Protective relays</li>
-                    </ul>
-                """)
-    
-    # Footer
-    gr.HTML("""
-        <div style="text-align: center; margin-top: 2em; padding: 1em; background-color: #f8f9fa; border-radius: 8px;">
-            <p><strong>⚡ Power Systems Mini-Consultant</strong></p>
-            <p>Built with Groq AI • Deployed on Hugging Face Spaces</p>
-            <p><em>For educational and professional use in power systems engineering</em></p>
-        </div>
-    """)
-
-if __name__ == "__main__":
-    app.launch()
+                    with gr.Accordion("🛡️ Protection Principles", open=False):
+                        gr.HTML("""
+                            <div style='background: #f8f9fa; padding: 1.5rem; border-radius: 8px; margin: 1rem 0;'>
+                                <h4>Overcurrent Protection:</h4>
+                                <ul style='margin-left: 1.5rem;'>
+                                    <li>Inverse Time Characteristics</li>
+                                    <li>Coordination Time Intervals (0.2-0.5s)</li>
+                                    <li>Pickup Current Settings (1.25-1.5