App_Function_Libraries/Gradio_UI/Anki_tab.py

# Anki_Validation_tab.py
# Description: Gradio functions for the Anki Validation tab
#
# Imports
import json
import logging
import os
import tempfile
from typing import Optional, Tuple, List, Dict
#
# External Imports
import genanki
import gradio as gr
#
# Local Imports
from App_Function_Libraries.Chat.Chat_Functions import approximate_token_count, update_chat_content, save_chat_history, \
    save_chat_history_to_db_wrapper
from App_Function_Libraries.DB.DB_Manager import list_prompts
from App_Function_Libraries.Gradio_UI.Chat_ui import update_dropdown_multiple, chat_wrapper, update_selected_parts, \
    search_conversations, regenerate_last_message, load_conversation, debug_output
from App_Function_Libraries.Third_Party.Anki import sanitize_html, generate_card_choices, \
    export_cards, load_card_for_editing, handle_file_upload, \
    validate_for_ui, update_card_with_validation, update_card_choices, enhanced_file_upload, \
    handle_validation
from App_Function_Libraries.Utils.Utils import default_api_endpoint, global_api_endpoints, format_api_name
#
############################################################################################################
#
# Functions:

def create_anki_validation_tab():
    with gr.TabItem("Anki Flashcard Validation", visible=True):
        gr.Markdown("# Anki Flashcard Validation and Editor")

        # State variables for internal tracking
        current_card_data = gr.State({})
        preview_update_flag = gr.State(False)

        with gr.Row():
            # Left Column: Input and Validation
            with gr.Column(scale=1):
                gr.Markdown("## Import or Create Flashcards")

                input_type = gr.Radio(
                    choices=["JSON", "APKG"],
                    label="Input Type",
                    value="JSON"
                )

                with gr.Group() as json_input_group:
                    flashcard_input = gr.TextArea(
                        label="Enter Flashcards (JSON format)",
                        placeholder='''{
    "cards": [
        {
            "id": "CARD_001",
            "type": "basic",
            "front": "What is the capital of France?",
            "back": "Paris",
            "tags": ["geography", "europe"],
            "note": "Remember: City of Light"
        }
    ]
}''',
                        lines=10
                    )

                    import_json = gr.File(
                        label="Or Import JSON File",
                        file_types=[".json"]
                    )

                with gr.Group(visible=False) as apkg_input_group:
                    import_apkg = gr.File(
                        label="Import APKG File",
                        file_types=[".apkg"]
                    )
                    deck_info = gr.JSON(
                        label="Deck Information",
                        visible=False
                    )

                validate_button = gr.Button("Validate Flashcards")

            # Right Column: Validation Results and Editor
            with gr.Column(scale=1):
                gr.Markdown("## Validation Results")
                validation_status = gr.Markdown("")

                with gr.Accordion("Validation Rules", open=False):
                    gr.Markdown("""
                    ### Required Fields:
                    - Unique ID
                    - Card Type (basic, cloze, reverse)
                    - Front content
                    - Back content
                    - At least one tag

                    ### Content Rules:
                    - No empty fields
                    - Front side should be a clear question/prompt
                    - Back side should contain complete answer
                    - Cloze deletions must have valid syntax
                    - No duplicate IDs

                    ### Image Rules:
                    - Valid image tags
                    - Supported formats (JPG, PNG, GIF)
                    - Base64 encoded or valid URL

                    ### APKG-specific Rules:
                    - Valid SQLite database structure
                    - Media files properly referenced
                    - Note types match Anki standards
                    - Card templates are well-formed
                    """)

        with gr.Row():
            # Card Editor
            gr.Markdown("## Card Editor")
        with gr.Row():
            with gr.Column(scale=1):
                with gr.Accordion("Edit Individual Cards", open=True):
                    card_selector = gr.Dropdown(
                        label="Select Card to Edit",
                        choices=[],
                        interactive=True
                    )

                    card_type = gr.Radio(
                        choices=["basic", "cloze", "reverse"],
                        label="Card Type",
                        value="basic"
                    )

                    # Front content with preview
                    with gr.Group():
                        gr.Markdown("### Front Content")
                        front_content = gr.TextArea(
                            label="Content (HTML supported)",
                            lines=3
                        )
                        front_preview = gr.HTML(
                            label="Preview"
                        )

                    # Back content with preview
                    with gr.Group():
                        gr.Markdown("### Back Content")
                        back_content = gr.TextArea(
                            label="Content (HTML supported)",
                            lines=3
                        )
                        back_preview = gr.HTML(
                            label="Preview"
                        )

                    tags_input = gr.TextArea(
                        label="Tags (comma-separated)",
                        lines=1
                    )

                    notes_input = gr.TextArea(
                        label="Additional Notes",
                        lines=2
                    )

                    with gr.Row():
                        update_card_button = gr.Button("Update Card")
                        delete_card_button = gr.Button("Delete Card", variant="stop")

        with gr.Row():
            with gr.Column(scale=1):
                # Export Options
                gr.Markdown("## Export Options")
                export_format = gr.Radio(
                    choices=["Anki CSV", "JSON", "Plain Text"],
                    label="Export Format",
                    value="Anki CSV"
                )
                export_button = gr.Button("Export Valid Cards")
                export_file = gr.File(label="Download Validated Cards")
                export_status = gr.Markdown("")
            with gr.Column(scale=1):
                gr.Markdown("## Export Instructions")
                gr.Markdown("""
                ### Anki CSV Format:
                - Front, Back, Tags, Type, Note
                - Use for importing into Anki
                - Images preserved as HTML

                ### JSON Format:
                - JSON array of cards
                - Images as base64 or URLs
                - Use for custom processing

                ### Plain Text Format:
                - Question and Answer pairs
                - Images represented as [IMG] placeholder
                - Use for manual review
                """)

        def update_preview(content):
            """Update preview with sanitized content."""
            if not content:
                return ""
            return sanitize_html(content)

        # Event handlers
        def validation_chain(content: str) -> Tuple[str, List[str]]:
            """Combined validation and card choice update."""
            validation_message = validate_for_ui(content)
            card_choices = update_card_choices(content)
            return validation_message, card_choices

        def delete_card(card_selection, current_content):
            """Delete selected card and return updated content."""
            if not card_selection or not current_content:
                return current_content, "No card selected", []

            try:
                data = json.loads(current_content)
                selected_id = card_selection.split(" - ")[0]

                data['cards'] = [card for card in data['cards'] if card['id'] != selected_id]
                new_content = json.dumps(data, indent=2)

                return (
                    new_content,
                    "Card deleted successfully!",
                    generate_card_choices(new_content)
                )

            except Exception as e:
                return current_content, f"Error deleting card: {str(e)}", []

        def process_validation_result(is_valid, message):
            """Process validation result into a formatted markdown string."""
            if is_valid:
                return f"✅ {message}"
            else:
                return f"❌ {message}"

        # Register event handlers
        input_type.change(
            fn=lambda t: (
                gr.update(visible=t == "JSON"),
                gr.update(visible=t == "APKG"),
                gr.update(visible=t == "APKG")
            ),
            inputs=[input_type],
            outputs=[json_input_group, apkg_input_group, deck_info]
        )

        # File upload handlers
        import_json.upload(
            fn=handle_file_upload,
            inputs=[import_json, input_type],
            outputs=[
                flashcard_input,
                deck_info,
                validation_status,
                card_selector
            ]
        )

        import_apkg.upload(
            fn=enhanced_file_upload,
            inputs=[import_apkg, input_type],
            outputs=[
                flashcard_input,
                deck_info,
                validation_status,
                card_selector
            ]
        )

        # Validation handler
        validate_button.click(
            fn=lambda content, input_format: (
                handle_validation(content, input_format),
                generate_card_choices(content) if content else []
            ),
            inputs=[flashcard_input, input_type],
            outputs=[validation_status, card_selector]
        )

        # Card editing handlers
        # Card selector change event
        card_selector.change(
            fn=load_card_for_editing,
            inputs=[card_selector, flashcard_input],
            outputs=[
                card_type,
                front_content,
                back_content,
                tags_input,
                notes_input,
                front_preview,
                back_preview
            ]
        )

        # Live preview updates
        front_content.change(
            fn=update_preview,
            inputs=[front_content],
            outputs=[front_preview]
        )

        back_content.change(
            fn=update_preview,
            inputs=[back_content],
            outputs=[back_preview]
        )

        # Card update handler
        update_card_button.click(
            fn=update_card_with_validation,
            inputs=[
                flashcard_input,
                card_selector,
                card_type,
                front_content,
                back_content,
                tags_input,
                notes_input
            ],
            outputs=[
                flashcard_input,
                validation_status,
                card_selector
            ]
        )

        # Delete card handler
        delete_card_button.click(
            fn=delete_card,
            inputs=[card_selector, flashcard_input],
            outputs=[flashcard_input, validation_status, card_selector]
        )

        # Export handler
        export_button.click(
            fn=export_cards,
            inputs=[flashcard_input, export_format],
            outputs=[export_status, export_file]
        )

        return (
            flashcard_input,
            import_json,
            import_apkg,
            validate_button,
            validation_status,
            card_selector,
            card_type,
            front_content,
            back_content,
            front_preview,
            back_preview,
            tags_input,
            notes_input,
            update_card_button,
            delete_card_button,
            export_format,
            export_button,
            export_file,
            export_status,
            deck_info
        )


