feat: implement Edit Dataset functionality with test case management

- Add dataset editing interface with test case display
- Implement add new test case functionality
- Add classification selector (green/yellow/red) for new test cases
- Implement close editor button
- Fix dataset dropdown initialization in Enhanced Dataset Mode
- Add proper event handlers for edit operations
- Improve UI with HTML rendering for test cases display

src/interface/enhanced_verification_interface.py

@@ -202,8 +202,108 @@ class EnhancedVerificationInterface:
                         gr.Markdown("Select and customize test datasets for verification.")
                         back_from_dataset_btn = gr.Button("← Back to Mode Selection", size="sm")
                         gr.Markdown("---")
-                        # Embed the actual interface
-                        enhanced_dataset_ui = EnhancedVerificationUIComponents.create_enhanced_dataset_interface_with_handlers()
+                        
+                        # Create dataset interface components directly here
+                        from src.interface.enhanced_dataset_interface import EnhancedDatasetInterfaceController
+                        dataset_controller = EnhancedDatasetInterfaceController()
+                        
+                        # Pre-load dataset choices for initialization
+                        try:
+                            initial_choices, _, _, _ = dataset_controller.initialize_interface()
+                        except Exception:
+                            initial_choices = []
+                        
+                        # Dataset selection interface
+                        with gr.Row():
+                            with gr.Column(scale=2):
+                                gr.Markdown("## 📋 Select Dataset")
+                                
+                                dataset_selector = gr.Dropdown(
+                                    choices=initial_choices,
+                                    value=initial_choices[0] if initial_choices else None,
+                                    label="Available Datasets",
+                                    info="Choose a dataset to verify or edit",
+                                    interactive=True
+                                )
+                                
+                                with gr.Row():
+                                    load_dataset_btn = gr.Button("📥 Load Dataset", variant="primary", scale=2)
+                                    edit_dataset_btn = gr.Button("✏️ Edit Dataset", variant="secondary", scale=1)
+                            
+                            with gr.Column(scale=1):
+                                gr.Markdown("## 📊 Dataset Information")
+                                dataset_info_display = gr.Markdown(
+                                    "Select a dataset to view details",
+                                    label="Dataset Details"
+                                )
+                        
+                        # Verification interface (initially hidden)
+                        verification_section = gr.Row(visible=False)
+                        with verification_section:
+                            with gr.Column():
+                                gr.Markdown("## 🔍 Dataset Verification")
+                                
+                                # Verification controls
+                                with gr.Row():
+                                    with gr.Column(scale=2):
+                                        verifier_name_input = gr.Textbox(
+                                            label="Verifier Name",
+                                            placeholder="Enter your name...",
+                                            interactive=True
+                                        )
+                                    
+                                    with gr.Column(scale=1):
+                                        start_verification_btn = gr.Button(
+                                            "🚀 Start Verification",
+                                            variant="primary",
+                                            size="lg"
+                                        )
+                                
+                                # Progress display
+                                verification_progress = gr.Markdown(
+                                    "Ready to start verification",
+                                    label="Progress"
+                                )
+                        
+                        # Edit Dataset interface (initially hidden)
+                        edit_section = gr.Row(visible=False)
+                        with edit_section:
+                            with gr.Column():
+                                gr.Markdown("## ✏️ Edit Dataset")
+                                
+                                # Test cases display
+                                test_cases_display = gr.HTML(
+                                    value="<p>Loading test cases...</p>",
+                                    label="Test Cases"
+                                )
+                                
+                                gr.Markdown("### ➕ Add New Test Case")
+                                with gr.Row():
+                                    with gr.Column(scale=3):
+                                        new_message_text = gr.Textbox(
+                                            label="Message Text",
+                                            placeholder="Enter the test message...",
+                                            lines=3,
+                                            interactive=True
+                                        )
+                                    with gr.Column(scale=1):
+                                        new_message_classification = gr.Radio(
+                                            choices=["green", "yellow", "red"],
+                                            label="Expected Classification",
+                                            value="yellow"
+                                        )
+                                
+                                with gr.Row():
+                                    add_test_case_btn = gr.Button("➕ Add Test Case", variant="primary")
+                                    close_edit_btn = gr.Button("✖️ Close Editor", variant="secondary")
+                        
+                        # Status message for dataset interface
+                        dataset_status_message = gr.Markdown("", visible=True)
+                        
+                        # Dataset state
+                        current_dataset_state = gr.State(value=None)
+                        verification_session_state = gr.State(value=None)
+                        editing_dataset_state = gr.State(value=None)
                 
                 manual_input_interface = gr.Row(visible=False)
                 with manual_input_interface:
