azure_design_questions.py


#!/usr/bin/env python3
"""
Azure Design Questions Manager
A GUI application for managing design questions for Azure components
"""

import sqlite3
import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext, filedialog
from datetime import datetime
import os


class AzureDesignQuestionsApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Azure Design Questions Manager")
        self.root.geometry("1400x800")
        
        # Set window close protocol
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        
        # Initialize database
        self.db_path = "azure_design_questions.db"
        self.init_database()
        
        # Create menu bar
        self.create_menu()
        
        # Create main UI
        self.create_widgets()
        
        # Load initial data
        self.refresh_questions_list()
        
    def init_database(self):
        """Initialize SQLite database with required tables"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Check if tables exist and have correct schema
            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
            existing_tables = [row[0] for row in cursor.fetchall()]
            
            # If projects table exists but doesn't have correct schema, we need to recreate
            if 'projects' in existing_tables:
                try:
                    cursor.execute("SELECT id, project_name, description, status FROM projects LIMIT 1")
                except sqlite3.OperationalError:
                    # Schema is outdated, need to recreate
                    print("Upgrading database schema...")
                    cursor.execute("DROP TABLE IF EXISTS project_answers")
                    cursor.execute("DROP TABLE IF EXISTS project_components")
                    cursor.execute("DROP TABLE IF EXISTS projects")
            
            # Create azure_components table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS azure_components (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    component_name TEXT UNIQUE NOT NULL,
                    category TEXT,
                    description TEXT,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            
            # Create design_questions table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS design_questions (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    component_id INTEGER NOT NULL,
                    question_text TEXT NOT NULL,
                    answer_guidance TEXT,
                    priority TEXT DEFAULT 'Medium',
                    tags TEXT,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (component_id) REFERENCES azure_components (id)
                )
            ''')
            
            # Create projects table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS projects (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    project_name TEXT UNIQUE NOT NULL,
                    description TEXT,
                    status TEXT DEFAULT 'Active',
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            
            # Create project_components table (many-to-many relationship)
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS project_components (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    project_id INTEGER NOT NULL,
                    component_id INTEGER NOT NULL,
                    notes TEXT,
                    added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (project_id) REFERENCES projects (id) ON DELETE CASCADE,
                    FOREIGN KEY (component_id) REFERENCES azure_components (id) ON DELETE CASCADE,
                    UNIQUE(project_id, component_id)
                )
            ''')
            
            # Create project_answers table (stores answers to questions within project context)
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS project_answers (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    project_id INTEGER NOT NULL,
                    question_id INTEGER NOT NULL,
                    answer_text TEXT,
                    answered_by TEXT,
                    answered_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (project_id) REFERENCES projects (id) ON DELETE CASCADE,
                    FOREIGN KEY (question_id) REFERENCES design_questions (id) ON DELETE CASCADE,
                    UNIQUE(project_id, question_id)
                )
            ''')
            
            # Insert default Azure components if table is empty
            cursor.execute("SELECT COUNT(*) FROM azure_components")
            if cursor.fetchone()[0] == 0:
                default_components = [
                    ("Azure SQL Database", "Database", "Managed relational database service"),
                    ("Azure Function App", "Compute", "Serverless compute service"),
                    ("Azure Key Vault", "Security", "Secrets management service"),
                    ("Azure Storage Account", "Storage", "Cloud storage solution"),
                    ("Azure App Service", "Compute", "Web app hosting service"),
                    ("Azure Cosmos DB", "Database", "NoSQL database service"),
                    ("Azure Service Bus", "Integration", "Message broker service"),
                    ("Azure API Management", "Integration", "API gateway service"),
                    ("Azure Virtual Network", "Networking", "Virtual network infrastructure"),
                    ("Azure Application Insights", "Monitoring", "Application performance monitoring"),
                    ("Azure Container Registry", "Containers", "Container image registry"),
                    ("Azure Kubernetes Service", "Containers", "Managed Kubernetes service"),
                    ("Azure Logic Apps", "Integration", "Workflow automation service"),
                    ("Azure Event Grid", "Integration", "Event routing service"),
                    ("Azure Redis Cache", "Cache", "In-memory data store")
                ]
                cursor.executemany(
                    "INSERT INTO azure_components (component_name, category, description) VALUES (?, ?, ?)",
                    default_components
                )
            
            conn.commit()
            conn.close()
            
        except Exception as e:
            print(f"Database initialization error: {e}")
            print(f"If you see 'no such column' errors, delete {self.db_path} and restart the application.")
            raise
    
    def create_menu(self):
        """Create the menu bar"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # File menu
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="File", menu=file_menu)
        file_menu.add_command(label="Export Project Report...", command=self.export_project_report_menu, accelerator="Ctrl+E")
        file_menu.add_separator()
        file_menu.add_command(label="Exit", command=self.on_closing, accelerator="Alt+F4")
        
        # Edit menu
        edit_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Edit", menu=edit_menu)
        edit_menu.add_command(label="Add Component", command=self.add_component)
        edit_menu.add_command(label="Add Question", command=self.add_question)
        edit_menu.add_separator()
        edit_menu.add_command(label="New Project", command=self.add_project)
        
        # Help menu
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Help", menu=help_menu)
        help_menu.add_command(label="About", command=self.show_about)
        
        # Bind keyboard shortcuts
        self.root.bind('<Control-e>', lambda e: self.export_project_report_menu())
    
    def on_closing(self):
        """Handle window close event"""
        if messagebox.askokcancel("Quit", "Do you want to exit Azure Design Questions Manager?"):
            self.root.destroy()
    
    def export_project_report_menu(self):
        """Export report from menu - checks if project is selected"""
        if hasattr(self, 'current_project_id'):
            self.export_project_report()
        else:
            messagebox.showinfo("Info", 
                "Please select a project in the Projects tab, then click Export Report.")
    
    def show_about(self):
        """Show about dialog"""
        about_text = """Azure Design Questions Manager
Version 2.1

A comprehensive tool for managing design questions 
and architecture reviews for Azure solutions.

Features:
• Component library management
• Design questions library
• Project management
• Q&A tracking
• Report generation

© 2025 - Educational Use"""
        
        messagebox.showinfo("About", about_text)
    
    def create_widgets(self):
        """Create all GUI widgets"""
        # Create notebook (tabbed interface)
        self.notebook = ttk.Notebook(self.root)
        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Create Components/Questions tab
        self.components_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.components_tab, text="Components & Questions")
        self.create_components_tab()
        
        # Create Projects tab
        self.projects_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.projects_tab, text="Projects")
        self.create_projects_tab()
        
        # Status bar
        self.status_var = tk.StringVar()
        self.status_var.set("Ready")
        status_bar = ttk.Label(self.root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def create_components_tab(self):
        """Create the components and questions management interface"""
        # Create main container with paned window
        main_paned = ttk.PanedWindow(self.components_tab, orient=tk.HORIZONTAL)
        main_paned.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Left panel - Components list
        left_frame = ttk.Frame(main_paned)
        main_paned.add(left_frame, weight=1)
        
        # Components section
        ttk.Label(left_frame, text="Azure Components", font=("Arial", 12, "bold")).pack(pady=5)
        
        # Search box for components
        search_frame = ttk.Frame(left_frame)
        search_frame.pack(fill=tk.X, padx=5, pady=5)
        ttk.Label(search_frame, text="Search:").pack(side=tk.LEFT)
        self.component_search_var = tk.StringVar()
        self.component_search_var.trace("w", self.filter_components)
        ttk.Entry(search_frame, textvariable=self.component_search_var).pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
        
        # Components listbox
        list_frame = ttk.Frame(left_frame)
        list_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        scrollbar = ttk.Scrollbar(list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.components_listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, font=("Arial", 10))
        self.components_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.config(command=self.components_listbox.yview)
        self.components_listbox.bind("<<ListboxSelect>>", self.on_component_select)
        
        # Component management buttons
        comp_btn_frame = ttk.Frame(left_frame)
        comp_btn_frame.pack(fill=tk.X, padx=5, pady=5)
        ttk.Button(comp_btn_frame, text="Add Component", command=self.add_component).pack(side=tk.LEFT, padx=2)
        ttk.Button(comp_btn_frame, text="Edit Component", command=self.edit_component).pack(side=tk.LEFT, padx=2)
        ttk.Button(comp_btn_frame, text="Delete Component", command=self.delete_component).pack(side=tk.LEFT, padx=2)
        
        # Right panel - Questions
        right_frame = ttk.Frame(main_paned)
        main_paned.add(right_frame, weight=2)
        
        # Questions header
        header_frame = ttk.Frame(right_frame)
        header_frame.pack(fill=tk.X, pady=5)
        ttk.Label(header_frame, text="Design Questions", font=("Arial", 12, "bold")).pack(side=tk.LEFT, padx=5)
        
        # Question buttons
        btn_frame = ttk.Frame(header_frame)
        btn_frame.pack(side=tk.RIGHT, padx=5)
        ttk.Button(btn_frame, text="Add Question", command=self.add_question).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="Edit Question", command=self.edit_question).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="Delete Question", command=self.delete_question).pack(side=tk.LEFT, padx=2)
        
        # Questions treeview
        tree_frame = ttk.Frame(right_frame)
        tree_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        # Scrollbars for treeview
        tree_scroll_y = ttk.Scrollbar(tree_frame)
        tree_scroll_y.pack(side=tk.RIGHT, fill=tk.Y)
        tree_scroll_x = ttk.Scrollbar(tree_frame, orient=tk.HORIZONTAL)
        tree_scroll_x.pack(side=tk.BOTTOM, fill=tk.X)
        
        # Create treeview
        self.questions_tree = ttk.Treeview(
            tree_frame,
            columns=("ID", "Question", "Priority", "Tags", "Created"),
            show="tree headings",
            yscrollcommand=tree_scroll_y.set,
            xscrollcommand=tree_scroll_x.set
        )
        self.questions_tree.pack(fill=tk.BOTH, expand=True)
        tree_scroll_y.config(command=self.questions_tree.yview)
        tree_scroll_x.config(command=self.questions_tree.xview)
        
        # Configure columns
        self.questions_tree.column("#0", width=0, stretch=False)
        self.questions_tree.column("ID", width=50, anchor=tk.CENTER)
        self.questions_tree.column("Question", width=400, anchor=tk.W)
        self.questions_tree.column("Priority", width=80, anchor=tk.CENTER)
        self.questions_tree.column("Tags", width=150, anchor=tk.W)
        self.questions_tree.column("Created", width=150, anchor=tk.CENTER)
        
        # Configure headings
        self.questions_tree.heading("ID", text="ID")
        self.questions_tree.heading("Question", text="Question")
        self.questions_tree.heading("Priority", text="Priority")
        self.questions_tree.heading("Tags", text="Tags")
        self.questions_tree.heading("Created", text="Created")
        
        # Bind double-click to edit
        self.questions_tree.bind("<Double-1>", lambda e: self.edit_question())
        
        # Load components
        self.load_components()
    
    def create_projects_tab(self):
        """Create the projects management interface"""
        # Main horizontal paned window
        main_paned = ttk.PanedWindow(self.projects_tab, orient=tk.HORIZONTAL)
        main_paned.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Left panel - Projects list
        left_frame = ttk.Frame(main_paned)
        main_paned.add(left_frame, weight=1)
        
        # Projects header
        ttk.Label(left_frame, text="Projects", font=("Arial", 12, "bold")).pack(pady=5)
        
        # Projects listbox with scrollbar
        list_frame = ttk.Frame(left_frame)
        list_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        scrollbar = ttk.Scrollbar(list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.projects_listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, font=("Arial", 10))
        self.projects_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.config(command=self.projects_listbox.yview)
        self.projects_listbox.bind("<<ListboxSelect>>", self.on_project_select)
        
        # Project management buttons
        proj_btn_frame = ttk.Frame(left_frame)
        proj_btn_frame.pack(fill=tk.X, padx=5, pady=5)
        ttk.Button(proj_btn_frame, text="New Project", command=self.add_project).pack(side=tk.LEFT, padx=2)
        ttk.Button(proj_btn_frame, text="Edit Project", command=self.edit_project).pack(side=tk.LEFT, padx=2)
        ttk.Button(proj_btn_frame, text="Delete Project", command=self.delete_project).pack(side=tk.LEFT, padx=2)
        
        # Right panel - Project details (notebook for components and Q&A)
        right_frame = ttk.Frame(main_paned)
        main_paned.add(right_frame, weight=2)
        
        # Project details notebook
        self.project_notebook = ttk.Notebook(right_frame)
        self.project_notebook.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # Components tab
        components_frame = ttk.Frame(self.project_notebook)
        self.project_notebook.add(components_frame, text="Components")
        
        # Components header and buttons
        comp_header = ttk.Frame(components_frame)
        comp_header.pack(fill=tk.X, pady=5, padx=5)
        ttk.Label(comp_header, text="Project Components", font=("Arial", 11, "bold")).pack(side=tk.LEFT)
        comp_btn = ttk.Frame(comp_header)
        comp_btn.pack(side=tk.RIGHT)
        ttk.Button(comp_btn, text="Add Component", command=self.add_component_to_project).pack(side=tk.LEFT, padx=2)
        ttk.Button(comp_btn, text="Remove Component", command=self.remove_component_from_project).pack(side=tk.LEFT, padx=2)
        
        # Project components treeview
        proj_comp_frame = ttk.Frame(components_frame)
        proj_comp_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        proj_comp_scroll = ttk.Scrollbar(proj_comp_frame)
        proj_comp_scroll.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.project_components_tree = ttk.Treeview(
            proj_comp_frame,
            columns=("ID", "Component", "Category", "Notes"),
            show="tree headings",
            yscrollcommand=proj_comp_scroll.set
        )
        self.project_components_tree.pack(fill=tk.BOTH, expand=True)
        proj_comp_scroll.config(command=self.project_components_tree.yview)
        
        self.project_components_tree.column("#0", width=0, stretch=False)
        self.project_components_tree.column("ID", width=50, anchor=tk.CENTER)
        self.project_components_tree.column("Component", width=200, anchor=tk.W)
        self.project_components_tree.column("Category", width=120, anchor=tk.W)
        self.project_components_tree.column("Notes", width=300, anchor=tk.W)
        
        self.project_components_tree.heading("ID", text="ID")
        self.project_components_tree.heading("Component", text="Component")
        self.project_components_tree.heading("Category", text="Category")
        self.project_components_tree.heading("Notes", text="Notes")
        
        # Questions & Answers tab
        qa_frame = ttk.Frame(self.project_notebook)
        self.project_notebook.add(qa_frame, text="Questions & Answers")
        
        # Q&A header
        qa_header = ttk.Frame(qa_frame)
        qa_header.pack(fill=tk.X, pady=5, padx=5)
        ttk.Label(qa_header, text="Design Questions & Answers", font=("Arial", 11, "bold")).pack(side=tk.LEFT)
        
        # Filter by component
        filter_frame = ttk.Frame(qa_header)
        filter_frame.pack(side=tk.RIGHT)
        ttk.Label(filter_frame, text="Component:").pack(side=tk.LEFT, padx=2)
        self.qa_filter_var = tk.StringVar(value="All")
        self.qa_filter_combo = ttk.Combobox(filter_frame, textvariable=self.qa_filter_var, width=20, state="readonly")
        self.qa_filter_combo.pack(side=tk.LEFT, padx=2)
        self.qa_filter_combo.bind("<<ComboboxSelected>>", self.filter_project_questions)
        
        # Q&A treeview
        qa_tree_frame = ttk.Frame(qa_frame)
        qa_tree_frame.pack(fill=tk.BOTH, expand=True, padx=5)
        
        qa_scroll_y = ttk.Scrollbar(qa_tree_frame)
        qa_scroll_y.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.project_qa_tree = ttk.Treeview(
            qa_tree_frame,
            columns=("Q_ID", "Component", "Question", "Answer", "Status", "Answered By"),
            show="tree headings",
            yscrollcommand=qa_scroll_y.set
        )
        self.project_qa_tree.pack(fill=tk.BOTH, expand=True)
        qa_scroll_y.config(command=self.project_qa_tree.yview)
        
        self.project_qa_tree.column("#0", width=0, stretch=False)
        self.project_qa_tree.column("Q_ID", width=50, anchor=tk.CENTER)
        self.project_qa_tree.column("Component", width=150, anchor=tk.W)
        self.project_qa_tree.column("Question", width=300, anchor=tk.W)
        self.project_qa_tree.column("Answer", width=200, anchor=tk.W)
        self.project_qa_tree.column("Status", width=100, anchor=tk.CENTER)
        self.project_qa_tree.column("Answered By", width=120, anchor=tk.W)
        
        self.project_qa_tree.heading("Q_ID", text="Q ID")
        self.project_qa_tree.heading("Component", text="Component")
        self.project_qa_tree.heading("Question", text="Question")
        self.project_qa_tree.heading("Answer", text="Answer")
        self.project_qa_tree.heading("Status", text="Status")
        self.project_qa_tree.heading("Answered By", text="Answered By")
        
        # Bind double-click to answer question
        self.project_qa_tree.bind("<Double-1>", lambda e: self.answer_project_question())
        
        # Q&A buttons
        qa_btn_frame = ttk.Frame(qa_frame)
        qa_btn_frame.pack(fill=tk.X, padx=5, pady=5)
        ttk.Button(qa_btn_frame, text="Answer Question", command=self.answer_project_question).pack(side=tk.LEFT, padx=2)
        ttk.Button(qa_btn_frame, text="View/Edit Answer", command=self.answer_project_question).pack(side=tk.LEFT, padx=2)
        ttk.Button(qa_btn_frame, text="Export Report", command=self.export_project_report).pack(side=tk.LEFT, padx=2)
        
        # Load projects
        self.load_projects()
    
    def load_components(self):
        """Load all Azure components into the listbox"""
        self.components_listbox.delete(0, tk.END)
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT id, component_name, category FROM azure_components ORDER BY component_name")
        self.components_data = cursor.fetchall()
        conn.close()
        
        for comp_id, name, category in self.components_data:
            display_text = f"{name} ({category})" if category else name
            self.components_listbox.insert(tk.END, display_text)
    
    def filter_components(self, *args):
        """Filter components based on search text"""
        search_text = self.component_search_var.get().lower()
        self.components_listbox.delete(0, tk.END)
        
        for comp_id, name, category in self.components_data:
            if search_text in name.lower() or (category and search_text in category.lower()):
                display_text = f"{name} ({category})" if category else name
                self.components_listbox.insert(tk.END, display_text)
    
    def on_component_select(self, event):
        """Handle component selection"""
        selection = self.components_listbox.curselection()
        if selection:
            index = selection[0]
            # Find the actual component from filtered results
            display_text = self.components_listbox.get(index)
            for comp_id, name, category in self.components_data:
                expected_text = f"{name} ({category})" if category else name
                if expected_text == display_text:
                    self.current_component_id = comp_id
                    self.refresh_questions_list()
                    break
    
    def refresh_questions_list(self):
        """Refresh the questions treeview"""
        # Clear existing items
        for item in self.questions_tree.get_children():
            self.questions_tree.delete(item)
        
        if not hasattr(self, 'current_component_id'):
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT id, question_text, priority, tags, created_at
            FROM design_questions
            WHERE component_id = ?
            ORDER BY created_at DESC
        ''', (self.current_component_id,))
        
        questions = cursor.fetchall()
        conn.close()
        
        for question in questions:
            q_id, text, priority, tags, created = question
            # Truncate long question text for display
            display_text = text[:100] + "..." if len(text) > 100 else text
            created_date = created.split()[0] if created else ""
            self.questions_tree.insert("", tk.END, values=(q_id, display_text, priority, tags or "", created_date))
        
        # Update status
        count = len(questions)
        self.status_var.set(f"Showing {count} question(s)")
    
    def add_component(self):
        """Add a new Azure component"""
        dialog = ComponentDialog(self.root, "Add Azure Component")
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            name, category, description = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute(
                    "INSERT INTO azure_components (component_name, category, description) VALUES (?, ?, ?)",
                    (name, category, description)
                )
                conn.commit()
                conn.close()
                self.load_components()
                messagebox.showinfo("Success", "Component added successfully!")
            except sqlite3.IntegrityError:
                messagebox.showerror("Error", "A component with this name already exists!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to add component: {str(e)}")
    
    def edit_component(self):
        """Edit selected component"""
        selection = self.components_listbox.curselection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a component to edit!")
            return
        
        if not hasattr(self, 'current_component_id'):
            return
        
        # Get current component data
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute(
            "SELECT component_name, category, description FROM azure_components WHERE id = ?",
            (self.current_component_id,)
        )
        current_data = cursor.fetchone()
        conn.close()
        
        dialog = ComponentDialog(self.root, "Edit Azure Component", current_data)
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            name, category, description = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute(
                    "UPDATE azure_components SET component_name = ?, category = ?, description = ? WHERE id = ?",
                    (name, category, description, self.current_component_id)
                )
                conn.commit()
                conn.close()
                self.load_components()
                messagebox.showinfo("Success", "Component updated successfully!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to update component: {str(e)}")
    
    def delete_component(self):
        """Delete selected component"""
        selection = self.components_listbox.curselection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a component to delete!")
            return
        
        if not hasattr(self, 'current_component_id'):
            return
        
        # Check if component has questions
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT COUNT(*) FROM design_questions WHERE component_id = ?", (self.current_component_id,))
        count = cursor.fetchone()[0]
        
        if count > 0:
            if not messagebox.askyesno("Confirm Delete", 
                f"This component has {count} question(s). Delete anyway?"):
                conn.close()
                return
        
        cursor.execute("DELETE FROM design_questions WHERE component_id = ?", (self.current_component_id,))
        cursor.execute("DELETE FROM azure_components WHERE id = ?", (self.current_component_id,))
        conn.commit()
        conn.close()
        
        self.load_components()
        self.refresh_questions_list()
        messagebox.showinfo("Success", "Component deleted successfully!")
    
    def add_question(self):
        """Add a new design question"""
        if not hasattr(self, 'current_component_id'):
            messagebox.showwarning("Warning", "Please select a component first!")
            return
        
        dialog = QuestionDialog(self.root, "Add Design Question")
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            question, answer, priority, tags = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute('''
                    INSERT INTO design_questions 
                    (component_id, question_text, answer_guidance, priority, tags)
                    VALUES (?, ?, ?, ?, ?)
                ''', (self.current_component_id, question, answer, priority, tags))
                conn.commit()
                conn.close()
                self.refresh_questions_list()
                messagebox.showinfo("Success", "Question added successfully!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to add question: {str(e)}")
    
    def edit_question(self):
        """Edit selected question"""
        selection = self.questions_tree.selection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a question to edit!")
            return
        
        item = self.questions_tree.item(selection[0])
        question_id = item['values'][0]
        
        # Get current question data
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT question_text, answer_guidance, priority, tags
            FROM design_questions WHERE id = ?
        ''', (question_id,))
        current_data = cursor.fetchone()
        conn.close()
        
        dialog = QuestionDialog(self.root, "Edit Design Question", current_data)
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            question, answer, priority, tags = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute('''
                    UPDATE design_questions
                    SET question_text = ?, answer_guidance = ?, priority = ?, tags = ?,
                        updated_at = CURRENT_TIMESTAMP
                    WHERE id = ?
                ''', (question, answer, priority, tags, question_id))
                conn.commit()
                conn.close()
                self.refresh_questions_list()
                messagebox.showinfo("Success", "Question updated successfully!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to update question: {str(e)}")
    
    def delete_question(self):
        """Delete selected question"""
        selection = self.questions_tree.selection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a question to delete!")
            return
        
        if not messagebox.askyesno("Confirm Delete", "Are you sure you want to delete this question?"):
            return
        
        item = self.questions_tree.item(selection[0])
        question_id = item['values'][0]
        
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            cursor.execute("DELETE FROM design_questions WHERE id = ?", (question_id,))
            conn.commit()
            conn.close()
            self.refresh_questions_list()
            messagebox.showinfo("Success", "Question deleted successfully!")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to delete question: {str(e)}")
    
    # ========== Project Management Methods ==========
    
    def load_projects(self):
        """Load all projects into the listbox"""
        self.projects_listbox.delete(0, tk.END)
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT id, project_name, status FROM projects 
            ORDER BY project_name
        ''')
        self.projects_data = cursor.fetchall()
        conn.close()
        
        for proj_id, name, status in self.projects_data:
            display_text = f"{name} [{status}]"
            self.projects_listbox.insert(tk.END, display_text)
    
    def on_project_select(self, event):
        """Handle project selection"""
        selection = self.projects_listbox.curselection()
        if selection:
            index = selection[0]
            self.current_project_id = self.projects_data[index][0]
            self.refresh_project_components()
            self.refresh_project_questions()
    
    def add_project(self):
        """Add a new project"""
        dialog = ProjectDialog(self.root, "Add New Project")
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            name, description, status = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute(
                    "INSERT INTO projects (project_name, description, status) VALUES (?, ?, ?)",
                    (name, description, status)
                )
                conn.commit()
                conn.close()
                self.load_projects()
                messagebox.showinfo("Success", "Project added successfully!")
            except sqlite3.IntegrityError:
                messagebox.showerror("Error", "A project with this name already exists!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to add project: {str(e)}")
    
    def edit_project(self):
        """Edit selected project"""
        selection = self.projects_listbox.curselection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a project to edit!")
            return
        
        if not hasattr(self, 'current_project_id'):
            return
        
        # Get current project data
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute(
            "SELECT project_name, description, status FROM projects WHERE id = ?",
            (self.current_project_id,)
        )
        current_data = cursor.fetchone()
        conn.close()
        
        dialog = ProjectDialog(self.root, "Edit Project", current_data)
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            name, description, status = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute(
                    "UPDATE projects SET project_name = ?, description = ?, status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                    (name, description, status, self.current_project_id)
                )
                conn.commit()
                conn.close()
                self.load_projects()
                messagebox.showinfo("Success", "Project updated successfully!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to update project: {str(e)}")
    
    def delete_project(self):
        """Delete selected project"""
        selection = self.projects_listbox.curselection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a project to delete!")
            return
        
        if not hasattr(self, 'current_project_id'):
            return
        
        if not messagebox.askyesno("Confirm Delete", 
            "Are you sure you want to delete this project? All associated data will be removed."):
            return
        
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            cursor.execute("DELETE FROM projects WHERE id = ?", (self.current_project_id,))
            conn.commit()
            conn.close()
            
            self.load_projects()
            self.refresh_project_components()
            self.refresh_project_questions()
            messagebox.showinfo("Success", "Project deleted successfully!")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to delete project: {str(e)}")
    
    def refresh_project_components(self):
        """Refresh the project components list"""
        # Clear existing items
        for item in self.project_components_tree.get_children():
            self.project_components_tree.delete(item)
        
        if not hasattr(self, 'current_project_id'):
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT ac.id, ac.component_name, ac.category, pc.notes
            FROM project_components pc
            JOIN azure_components ac ON pc.component_id = ac.id
            WHERE pc.project_id = ?
            ORDER BY ac.component_name
        ''', (self.current_project_id,))
        
        components = cursor.fetchall()
        conn.close()
        
        for comp_id, name, category, notes in components:
            notes_display = (notes[:50] + "...") if notes and len(notes) > 50 else (notes or "")
            self.project_components_tree.insert("", tk.END, values=(comp_id, name, category or "", notes_display))
        
        # Update filter combo in Q&A tab
        self.update_qa_filter_combo()
    
    def update_qa_filter_combo(self):
        """Update the component filter combo box in Q&A tab"""
        if not hasattr(self, 'current_project_id'):
            self.qa_filter_combo['values'] = ["All"]
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT DISTINCT ac.component_name
            FROM project_components pc
            JOIN azure_components ac ON pc.component_id = ac.id
            WHERE pc.project_id = ?
            ORDER BY ac.component_name
        ''', (self.current_project_id,))
        
        components = [row[0] for row in cursor.fetchall()]
        conn.close()
        
        self.qa_filter_combo['values'] = ["All"] + components
        self.qa_filter_var.set("All")
    
    def add_component_to_project(self):
        """Add a component to the current project"""
        if not hasattr(self, 'current_project_id'):
            messagebox.showwarning("Warning", "Please select a project first!")
            return
        
        dialog = AddComponentToProjectDialog(self.root, self.db_path, self.current_project_id)
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            component_id, notes = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                cursor.execute(
                    "INSERT INTO project_components (project_id, component_id, notes) VALUES (?, ?, ?)",
                    (self.current_project_id, component_id, notes)
                )
                conn.commit()
                conn.close()
                self.refresh_project_components()
                self.refresh_project_questions()
                messagebox.showinfo("Success", "Component added to project!")
            except sqlite3.IntegrityError:
                messagebox.showwarning("Warning", "This component is already in the project!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to add component: {str(e)}")
    
    def remove_component_from_project(self):
        """Remove a component from the current project"""
        selection = self.project_components_tree.selection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a component to remove!")
            return
        
        item = self.project_components_tree.item(selection[0])
        component_id = item['values'][0]
        
        if not messagebox.askyesno("Confirm Remove", 
            "Remove this component from the project? Associated answers will also be removed."):
            return
        
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            # Delete answers for questions related to this component
            cursor.execute('''
                DELETE FROM project_answers 
                WHERE project_id = ? AND question_id IN (
                    SELECT id FROM design_questions WHERE component_id = ?
                )
            ''', (self.current_project_id, component_id))
            # Delete the component from project
            cursor.execute(
                "DELETE FROM project_components WHERE project_id = ? AND component_id = ?",
                (self.current_project_id, component_id)
            )
            conn.commit()
            conn.close()
            
            self.refresh_project_components()
            self.refresh_project_questions()
            messagebox.showinfo("Success", "Component removed from project!")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to remove component: {str(e)}")
    
    def refresh_project_questions(self):
        """Refresh the project questions and answers list"""
        # Clear existing items
        for item in self.project_qa_tree.get_children():
            self.project_qa_tree.delete(item)
        
        if not hasattr(self, 'current_project_id'):
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Get filter value
        filter_component = self.qa_filter_var.get() if hasattr(self, 'qa_filter_var') else "All"
        
        if filter_component == "All":
            cursor.execute('''
                SELECT dq.id, ac.component_name, dq.question_text, 
                       pa.answer_text, pa.answered_by
                FROM design_questions dq
                JOIN azure_components ac ON dq.component_id = ac.id
                JOIN project_components pc ON pc.component_id = ac.id
                LEFT JOIN project_answers pa ON pa.question_id = dq.id AND pa.project_id = ?
                WHERE pc.project_id = ?
                ORDER BY ac.component_name, dq.priority DESC, dq.created_at
            ''', (self.current_project_id, self.current_project_id))
        else:
            cursor.execute('''
                SELECT dq.id, ac.component_name, dq.question_text, 
                       pa.answer_text, pa.answered_by
                FROM design_questions dq
                JOIN azure_components ac ON dq.component_id = ac.id
                JOIN project_components pc ON pc.component_id = ac.id
                LEFT JOIN project_answers pa ON pa.question_id = dq.id AND pa.project_id = ?
                WHERE pc.project_id = ? AND ac.component_name = ?
                ORDER BY dq.priority DESC, dq.created_at
            ''', (self.current_project_id, self.current_project_id, filter_component))
        
        questions = cursor.fetchall()
        conn.close()
        
        for q_id, component, question, answer, answered_by in questions:
            question_display = question[:80] + "..." if len(question) > 80 else question
            answer_display = (answer[:50] + "...") if answer and len(answer) > 50 else (answer or "")
            status = "Answered" if answer else "Pending"
            answered_by_display = answered_by or ""
            
            self.project_qa_tree.insert("", tk.END, 
                values=(q_id, component, question_display, answer_display, status, answered_by_display))
        
        # Update status
        count = len(questions)
        answered = sum(1 for q in questions if q[3])
        self.status_var.set(f"Project questions: {answered}/{count} answered")
    
    def filter_project_questions(self, event=None):
        """Filter project questions by component"""
        self.refresh_project_questions()
    
    def answer_project_question(self):
        """Answer or edit answer for a project question"""
        selection = self.project_qa_tree.selection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a question to answer!")
            return
        
        item = self.project_qa_tree.item(selection[0])
        question_id = item['values'][0]
        
        # Get question and current answer
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT dq.question_text, dq.answer_guidance, pa.answer_text, pa.answered_by
            FROM design_questions dq
            LEFT JOIN project_answers pa ON pa.question_id = dq.id AND pa.project_id = ?
            WHERE dq.id = ?
        ''', (self.current_project_id, question_id))
        
        result = cursor.fetchone()
        conn.close()
        
        if not result:
            messagebox.showerror("Error", "Question not found!")
            return
        
        question_text, guidance, current_answer, answered_by = result
        
        dialog = AnswerQuestionDialog(self.root, question_text, guidance, current_answer, answered_by)
        self.root.wait_window(dialog.dialog)
        
        if dialog.result:
            answer_text, answered_by_name = dialog.result
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                
                # Check if answer exists
                cursor.execute(
                    "SELECT id FROM project_answers WHERE project_id = ? AND question_id = ?",
                    (self.current_project_id, question_id)
                )
                existing = cursor.fetchone()
                
                if existing:
                    cursor.execute('''
                        UPDATE project_answers 
                        SET answer_text = ?, answered_by = ?, updated_at = CURRENT_TIMESTAMP
                        WHERE project_id = ? AND question_id = ?
                    ''', (answer_text, answered_by_name, self.current_project_id, question_id))
                else:
                    cursor.execute('''
                        INSERT INTO project_answers (project_id, question_id, answer_text, answered_by)
                        VALUES (?, ?, ?, ?)
                    ''', (self.current_project_id, question_id, answer_text, answered_by_name))
                
                conn.commit()
                conn.close()
                self.refresh_project_questions()
                messagebox.showinfo("Success", "Answer saved successfully!")
            except Exception as e:
                messagebox.showerror("Error", f"Failed to save answer: {str(e)}")
    
    def export_project_report(self):
        """Export project report to a text file"""
        if not hasattr(self, 'current_project_id'):
            messagebox.showwarning("Warning", "Please select a project first!")
            return
        
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Get project details
            cursor.execute("SELECT project_name, description, status FROM projects WHERE id = ?", 
                          (self.current_project_id,))
            result = cursor.fetchone()
            
            if not result:
                messagebox.showerror("Error", "Project not found!")
                conn.close()
                return
            
            proj_name, proj_desc, proj_status = result
            
            # Get components and their Q&A
            cursor.execute('''
                SELECT ac.component_name, ac.category, ac.description, pc.notes
                FROM project_components pc
                JOIN azure_components ac ON pc.component_id = ac.id
                WHERE pc.project_id = ?
                ORDER BY ac.component_name
            ''', (self.current_project_id,))
            components = cursor.fetchall()
            
            # Create report
            report = []
            report.append("=" * 80)
            report.append(f"Azure Design Review Report: {proj_name}")
            report.append("=" * 80)
            report.append(f"\nStatus: {proj_status}")
            report.append(f"Description: {proj_desc or 'N/A'}")
            report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            report.append("\n" + "=" * 80)
            
            for comp_name, comp_cat, comp_desc, comp_notes in components:
                report.append(f"\n\nCOMPONENT: {comp_name}")
                report.append("-" * 80)
                report.append(f"Category: {comp_cat or 'N/A'}")
                report.append(f"Description: {comp_desc or 'N/A'}")
                if comp_notes:
                    report.append(f"Project Notes: {comp_notes}")
                
                # Get questions and answers for this component
                cursor.execute('''
                    SELECT dq.question_text, dq.answer_guidance, dq.priority,
                           pa.answer_text, pa.answered_by, pa.answered_at
                    FROM design_questions dq
                    LEFT JOIN project_answers pa ON pa.question_id = dq.id AND pa.project_id = ?
                    WHERE dq.component_id = (
                        SELECT id FROM azure_components WHERE component_name = ?
                    )
                    ORDER BY dq.priority DESC, dq.created_at
                ''', (self.current_project_id, comp_name))
                
                questions = cursor.fetchall()
                
                if questions:
                    report.append("\nDesign Questions:")
                    for idx, (q_text, q_guidance, q_priority, a_text, a_by, a_at) in enumerate(questions, 1):
                        report.append(f"\n  Q{idx}. [{q_priority}] {q_text}")
                        if q_guidance:
                            report.append(f"      Guidance: {q_guidance}")
                        if a_text:
                            report.append(f"      ANSWER: {a_text}")
                            report.append(f"      Answered by: {a_by or 'Unknown'} on {a_at or 'Unknown'}")
                        else:
                            report.append(f"      ANSWER: [NOT YET ANSWERED]")
                else:
                    report.append("\nNo design questions defined for this component.")
            
            conn.close()
            
            # Generate default filename
            safe_proj_name = "".join(c if c.isalnum() or c in (' ', '-', '_') else '_' for c in proj_name)
            default_filename = f"project_report_{safe_proj_name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
            
            # Ask user where to save the file
            filepath = filedialog.asksaveasfilename(
                defaultextension=".txt",
                filetypes=[
                    ("Text files", "*.txt"),
                    ("All files", "*.*")
                ],
                initialfile=default_filename,
                title="Save Project Report"
            )
            
            # If user cancelled, return
            if not filepath:
                return
            
            # Save report
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write('\n'.join(report))
            
            messagebox.showinfo("Success", 
                f"Report exported successfully!\n\nSaved to:\n{filepath}")
            
        except Exception as e:
            messagebox.showerror("Error", f"Failed to export report: {str(e)}")