def create_anki_generator_tab():
    with gr.TabItem("Anki Deck Generator", visible=True):
        try:
            default_value = None
            if default_api_endpoint:
                if default_api_endpoint in global_api_endpoints:
                    default_value = format_api_name(default_api_endpoint)
                else:
                    logging.warning(f"Default API endpoint '{default_api_endpoint}' not found in global_api_endpoints")
        except Exception as e:
            logging.error(f"Error setting default API endpoint: {str(e)}")
            default_value = None
        custom_css = """
        .chatbot-container .message-wrap .message {
            font-size: 14px !important;
        }
        """
        with gr.TabItem("LLM Chat & Anki Deck Creation", visible=True):
            gr.Markdown("# Chat with an LLM to help you come up with Questions/Answers for an Anki Deck")
            chat_history = gr.State([])
            media_content = gr.State({})
            selected_parts = gr.State([])
            conversation_id = gr.State(None)
            initial_prompts, total_pages, current_page = list_prompts(page=1, per_page=10)

            with gr.Row():
                with gr.Column(scale=1):
                    search_query_input = gr.Textbox(
                        label="Search Query",
                        placeholder="Enter your search query here..."
                    )
                    search_type_input = gr.Radio(
                        choices=["Title", "Content", "Author", "Keyword"],
                        value="Keyword",
                        label="Search By"
                    )
                    keyword_filter_input = gr.Textbox(
                        label="Filter by Keywords (comma-separated)",
                        placeholder="ml, ai, python, etc..."
                    )
                    search_button = gr.Button("Search")
                    items_output = gr.Dropdown(label="Select Item", choices=[], interactive=True)
                    item_mapping = gr.State({})
                    with gr.Row():
                        use_content = gr.Checkbox(label="Use Content")
                        use_summary = gr.Checkbox(label="Use Summary")
                        use_prompt = gr.Checkbox(label="Use Prompt")
                        save_conversation = gr.Checkbox(label="Save Conversation", value=False, visible=True)
                    with gr.Row():
                        temperature = gr.Slider(label="Temperature", minimum=0.00, maximum=1.0, step=0.05, value=0.7)
                    with gr.Row():
                        conversation_search = gr.Textbox(label="Search Conversations")
                    with gr.Row():
                        search_conversations_btn = gr.Button("Search Conversations")
                    with gr.Row():
                        previous_conversations = gr.Dropdown(label="Select Conversation", choices=[], interactive=True)
                    with gr.Row():
                        load_conversations_btn = gr.Button("Load Selected Conversation")

                    # Refactored API selection dropdown
                    api_endpoint = gr.Dropdown(
                        choices=["None"] + [format_api_name(api) for api in global_api_endpoints],
                        value=default_value,
                        label="API for Chat Interaction (Optional)"
                    )
                    api_key = gr.Textbox(label="API Key (if required)", type="password")
                    custom_prompt_checkbox = gr.Checkbox(label="Use a Custom Prompt",
                                                         value=False,
                                                         visible=True)
                    preset_prompt_checkbox = gr.Checkbox(label="Use a Pre-set Prompt",
                                                         value=False,
                                                         visible=True)
                    with gr.Row(visible=False) as preset_prompt_controls:
                        prev_prompt_page = gr.Button("Previous")
                        next_prompt_page = gr.Button("Next")
                        current_prompt_page_text = gr.Text(f"Page {current_page} of {total_pages}")
                        current_prompt_page_state = gr.State(value=1)

                    preset_prompt = gr.Dropdown(
                        label="Select Preset Prompt",
                        choices=initial_prompts
                    )
                    user_prompt = gr.Textbox(label="Custom Prompt",
                                             placeholder="Enter custom prompt here",
                                             lines=3,
                                             visible=False)
                    system_prompt_input = gr.Textbox(label="System Prompt",
                                                     value="You are a helpful AI assitant",
                                                     lines=3,
                                                     visible=False)
                with gr.Column(scale=2):
                    chatbot = gr.Chatbot(height=800, elem_classes="chatbot-container")
                    msg = gr.Textbox(label="Enter your message")
                    submit = gr.Button("Submit")
                    regenerate_button = gr.Button("Regenerate Last Message")
                    token_count_display = gr.Number(label="Approximate Token Count", value=0, interactive=False)
                    clear_chat_button = gr.Button("Clear Chat")

                    chat_media_name = gr.Textbox(label="Custom Chat Name(optional)")
                    save_chat_history_to_db = gr.Button("Save Chat History to DataBase")
                    save_status = gr.Textbox(label="Save Status", interactive=False)
                    save_chat_history_as_file = gr.Button("Save Chat History as File")
                    download_file = gr.File(label="Download Chat History")

            search_button.click(
                fn=update_dropdown_multiple,
                inputs=[search_query_input, search_type_input, keyword_filter_input],
                outputs=[items_output, item_mapping]
            )

            def update_prompt_visibility(custom_prompt_checked, preset_prompt_checked):
                user_prompt_visible = custom_prompt_checked
                system_prompt_visible = custom_prompt_checked
                preset_prompt_visible = preset_prompt_checked
                preset_prompt_controls_visible = preset_prompt_checked
                return (
                    gr.update(visible=user_prompt_visible, interactive=user_prompt_visible),
                    gr.update(visible=system_prompt_visible, interactive=system_prompt_visible),
                    gr.update(visible=preset_prompt_visible, interactive=preset_prompt_visible),
                    gr.update(visible=preset_prompt_controls_visible)
                )

            def update_prompt_page(direction, current_page_val):
                new_page = current_page_val + direction
                if new_page < 1:
                    new_page = 1
                prompts, total_pages, _ = list_prompts(page=new_page, per_page=20)
                if new_page > total_pages:
                    new_page = total_pages
                    prompts, total_pages, _ = list_prompts(page=new_page, per_page=20)
                return (
                    gr.update(choices=prompts),
                    gr.update(value=f"Page {new_page} of {total_pages}"),
                    new_page
                )

            def clear_chat():
                return [], None  # Return empty list for chatbot and None for conversation_id

            custom_prompt_checkbox.change(
                update_prompt_visibility,
                inputs=[custom_prompt_checkbox, preset_prompt_checkbox],
                outputs=[user_prompt, system_prompt_input, preset_prompt, preset_prompt_controls]
            )

            preset_prompt_checkbox.change(
                update_prompt_visibility,
                inputs=[custom_prompt_checkbox, preset_prompt_checkbox],
                outputs=[user_prompt, system_prompt_input, preset_prompt, preset_prompt_controls]
            )

            prev_prompt_page.click(
                lambda x: update_prompt_page(-1, x),
                inputs=[current_prompt_page_state],
                outputs=[preset_prompt, current_prompt_page_text, current_prompt_page_state]
            )

            next_prompt_page.click(
                lambda x: update_prompt_page(1, x),
                inputs=[current_prompt_page_state],
                outputs=[preset_prompt, current_prompt_page_text, current_prompt_page_state]
            )

            submit.click(
                chat_wrapper,
                inputs=[msg, chatbot, media_content, selected_parts, api_endpoint, api_key, user_prompt,
                        conversation_id,
                        save_conversation, temperature, system_prompt_input],
                outputs=[msg, chatbot, conversation_id]
            ).then(  # Clear the message box after submission
                lambda x: gr.update(value=""),
                inputs=[chatbot],
                outputs=[msg]
            ).then(  # Clear the user prompt after the first message
                lambda: (gr.update(value=""), gr.update(value="")),
                outputs=[user_prompt, system_prompt_input]
            ).then(
                lambda history: approximate_token_count(history),
                inputs=[chatbot],
                outputs=[token_count_display]
            )


            clear_chat_button.click(
                clear_chat,
                outputs=[chatbot, conversation_id]
            )

            items_output.change(
                update_chat_content,
                inputs=[items_output, use_content, use_summary, use_prompt, item_mapping],
                outputs=[media_content, selected_parts]
            )

            use_content.change(update_selected_parts, inputs=[use_content, use_summary, use_prompt],
                               outputs=[selected_parts])
            use_summary.change(update_selected_parts, inputs=[use_content, use_summary, use_prompt],
                               outputs=[selected_parts])
            use_prompt.change(update_selected_parts, inputs=[use_content, use_summary, use_prompt],
                              outputs=[selected_parts])
            items_output.change(debug_output, inputs=[media_content, selected_parts], outputs=[])

            search_conversations_btn.click(
                search_conversations,
                inputs=[conversation_search],
                outputs=[previous_conversations]
            )

            load_conversations_btn.click(
                clear_chat,
                outputs=[chatbot, chat_history]
            ).then(
                load_conversation,
                inputs=[previous_conversations],
                outputs=[chatbot, conversation_id]
            )

            previous_conversations.change(
                load_conversation,
                inputs=[previous_conversations],
                outputs=[chat_history]
            )

            save_chat_history_as_file.click(
                save_chat_history,
                inputs=[chatbot, conversation_id],
                outputs=[download_file]
            )

            save_chat_history_to_db.click(
                save_chat_history_to_db_wrapper,
                inputs=[chatbot, conversation_id, media_content, chat_media_name],
                outputs=[conversation_id, gr.Textbox(label="Save Status")]
            )

            regenerate_button.click(
                regenerate_last_message,
                inputs=[chatbot, media_content, selected_parts, api_endpoint, api_key, user_prompt, temperature,
                        system_prompt_input],
                outputs=[chatbot, save_status]
            ).then(
                lambda history: approximate_token_count(history),
                inputs=[chatbot],
                outputs=[token_count_display]
            )
        gr.Markdown("# Create Anki Deck")

        with gr.Row():
            # Left Column: Deck Settings
            with gr.Column(scale=1):
                gr.Markdown("## Deck Settings")
                deck_name = gr.Textbox(
                    label="Deck Name",
                    placeholder="My Study Deck",
                    value="My Study Deck"
                )

                deck_description = gr.Textbox(
                    label="Deck Description",
                    placeholder="Description of your deck",
                    lines=2
                )

                note_type = gr.Radio(
                    choices=["Basic", "Basic (and reversed)", "Cloze"],
                    label="Note Type",
                    value="Basic"
                )

                # Card Fields based on note type
                with gr.Group() as basic_fields:
                    front_template = gr.Textbox(
                        label="Front Template (HTML)",
                        value="{{Front}}",
                        lines=3
                    )
                    back_template = gr.Textbox(
                        label="Back Template (HTML)",
                        value="{{FrontSide}}<hr id='answer'>{{Back}}",
                        lines=3
                    )

                with gr.Group() as cloze_fields:
                    cloze_template = gr.Textbox(
                        label="Cloze Template (HTML)",
                        value="{{cloze:Text}}",
                        lines=3,
                        visible=False
                    )

                css_styling = gr.Textbox(
                    label="Card Styling (CSS)",
                    value=".card {\n font-family: arial;\n font-size: 20px;\n text-align: center;\n color: black;\n background-color: white;\n}\n\n.cloze {\n font-weight: bold;\n color: blue;\n}",
                    lines=5
                )

            # Right Column: Card Creation
            with gr.Column(scale=1):
                gr.Markdown("## Add Cards")

                with gr.Group() as basic_input:
                    front_content = gr.TextArea(
                        label="Front Content",
                        placeholder="Question or prompt",
                        lines=3
                    )
                    back_content = gr.TextArea(
                        label="Back Content",
                        placeholder="Answer",
                        lines=3
                    )

                with gr.Group() as cloze_input:
                    cloze_content = gr.TextArea(
                        label="Cloze Content",
                        placeholder="Text with {{c1::cloze}} deletions",
                        lines=3,
                        visible=False
                    )

                tags_input = gr.TextArea(
                    label="Tags (comma-separated)",
                    placeholder="tag1, tag2, tag3",
                    lines=1
                )

                add_card_btn = gr.Button("Add Card")

                cards_list = gr.JSON(
                    label="Cards in Deck",
                    value={"cards": []}
                )

                clear_cards_btn = gr.Button("Clear All Cards", variant="stop")

        with gr.Row():
            generate_deck_btn = gr.Button("Generate Deck", variant="primary")
            download_deck = gr.File(label="Download Deck")
            generation_status = gr.Markdown("")

        def update_note_type_fields(note_type: str):
            if note_type == "Cloze":
                return {
                    basic_input: gr.update(visible=False),
                    cloze_input: gr.update(visible=True),
                    basic_fields: gr.update(visible=False),
                    cloze_fields: gr.update(visible=True)
                }
            else:
                return {
                    basic_input: gr.update(visible=True),
                    cloze_input: gr.update(visible=False),
                    basic_fields: gr.update(visible=True),
                    cloze_fields: gr.update(visible=False)
                }

        def add_card(note_type: str, front: str, back: str, cloze: str, tags: str, current_cards: Dict[str, List]):
            if not current_cards:
                current_cards = {"cards": []}

            cards_data = current_cards["cards"]

            # Process tags
            card_tags = [tag.strip() for tag in tags.split(',') if tag.strip()]

            new_card = {
                "id": f"CARD_{len(cards_data) + 1}",
                "tags": card_tags
            }

            if note_type == "Cloze":
                if not cloze or "{{c" not in cloze:
                    return current_cards, "❌ Invalid cloze format. Use {{c1::text}} syntax."
                new_card.update({
                    "type": "cloze",
                    "content": cloze
                })
            else:
                if not front or not back:
                    return current_cards, "❌ Both front and back content are required."
                new_card.update({
                    "type": "basic",
                    "front": front,
                    "back": back,
                    "is_reverse": note_type == "Basic (and reversed)"
                })

            cards_data.append(new_card)
            return {"cards": cards_data}, "✅ Card added successfully!"

        def clear_cards() -> Tuple[Dict[str, List], str]:
            return {"cards": []}, "✅ All cards cleared!"

        def generate_anki_deck(
            deck_name: str,
            deck_description: str,
            note_type: str,
            front_template: str,
            back_template: str,
            cloze_template: str,
            css: str,
            cards_data: Dict[str, List]
        ) -> Tuple[Optional[str], str]:
            try:
                if not cards_data or not cards_data.get("cards"):
                    return None, "❌ No cards to generate deck from!"

                # Create model based on note type
                if note_type == "Cloze":
                    model = genanki.Model(
                        1483883320,  # Random model ID
                        'Cloze Model',
                        fields=[
                            {'name': 'Text'},
                            {'name': 'Back Extra'}
                        ],
                        templates=[{
                            'name': 'Cloze Card',
                            'qfmt': cloze_template,
                            'afmt': cloze_template + '<br><hr id="extra">{{Back Extra}}'
                        }],
                        css=css,
                        # FIXME CLOZE DOESNT EXIST
                        model_type=1
                    )
                else:
                    templates = [{
                        'name': 'Card 1',
                        'qfmt': front_template,
                        'afmt': back_template
                    }]

                    if note_type == "Basic (and reversed)":
                        templates.append({
                            'name': 'Card 2',
                            'qfmt': '{{Back}}',
                            'afmt': '{{FrontSide}}<hr id="answer">{{Front}}'
                        })

                    model = genanki.Model(
                        1607392319,  # Random model ID
                        'Basic Model',
                        fields=[
                            {'name': 'Front'},
                            {'name': 'Back'}
                        ],
                        templates=templates,
                        css=css
                    )

                # Create deck
                deck = genanki.Deck(
                    2059400110,  # Random deck ID
                    deck_name,
                    description=deck_description
                )

                # Add cards to deck
                for card in cards_data["cards"]:
                    if card["type"] == "cloze":
                        note = genanki.Note(
                            model=model,
                            fields=[card["content"], ""],
                            tags=card["tags"]
                        )
                    else:
                        note = genanki.Note(
                            model=model,
                            fields=[card["front"], card["back"]],
                            tags=card["tags"]
                        )
                    deck.add_note(note)

                # Save deck to temporary file
                temp_dir = tempfile.mkdtemp()
                deck_path = os.path.join(temp_dir, f"{deck_name}.apkg")
                genanki.Package(deck).write_to_file(deck_path)

                return deck_path, "✅ Deck generated successfully!"

            except Exception as e:
                return None, f"❌ Error generating deck: {str(e)}"

        # Register event handlers
        note_type.change(
            fn=update_note_type_fields,
            inputs=[note_type],
            outputs=[basic_input, cloze_input, basic_fields, cloze_fields]
        )

        add_card_btn.click(
            fn=add_card,
            inputs=[
                note_type,
                front_content,
                back_content,
                cloze_content,
                tags_input,
                cards_list
            ],
            outputs=[cards_list, generation_status]
        )

        clear_cards_btn.click(
            fn=clear_cards,
            inputs=[],
            outputs=[cards_list, generation_status]
        )

        generate_deck_btn.click(
            fn=generate_anki_deck,
            inputs=[
                deck_name,
                deck_description,
                note_type,
                front_template,
                back_template,
                cloze_template,
                css_styling,
                cards_list
            ],
            outputs=[download_deck, generation_status]
        )


        return (
            deck_name,
            deck_description,
            note_type,
            front_template,
            back_template,
            cloze_template,
            css_styling,
            front_content,
            back_content,
            cloze_content,
            tags_input,
            cards_list,
            add_card_btn,
            clear_cards_btn,
            generate_deck_btn,
            download_deck,
            generation_status
        )

#
# End of Anki_Validation_tab.py
############################################################################################################