@@ -439,9 +539,44 @@ class EnhancedVerificationInterface:
                     status_msg  # status_message
                 )
             
+            # Special function for enhanced dataset mode initialization
+            def switch_to_enhanced_dataset():
+                """Switch to enhanced dataset mode with proper initialization."""
+                try:
+                    # Get first dataset info for display
+                    dataset_choices, _, _, _ = dataset_controller.initialize_interface()
+                    first_dataset = None
+                    dataset_info = "Select a dataset to view details"
+                    
+                    if dataset_choices:
+                        first_info, first_dataset = dataset_controller.get_dataset_info(dataset_choices[0])
+                        dataset_info = first_info
+                    
+                    return (
+                        gr.Row(visible=False),  # mode_selection_section
+                        gr.Row(visible=True),   # enhanced_dataset_interface
+                        gr.Row(visible=False),  # manual_input_interface
+                        gr.Row(visible=False),  # file_upload_interface
+                        "enhanced_dataset",     # current_mode_state
+                        "✅ Switched to Enhanced Datasets mode",  # status_message
+                        dataset_info,           # dataset_info_display
+                        first_dataset           # current_dataset_state
+                    )
+                except Exception as e:
+                    return (
+                        gr.Row(visible=False),  # mode_selection_section
+                        gr.Row(visible=True),   # enhanced_dataset_interface
+                        gr.Row(visible=False),  # manual_input_interface
+                        gr.Row(visible=False),  # file_upload_interface
+                        "enhanced_dataset",     # current_mode_state
+                        f"❌ Error initializing dataset mode: {str(e)}",  # status_message
+                        "Error loading datasets",  # dataset_info_display
+                        None                    # current_dataset_state
+                    )
+            
             # Bind mode selection buttons
             enhanced_dataset_btn.click(
-                lambda: direct_mode_switch("enhanced_dataset"),
+                switch_to_enhanced_dataset,
                 inputs=[],
                 outputs=[
                     mode_selection_section,
@@ -449,7 +584,9 @@ class EnhancedVerificationInterface:
                     manual_input_interface,
                     file_upload_interface,
                     current_mode_state,
-                    status_message
+                    status_message,
+                    dataset_info_display,
+                    current_dataset_state
                 ]
             )
             
@@ -599,6 +736,183 @@ class EnhancedVerificationInterface:
                     status_message
                 ]
             )