class ProjectDialog:
    """Dialog for adding/editing projects"""
    def __init__(self, parent, title, initial_data=None):
        self.result = None
        self.dialog = tk.Toplevel(parent)
        self.dialog.title(title)
        self.dialog.geometry("500x350")
        self.dialog.transient(parent)
        self.dialog.grab_set()
        
        # Center the dialog
        self.dialog.update_idletasks()
        x = (self.dialog.winfo_screenwidth() // 2) - (self.dialog.winfo_width() // 2)
        y = (self.dialog.winfo_screenheight() // 2) - (self.dialog.winfo_height() // 2)
        self.dialog.geometry(f"+{x}+{y}")
        
        # Project name
        ttk.Label(self.dialog, text="Project Name:").grid(row=0, column=0, sticky=tk.W, padx=10, pady=10)
        self.name_var = tk.StringVar(value=initial_data[0] if initial_data else "")
        ttk.Entry(self.dialog, textvariable=self.name_var, width=40).grid(row=0, column=1, padx=10, pady=10)
        
        # Status
        ttk.Label(self.dialog, text="Status:").grid(row=1, column=0, sticky=tk.W, padx=10, pady=10)
        self.status_var = tk.StringVar(value=initial_data[2] if initial_data else "Active")
        status_combo = ttk.Combobox(self.dialog, textvariable=self.status_var, width=37, state="readonly")
        status_combo['values'] = ("Active", "Planning", "On Hold", "Completed", "Archived")
        status_combo.grid(row=1, column=1, padx=10, pady=10)
        
        # Description
        ttk.Label(self.dialog, text="Description:").grid(row=2, column=0, sticky=tk.NW, padx=10, pady=10)
        self.description_text = tk.Text(self.dialog, width=40, height=8)
        self.description_text.grid(row=2, column=1, padx=10, pady=10)
        if initial_data and initial_data[1]:
            self.description_text.insert("1.0", initial_data[1])
        
        # Buttons
        btn_frame = ttk.Frame(self.dialog)
        btn_frame.grid(row=3, column=0, columnspan=2, pady=10)
        ttk.Button(btn_frame, text="Save", command=self.save).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.LEFT, padx=5)
    
    def save(self):
        name = self.name_var.get().strip()
        if not name:
            messagebox.showwarning("Warning", "Project name is required!")
            return
        
        description = self.description_text.get("1.0", tk.END).strip()
        status = self.status_var.get()
        
        self.result = (name, description, status)
        self.dialog.destroy()


class AddComponentToProjectDialog:
    """Dialog for adding a component to a project"""
    def __init__(self, parent, db_path, project_id):
        self.result = None
        self.dialog = tk.Toplevel(parent)
        self.dialog.title("Add Component to Project")
        self.dialog.geometry("500x400")
        self.dialog.transient(parent)
        self.dialog.grab_set()
        
        # Center the dialog
        self.dialog.update_idletasks()
        x = (self.dialog.winfo_screenwidth() // 2) - (self.dialog.winfo_width() // 2)
        y = (self.dialog.winfo_screenheight() // 2) - (self.dialog.winfo_height() // 2)
        self.dialog.geometry(f"+{x}+{y}")
        
        # Get available components (not already in project)
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        cursor.execute('''
            SELECT id, component_name, category
            FROM azure_components
            WHERE id NOT IN (
                SELECT component_id FROM project_components WHERE project_id = ?
            )
            ORDER BY component_name
        ''', (project_id,))
        self.components = cursor.fetchall()
        conn.close()
        
        if not self.components:
            messagebox.showinfo("Info", "All available components are already in this project!")
            self.dialog.destroy()
            return
        
        # Component selection
        ttk.Label(self.dialog, text="Select Component:").grid(row=0, column=0, sticky=tk.W, padx=10, pady=10)
        
        # Listbox with scrollbar
        list_frame = ttk.Frame(self.dialog)
        list_frame.grid(row=1, column=0, columnspan=2, padx=10, pady=10, sticky="nsew")
        
        scrollbar = ttk.Scrollbar(list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.components_listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, height=10)
        self.components_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.config(command=self.components_listbox.yview)
        
        for comp_id, name, category in self.components:
            display = f"{name} ({category})" if category else name
            self.components_listbox.insert(tk.END, display)
        
        # Notes
        ttk.Label(self.dialog, text="Notes (optional):").grid(row=2, column=0, sticky=tk.NW, padx=10, pady=10)
        self.notes_text = tk.Text(self.dialog, width=40, height=5)
        self.notes_text.grid(row=2, column=1, padx=10, pady=10)
        
        # Configure grid weights
        self.dialog.grid_rowconfigure(1, weight=1)
        self.dialog.grid_columnconfigure(1, weight=1)
        
        # Buttons
        btn_frame = ttk.Frame(self.dialog)
        btn_frame.grid(row=3, column=0, columnspan=2, pady=10)
        ttk.Button(btn_frame, text="Add", command=self.add).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.LEFT, padx=5)
    
    def add(self):
        selection = self.components_listbox.curselection()
        if not selection:
            messagebox.showwarning("Warning", "Please select a component!")
            return
        
        index = selection[0]
        component_id = self.components[index][0]
        notes = self.notes_text.get("1.0", tk.END).strip()
        
        self.result = (component_id, notes)
        self.dialog.destroy()


class AnswerQuestionDialog:
    """Dialog for answering project questions"""
    def __init__(self, parent, question_text, guidance, current_answer=None, answered_by=None):
        self.result = None
        self.dialog = tk.Toplevel(parent)
        self.dialog.title("Answer Question")
        self.dialog.geometry("700x600")
        self.dialog.transient(parent)
        self.dialog.grab_set()
        
        # Center the dialog
        self.dialog.update_idletasks()
        x = (self.dialog.winfo_screenwidth() // 2) - (self.dialog.winfo_width() // 2)
        y = (self.dialog.winfo_screenheight() // 2) - (self.dialog.winfo_height() // 2)
        self.dialog.geometry(f"+{x}+{y}")
        
        # Question text (read-only)
        ttk.Label(self.dialog, text="Question:", font=("Arial", 10, "bold")).grid(
            row=0, column=0, sticky=tk.NW, padx=10, pady=10)
        question_display = scrolledtext.ScrolledText(self.dialog, width=60, height=4, wrap=tk.WORD)
        question_display.grid(row=0, column=1, padx=10, pady=10, sticky="ew")
        question_display.insert("1.0", question_text)
        question_display.config(state=tk.DISABLED, background="#f0f0f0")
        
        # Guidance (read-only)
        if guidance:
            ttk.Label(self.dialog, text="Guidance:", font=("Arial", 10, "bold")).grid(
                row=1, column=0, sticky=tk.NW, padx=10, pady=10)
            guidance_display = scrolledtext.ScrolledText(self.dialog, width=60, height=4, wrap=tk.WORD)
            guidance_display.grid(row=1, column=1, padx=10, pady=10, sticky="ew")
            guidance_display.insert("1.0", guidance)
            guidance_display.config(state=tk.DISABLED, background="#f0f0f0")
        
        # Answer text (editable)
        ttk.Label(self.dialog, text="Your Answer:", font=("Arial", 10, "bold")).grid(
            row=2, column=0, sticky=tk.NW, padx=10, pady=10)
        self.answer_text = scrolledtext.ScrolledText(self.dialog, width=60, height=10, wrap=tk.WORD)
        self.answer_text.grid(row=2, column=1, padx=10, pady=10, sticky="ew")
        if current_answer:
            self.answer_text.insert("1.0", current_answer)
        
        # Answered by
        ttk.Label(self.dialog, text="Answered By:").grid(row=3, column=0, sticky=tk.W, padx=10, pady=10)
        self.answered_by_var = tk.StringVar(value=answered_by or "")
        ttk.Entry(self.dialog, textvariable=self.answered_by_var, width=40).grid(
            row=3, column=1, sticky=tk.W, padx=10, pady=10)
        
        # Configure grid weights
        self.dialog.grid_rowconfigure(2, weight=1)
        self.dialog.grid_columnconfigure(1, weight=1)
        
        # Buttons
        btn_frame = ttk.Frame(self.dialog)
        btn_frame.grid(row=4, column=0, columnspan=2, pady=20)
        ttk.Button(btn_frame, text="Save Answer", command=self.save).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.LEFT, padx=5)
    
    def save(self):
        answer = self.answer_text.get("1.0", tk.END).strip()
        if not answer:
            messagebox.showwarning("Warning", "Please provide an answer!")
            return
        
        answered_by = self.answered_by_var.get().strip()
        
        self.result = (answer, answered_by)
        self.dialog.destroy()


class ComponentDialog:
    """Dialog for adding/editing Azure components"""
    def __init__(self, parent, title, initial_data=None):
        self.result = None
        self.dialog = tk.Toplevel(parent)
        self.dialog.title(title)
        self.dialog.geometry("500x300")
        self.dialog.transient(parent)
        self.dialog.grab_set()
        
        # Center the dialog
        self.dialog.update_idletasks()
        x = (self.dialog.winfo_screenwidth() // 2) - (self.dialog.winfo_width() // 2)
        y = (self.dialog.winfo_screenheight() // 2) - (self.dialog.winfo_height() // 2)
        self.dialog.geometry(f"+{x}+{y}")
        
        # Component name
        ttk.Label(self.dialog, text="Component Name:").grid(row=0, column=0, sticky=tk.W, padx=10, pady=10)
        self.name_var = tk.StringVar(value=initial_data[0] if initial_data else "")
        ttk.Entry(self.dialog, textvariable=self.name_var, width=40).grid(row=0, column=1, padx=10, pady=10)
        
        # Category
        ttk.Label(self.dialog, text="Category:").grid(row=1, column=0, sticky=tk.W, padx=10, pady=10)
        self.category_var = tk.StringVar(value=initial_data[1] if initial_data else "")
        category_combo = ttk.Combobox(self.dialog, textvariable=self.category_var, width=37)
        category_combo['values'] = ("Compute", "Database", "Storage", "Networking", "Security", 
                                     "Integration", "Monitoring", "Containers", "Cache")
        category_combo.grid(row=1, column=1, padx=10, pady=10)
        
        # Description
        ttk.Label(self.dialog, text="Description:").grid(row=2, column=0, sticky=tk.NW, padx=10, pady=10)
        self.description_text = tk.Text(self.dialog, width=40, height=6)
        self.description_text.grid(row=2, column=1, padx=10, pady=10)
        if initial_data and initial_data[2]:
            self.description_text.insert("1.0", initial_data[2])
        
        # Buttons
        btn_frame = ttk.Frame(self.dialog)
        btn_frame.grid(row=3, column=0, columnspan=2, pady=10)
        ttk.Button(btn_frame, text="Save", command=self.save).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.LEFT, padx=5)
        
        self.name_var.trace("w", lambda *args: self.name_var.set(self.name_var.get()))
    
    def save(self):
        name = self.name_var.get().strip()
        if not name:
            messagebox.showwarning("Warning", "Component name is required!")
            return
        
        category = self.category_var.get().strip()
        description = self.description_text.get("1.0", tk.END).strip()
        
        self.result = (name, category, description)
        self.dialog.destroy()


class QuestionDialog:
    """Dialog for adding/editing design questions"""
    def __init__(self, parent, title, initial_data=None):
        self.result = None
        self.dialog = tk.Toplevel(parent)
        self.dialog.title(title)
        self.dialog.geometry("700x500")
        self.dialog.transient(parent)
        self.dialog.grab_set()
        
        # Center the dialog
        self.dialog.update_idletasks()
        x = (self.dialog.winfo_screenwidth() // 2) - (self.dialog.winfo_width() // 2)
        y = (self.dialog.winfo_screenheight() // 2) - (self.dialog.winfo_height() // 2)
        self.dialog.geometry(f"+{x}+{y}")
        
        # Question text
        ttk.Label(self.dialog, text="Question:").grid(row=0, column=0, sticky=tk.NW, padx=10, pady=10)
        self.question_text = scrolledtext.ScrolledText(self.dialog, width=60, height=6)
        self.question_text.grid(row=0, column=1, padx=10, pady=10)
        if initial_data and initial_data[0]:
            self.question_text.insert("1.0", initial_data[0])
        
        # Answer guidance
        ttk.Label(self.dialog, text="Answer Guidance:").grid(row=1, column=0, sticky=tk.NW, padx=10, pady=10)
        self.answer_text = scrolledtext.ScrolledText(self.dialog, width=60, height=8)
        self.answer_text.grid(row=1, column=1, padx=10, pady=10)
        if initial_data and initial_data[1]:
            self.answer_text.insert("1.0", initial_data[1])
        
        # Priority
        ttk.Label(self.dialog, text="Priority:").grid(row=2, column=0, sticky=tk.W, padx=10, pady=10)
        self.priority_var = tk.StringVar(value=initial_data[2] if initial_data else "Medium")
        priority_frame = ttk.Frame(self.dialog)
        priority_frame.grid(row=2, column=1, sticky=tk.W, padx=10, pady=10)
        for priority in ["High", "Medium", "Low"]:
            ttk.Radiobutton(priority_frame, text=priority, variable=self.priority_var, 
                           value=priority).pack(side=tk.LEFT, padx=5)
        
        # Tags
        ttk.Label(self.dialog, text="Tags:").grid(row=3, column=0, sticky=tk.W, padx=10, pady=10)
        self.tags_var = tk.StringVar(value=initial_data[3] if initial_data and initial_data[3] else "")
        ttk.Entry(self.dialog, textvariable=self.tags_var, width=60).grid(row=3, column=1, padx=10, pady=10)
        ttk.Label(self.dialog, text="(comma-separated)", font=("Arial", 8)).grid(row=4, column=1, sticky=tk.W, padx=10)
        
        # Buttons
        btn_frame = ttk.Frame(self.dialog)
        btn_frame.grid(row=5, column=0, columnspan=2, pady=20)
        ttk.Button(btn_frame, text="Save", command=self.save).pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.LEFT, padx=5)
    
    def save(self):
        question = self.question_text.get("1.0", tk.END).strip()
        if not question:
            messagebox.showwarning("Warning", "Question text is required!")
            return
        
        answer = self.answer_text.get("1.0", tk.END).strip()
        priority = self.priority_var.get()
        tags = self.tags_var.get().strip()
        
        self.result = (question, answer, priority, tags)
        self.dialog.destroy()


def main():
    root = tk.Tk()
    app = AzureDesignQuestionsApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()