+            
+            # Dataset interface event handlers
+            def on_dataset_selection_change(dataset_selection):
+                """Handle dataset selection change."""
+                try:
+                    dataset_info, dataset_obj = dataset_controller.get_dataset_info(dataset_selection)
+                    return (
+                        dataset_info,     # dataset_info_display
+                        dataset_obj       # current_dataset_state
+                    )
+                except Exception as e:
+                    return (
+                        f"❌ Error loading dataset info: {str(e)}",  # dataset_info_display
+                        None  # current_dataset_state
+                    )
+            
+            def on_load_dataset(current_dataset):
+                """Handle load dataset for verification."""
+                try:
+                    if not current_dataset:
+                        return (
+                            gr.Row(visible=False),  # verification_section
+                            "❌ No dataset selected"  # dataset_status_message
+                        )
+                    
+                    return (
+                        gr.Row(visible=True),   # verification_section
+                        f"✅ Dataset '{current_dataset.name}' loaded for verification"  # dataset_status_message
+                    )
+                except Exception as e:
+                    return (
+                        gr.Row(visible=False),  # verification_section
+                        f"❌ Error loading dataset: {str(e)}"  # dataset_status_message
+                    )
+            
+            def on_edit_dataset(current_dataset):
+                """Handle edit dataset button."""
+                try:
+                    if not current_dataset:
+                        return (
+                            gr.Row(visible=False),  # edit_section
+                            "",  # test_cases_display
+                            current_dataset,  # editing_dataset_state
+                            "❌ No dataset selected for editing"  # dataset_status_message
+                        )
+                    
+                    # Render test cases HTML
+                    test_cases_html = dataset_controller.render_test_cases_display(current_dataset)
+                    
+                    return (
+                        gr.Row(visible=True),  # edit_section
+                        test_cases_html,  # test_cases_display
+                        current_dataset,  # editing_dataset_state
+                        f"✏️ Editing dataset: '{current_dataset.name}'"  # dataset_status_message
+                    )
+                except Exception as e:
+                    return (
+                        gr.Row(visible=False),  # edit_section
+                        "",  # test_cases_display
+                        None,  # editing_dataset_state
+                        f"❌ Error accessing dataset for editing: {str(e)}"  # dataset_status_message
+                    )
+            
+            def on_close_edit():
+                """Close the edit section."""
+                return (
+                    gr.Row(visible=False),  # edit_section
+                    "✅ Editor closed"  # dataset_status_message
+                )
+            
+            def on_add_test_case(editing_dataset, message_text, classification):
+                """Add a new test case to the dataset."""
+                try:
+                    if not editing_dataset:
+                        return (
+                            "",  # test_cases_display
+                            editing_dataset,  # editing_dataset_state
+                            "❌ No dataset being edited"  # dataset_status_message
+                        )
+                    
+                    if not message_text or not message_text.strip():
+                        return (
+                            dataset_controller.render_test_cases_display(editing_dataset),  # test_cases_display
+                            editing_dataset,  # editing_dataset_state
+                            "❌ Message text is required"  # dataset_status_message
+                        )
+                    
+                    # Add test case
+                    success, message, updated_dataset = dataset_controller.add_test_case(
+                        editing_dataset, message_text.strip(), classification
+                    )
+                    
+                    if success:
+                        # Render updated test cases
+                        test_cases_html = dataset_controller.render_test_cases_display(updated_dataset)
+                        return (
+                            test_cases_html,  # test_cases_display
+                            updated_dataset,  # editing_dataset_state
+                            message  # dataset_status_message
+                        )
+                    else:
+                        return (
+                            dataset_controller.render_test_cases_display(editing_dataset),  # test_cases_display
+                            editing_dataset,  # editing_dataset_state
+                            message  # dataset_status_message
+                        )
+                except Exception as e:
+                    return (
+                        "",  # test_cases_display
+                        editing_dataset,  # editing_dataset_state
+                        f"❌ Error adding test case: {str(e)}"  # dataset_status_message
+                    )
+            
+            def on_start_verification(current_dataset, verifier_name):
+                """Handle starting verification session."""
+                try:
+                    if not current_dataset:
+                        return (
+                            None,  # verification_session_state
+                            "❌ No dataset selected"  # dataset_status_message
+                        )
+                    
+                    success, message, session = dataset_controller.start_verification_session(
+                        current_dataset, verifier_name
+                    )
+                    
+                    if success:
+                        return (
+                            session,  # verification_session_state
+                            message   # dataset_status_message
+                        )
+                    else:
+                        return (
+                            None,     # verification_session_state
+                            message   # dataset_status_message
+                        )
+                except Exception as e:
+                    return (
+                        None,  # verification_session_state
+                        f"❌ Error starting verification: {str(e)}"  # dataset_status_message
+                    )
+            
+            # Bind dataset interface events
+            dataset_selector.change(
+                on_dataset_selection_change,
+                inputs=[dataset_selector],
+                outputs=[dataset_info_display, current_dataset_state]
+            )
+            
+            load_dataset_btn.click(
+                on_load_dataset,
+                inputs=[current_dataset_state],
+                outputs=[verification_section, dataset_status_message]
+            )
+            
+            edit_dataset_btn.click(
+                on_edit_dataset,
+                inputs=[current_dataset_state],
+                outputs=[edit_section, test_cases_display, editing_dataset_state, dataset_status_message]
+            )
+            
+            close_edit_btn.click(
+                on_close_edit,
+                outputs=[edit_section, dataset_status_message]
+            )
+            
+            add_test_case_btn.click(
+                on_add_test_case,
+                inputs=[editing_dataset_state, new_message_text, new_message_classification],
+                outputs=[test_cases_display, editing_dataset_state, dataset_status_message]
+            )
+            
+            start_verification_btn.click(
+                on_start_verification,
+                inputs=[current_dataset_state, verifier_name_input],
+                outputs=[verification_session_state, dataset_status_message]
+            )
         
         return interface