manager.py

import wx
import json
import os
import webbrowser
from pathlib import Path
import html
import shutil

class LinkData:
    def __init__(self, url, label, about="", subcategory=""):
        self.url = url
        self.label = label
        self.about = about
        self.subcategory = subcategory

class LinkManagerFrame(wx.Frame):
    def __init__(self):
        super().__init__(None, title="Link Manager", size=(800, 600))
        
        # Create data directory if it doesn't exist
        self.data_dir = Path("data")
        self.data_dir.mkdir(exist_ok=True)
        
        self.InitUI()
        self.LoadCategories()
        
        # Focus on the treeview when app opens
        self.tree.SetFocus()
        
        self.Centre()
        
    def InitUI(self):
        # Create menu bar
        menubar = wx.MenuBar()
        
        # File menu
        file_menu = wx.Menu()
        add_category = file_menu.Append(wx.ID_ANY, "Add Category\tCtrl+N")
        file_menu.AppendSeparator()
        export_all = file_menu.Append(wx.ID_ANY, "Export All to HTML\tCtrl+Shift+E")
        file_menu.AppendSeparator()
        exit_item = file_menu.Append(wx.ID_EXIT, "Exit\tCtrl+Q")
        
        menubar.Append(file_menu, "&File")
        self.SetMenuBar(menubar)
        
        # Bind menu events
        self.Bind(wx.EVT_MENU, self.OnAddCategory, add_category)
        self.Bind(wx.EVT_MENU, self.OnExportAll, export_all)
        self.Bind(wx.EVT_MENU, self.OnExit, exit_item)
        
        # Create main panel
        panel = wx.Panel(self)
        main_sizer = wx.BoxSizer(wx.VERTICAL)
        
        # Create toolbar with just Add Category button
        toolbar_sizer = wx.BoxSizer(wx.HORIZONTAL)
        self.btn_add_category = wx.Button(panel, label="Add Category")
        toolbar_sizer.Add(self.btn_add_category, 0, wx.ALL, 5)
        
        # Create tree control (standard TreeCtrl)
        self.tree = wx.TreeCtrl(panel, style=wx.TR_DEFAULT_STYLE | wx.TR_HIDE_ROOT)
        self.tree_root = self.tree.AddRoot("Link Categories")
        
        # Add placeholder if no categories
        self.placeholder_item = None
        
        # Create info panel
        info_panel = wx.Panel(panel)
        info_sizer = wx.BoxSizer(wx.VERTICAL)
        
        self.info_label = wx.StaticText(info_panel, label="Select a link to see details")
        self.info_url = wx.TextCtrl(info_panel, style=wx.TE_READONLY)
        
        self.about_label = wx.StaticText(info_panel, label="About:", name="about_label")
        self.info_about = wx.TextCtrl(info_panel, style=wx.TE_MULTILINE|wx.TE_READONLY, size=(-1, 100))
        
        info_sizer.Add(self.info_label, 0, wx.ALL|wx.EXPAND, 5)
        info_sizer.Add(wx.StaticText(info_panel, label="URL:"), 0, wx.ALL, 5)
        info_sizer.Add(self.info_url, 0, wx.ALL|wx.EXPAND, 5)
        info_sizer.Add(self.about_label, 0, wx.ALL, 5)
        info_sizer.Add(self.info_about, 1, wx.ALL|wx.EXPAND, 5)
        info_panel.SetSizer(info_sizer)
        
        # Add to main sizer
        main_sizer.Add(toolbar_sizer, 0, wx.EXPAND)
        main_sizer.Add(wx.StaticLine(panel), 0, wx.EXPAND|wx.ALL, 5)
        main_sizer.Add(self.tree, 1, wx.EXPAND|wx.ALL, 5)
        main_sizer.Add(info_panel, 0, wx.EXPAND|wx.ALL, 5)
        
        panel.SetSizer(main_sizer)
        
        # Create context menus
        self.CreateContextMenus()
        
        # Bind events
        self.btn_add_category.Bind(wx.EVT_BUTTON, self.OnAddCategory)
        self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeSelectionChanged)
        self.tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemActivated)
        self.tree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnTreeRightClick)
        self.tree.Bind(wx.EVT_TREE_ITEM_MENU, self.OnTreeContextMenu)
        
    def CreateContextMenus(self):
        """Create context menus for categories and links"""
        # Category context menu
        self.category_menu = wx.Menu()
        self.menu_add_link = self.category_menu.Append(wx.ID_ANY, "Add Link")
        self.menu_add_subcategory = self.category_menu.Append(wx.ID_ANY, "Add Subcategory")
        self.category_menu.AppendSeparator()
        self.menu_rename_category = self.category_menu.Append(wx.ID_ANY, "Rename Category")
        self.menu_export_category = self.category_menu.Append(wx.ID_ANY, "Export to HTML")
        self.category_menu.AppendSeparator()
        self.menu_remove_category = self.category_menu.Append(wx.ID_ANY, "Remove Category")
        
        # Subcategory context menu
        self.subcategory_menu = wx.Menu()
        self.menu_add_link_to_subcategory = self.subcategory_menu.Append(wx.ID_ANY, "Add Link")
        self.subcategory_menu.AppendSeparator()
        self.menu_rename_subcategory = self.subcategory_menu.Append(wx.ID_ANY, "Rename Subcategory")
        self.menu_remove_subcategory = self.subcategory_menu.Append(wx.ID_ANY, "Remove Subcategory")
        
        # Link context menu
        self.link_menu = wx.Menu()
        self.menu_open_link = self.link_menu.Append(wx.ID_ANY, "Open in Browser")
        self.link_menu.AppendSeparator()
        self.menu_edit_link = self.link_menu.Append(wx.ID_ANY, "Edit Link")
        self.menu_remove_link = self.link_menu.Append(wx.ID_ANY, "Remove Link")
        
    def LoadCategories(self):
        """Load all categories from JSON files"""
        self.tree.DeleteChildren(self.tree_root)
        self.placeholder_item = None
        
        # Get all JSON files in the main data directory (categories)
        json_files = list(self.data_dir.glob("*.json"))
        
        if not json_files:
            # Show placeholder if no categories
            self.placeholder_item = self.tree.AppendItem(self.tree_root, "No categories")
            self.tree.SetItemTextColour(self.placeholder_item, wx.Colour(128, 128, 128))
            self.tree.SetItemData(self.placeholder_item, {"type": "placeholder"})
            return
        
        # Process main category files
        for json_file in json_files:
            category_name = json_file.stem
            category_item = self.tree.AppendItem(self.tree_root, category_name)
            self.tree.SetItemData(category_item, {"type": "category", "filename": json_file.name})
            self.tree.SetItemBold(category_item, True)
            
            # Load links from JSON file
            try:
                with open(json_file, 'r', encoding='utf-8') as f:
                    links = json.load(f)
                
                # Add direct links to category
                sorted_links = sorted(links.items(), key=lambda x: x[1].get("label", x[0]).lower())
                
                for url, data in sorted_links:
                    link_item = self.tree.AppendItem(category_item, data.get("label", url))
                    link_data = LinkData(
                        url, 
                        data.get("label", url), 
                        data.get("about", ""),
                        ""  # No subcategory for main files
                    )
                    self.tree.SetItemData(link_item, {"type": "link", "data": link_data})
                    
                # Check if this category has a subcategory folder
                subcat_folder = self.data_dir / category_name
                if subcat_folder.exists() and subcat_folder.is_dir():
                    # Load subcategories from the folder
                    subcategory_files = list(subcat_folder.glob("*.json"))
                    for subcategory_file in subcategory_files:
                        subcategory_name = subcategory_file.stem
                        subcategory_item = self.tree.AppendItem(category_item, subcategory_name)
                        self.tree.SetItemData(subcategory_item, {
                            "type": "subcategory", 
                            "name": subcategory_name,
                            "filename": subcategory_file.name
                        })
                        
                        # Load links from subcategory file
                        try:
                            with open(subcategory_file, 'r', encoding='utf-8') as f:
                                subcat_links = json.load(f)
                            
                            # Sort links
                            sorted_subcat_links = sorted(subcat_links.items(), key=lambda x: x[1].get("label", x[0]).lower())
                            
                            for suburl, subdata in sorted_subcat_links:
                                sublink_item = self.tree.AppendItem(subcategory_item, subdata.get("label", suburl))
                                sublink_data = LinkData(
                                    suburl, 
                                    subdata.get("label", suburl), 
                                    subdata.get("about", ""),
                                    subcategory_name
                                )
                                self.tree.SetItemData(sublink_item, {"type": "link", "data": sublink_data})
                        except (json.JSONDecodeError, FileNotFoundError):
                            pass
                        
            except (json.JSONDecodeError, FileNotFoundError):
                pass
    
    def SortCategoryLinks(self, category_item):
        """Sort links in a category alphabetically"""
        # Collect all link items and their data
        links_data = []
        subcategories = []
        child, cookie = self.tree.GetFirstChild(category_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data:
                if child_data.get("type") == "link":
                    link_data = child_data.get("data")
                    if link_data:
                        links_data.append((child, link_data))
                elif child_data.get("type") == "subcategory":
                    subcategories.append(child)
            child, cookie = self.tree.GetNextChild(category_item, cookie)
        
        # Sort by label
        links_data.sort(key=lambda x: x[1].label.lower())
        
        # Remove direct links (keep subcategories)
        for child, _ in links_data:
            self.tree.Delete(child)
        
        # Re-add in sorted order
        for _, link_data in links_data:
            link_item = self.tree.AppendItem(category_item, link_data.label)
            self.tree.SetItemData(link_item, {"type": "link", "data": link_data})
    
    def SortSubcategoryLinks(self, subcategory_item):
        """Sort links in a subcategory alphabetically"""
        # Collect all link items and their data
        links_data = []
        child, cookie = self.tree.GetFirstChild(subcategory_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data and child_data.get("type") == "link":
                link_data = child_data.get("data")
                if link_data:
                    links_data.append((child, link_data))
            child, cookie = self.tree.GetNextChild(subcategory_item, cookie)
        
        # Sort by label
        links_data.sort(key=lambda x: x[1].label.lower())
        
        # Delete all children
        self.tree.DeleteChildren(subcategory_item)
        
        # Re-add in sorted order
        for _, link_data in links_data:
            link_item = self.tree.AppendItem(subcategory_item, link_data.label)
            self.tree.SetItemData(link_item, {"type": "link", "data": link_data})
    
    def SaveCategory(self, category_item):
        """Save a category to its JSON file"""
        item_data = self.tree.GetItemData(category_item)
        if not item_data or item_data.get("type") != "category":
            return
            
        category_name = self.tree.GetItemText(category_item)
        filename = item_data.get("filename")
        if not filename:
            filename = f"{category_name}.json"
            item_data["filename"] = filename
            
        filepath = self.data_dir / filename
        
        # Collect direct links in this category
        direct_links = {}
        
        # Process direct children of category
        child, cookie = self.tree.GetFirstChild(category_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data:
                if child_data.get("type") == "link":
                    link_data = child_data.get("data")
                    if link_data:
                        direct_links[link_data.url] = {
                            "label": link_data.label,
                            "about": link_data.about,
                        }
                elif child_data.get("type") == "subcategory":
                    # Save subcategory separately
                    self.SaveSubcategory(child, category_name)
            
            child, cookie = self.tree.GetNextChild(category_item, cookie)
        
        # Save main category file
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(direct_links, f, indent=4, ensure_ascii=False)
    
    def SaveSubcategory(self, subcategory_item, parent_category_name):
        """Save a subcategory to its own JSON file in the parent category folder"""
        item_data = self.tree.GetItemData(subcategory_item)
        if not item_data or item_data.get("type") != "subcategory":
            return
        
        subcategory_name = self.tree.GetItemText(subcategory_item)
        
        # Create/ensure parent category folder exists
        category_folder = self.data_dir / parent_category_name
        if not category_folder.exists():
            category_folder.mkdir(exist_ok=True)
        
        # Define subcategory file path
        subcategory_file = category_folder / f"{subcategory_name}.json"
        
        # Collect links in this subcategory
        links = {}
        
        child, cookie = self.tree.GetFirstChild(subcategory_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data and child_data.get("type") == "link":
                link_data = child_data.get("data")
                if link_data:
                    links[link_data.url] = {
                        "label": link_data.label,
                        "about": link_data.about,
                    }
            child, cookie = self.tree.GetNextChild(subcategory_item, cookie)
        
        # Save subcategory file
        with open(subcategory_file, 'w', encoding='utf-8') as f:
            json.dump(links, f, indent=4, ensure_ascii=False)
        
        # Update item data with filename
        item_data["filename"] = subcategory_file.name
    
    def RemovePlaceholder(self):
        """Remove the 'No categories' placeholder if it exists"""
        if self.placeholder_item and self.placeholder_item.IsOk():
            self.tree.Delete(self.placeholder_item)
            self.placeholder_item = None
    
    def OnTreeRightClick(self, event):
        """Handle right-click on tree item"""
        item = event.GetItem()
        if not item.IsOk():
            return
        
        self.tree.SelectItem(item)
        self.OnTreeContextMenu(event)
    
    def OnTreeContextMenu(self, event):
        """Show context menu for tree item"""
        selected = self.tree.GetSelection()
        if not selected.IsOk():
            return
        
        item_data = self.tree.GetItemData(selected)
        if not item_data:
            return
        
        item_type = item_data.get("type")
        
        if item_type == "category":
            # Bind category menu events
            self.Bind(wx.EVT_MENU, lambda e: self.OnAddLink(e, selected), self.menu_add_link)
            self.Bind(wx.EVT_MENU, lambda e: self.OnAddSubcategory(e, selected), self.menu_add_subcategory)
            self.Bind(wx.EVT_MENU, lambda e: self.OnRenameCategory(e, selected), self.menu_rename_category)
            self.Bind(wx.EVT_MENU, lambda e: self.OnExportCategory(e, selected), self.menu_export_category)
            self.Bind(wx.EVT_MENU, lambda e: self.OnRemoveCategory(e, selected), self.menu_remove_category)
            self.PopupMenu(self.category_menu)
            
        elif item_type == "subcategory":
            # Bind subcategory menu events
            self.Bind(wx.EVT_MENU, lambda e: self.OnAddLinkToSubcategory(e, selected), self.menu_add_link_to_subcategory)
            self.Bind(wx.EVT_MENU, lambda e: self.OnRenameSubcategory(e, selected), self.menu_rename_subcategory)
            self.Bind(wx.EVT_MENU, lambda e: self.OnRemoveSubcategory(e, selected), self.menu_remove_subcategory)
            self.PopupMenu(self.subcategory_menu)
            
        elif item_type == "link":
            # Bind link menu events
            self.Bind(wx.EVT_MENU, lambda e: self.OnOpenLink(e, selected), self.menu_open_link)
            self.Bind(wx.EVT_MENU, lambda e: self.OnEditLink(e, selected), self.menu_edit_link)
            self.Bind(wx.EVT_MENU, lambda e: self.OnRemoveLink(e, selected), self.menu_remove_link)
            self.PopupMenu(self.link_menu)
    
    def OnAddCategory(self, event):
        """Add a new category"""
        dialog = wx.TextEntryDialog(self, "Enter category name:", "Add Category")
        if dialog.ShowModal() == wx.ID_OK:
            category_name = dialog.GetValue().strip()
            if not category_name:
                wx.MessageBox("Category name cannot be empty!", "Error", wx.OK | wx.ICON_ERROR)
                dialog.Destroy()
                return
                
            # Check if category already exists
            existing = False
            child, cookie = self.tree.GetFirstChild(self.tree_root)
            while child.IsOk():
                if self.tree.GetItemText(child) == category_name:
                    existing = True
                    break
                child, cookie = self.tree.GetNextChild(self.tree_root, cookie)
            
            if not existing:
                self.RemovePlaceholder()
                category_item = self.tree.AppendItem(self.tree_root, category_name)
                filename = f"{category_name}.json"
                self.tree.SetItemData(category_item, {"type": "category", "filename": filename})
                self.tree.SetItemBold(category_item, True)
                self.SaveCategory(category_item)
            else:
                wx.MessageBox("Category already exists!", "Error", wx.OK | wx.ICON_ERROR)
        dialog.Destroy()
    
    def OnRemoveCategory(self, event, category_item=None):
        """Remove selected category"""
        if not category_item:
            return
            
        item_data = self.tree.GetItemData(category_item)
        if item_data and item_data.get("type") == "category":
            category_name = self.tree.GetItemText(category_item)
            result = wx.MessageBox(f"Are you sure you want to delete '{category_name}' and all its links?", 
                                 "Confirm Delete", wx.YES_NO | wx.ICON_QUESTION)
            if result == wx.YES:
                # Delete JSON file
                filename = item_data.get("filename")
                if filename:
                    filepath = self.data_dir / filename
                    if filepath.exists():
                        filepath.unlink()
                
                # Delete category folder if it exists
                category_folder = self.data_dir / category_name
                if category_folder.exists():
                    try:
                        shutil.rmtree(category_folder)
                    except:
                        pass  # Ignore errors if any
                
                # Remove from tree
                self.tree.Delete(category_item)
                
                # Check if we need to show placeholder
                child, cookie = self.tree.GetFirstChild(self.tree_root)
                if not child.IsOk():
                    self.placeholder_item = self.tree.AppendItem(self.tree_root, "No categories")
                    self.tree.SetItemTextColour(self.placeholder_item, wx.Colour(128, 128, 128))
                    self.tree.SetItemData(self.placeholder_item, {"type": "placeholder"})
    
    def OnRenameCategory(self, event, category_item=None):
        """Rename selected category"""
        if not category_item:
            return
            
        item_data = self.tree.GetItemData(category_item)
        if item_data and item_data.get("type") == "category":
            old_name = self.tree.GetItemText(category_item)
            dialog = wx.TextEntryDialog(self, "Enter new category name:", "Rename Category", old_name)
            if dialog.ShowModal() == wx.ID_OK:
                new_name = dialog.GetValue().strip()
                if not new_name:
                    wx.MessageBox("Category name cannot be empty!", "Error", wx.OK | wx.ICON_ERROR)
                    dialog.Destroy()
                    return
                    
                if new_name != old_name:
                    # Check if new name already exists
                    existing = False
                    child, cookie = self.tree.GetFirstChild(self.tree_root)
                    while child.IsOk():
                        if child != category_item and self.tree.GetItemText(child) == new_name:
                            existing = True
                            break
                        child, cookie = self.tree.GetNextChild(self.tree_root, cookie)
                    
                    if not existing:
                        # Rename JSON file
                        old_filename = item_data.get("filename")
                        if old_filename:
                            old_filepath = self.data_dir / old_filename
                            new_filename = f"{new_name}.json"
                            new_filepath = self.data_dir / new_filename
                            
                            if old_filepath.exists():
                                old_filepath.rename(new_filepath)
                            
                            item_data["filename"] = new_filename
                        
                        # Rename category folder if it exists
                        old_folder = self.data_dir / old_name
                        if old_folder.exists() and old_folder.is_dir():
                            new_folder = self.data_dir / new_name
                            old_folder.rename(new_folder)
                        
                        # Update tree
                        self.tree.SetItemText(category_item, new_name)
                    else:
                        wx.MessageBox("A category with that name already exists!", "Error", wx.OK | wx.ICON_ERROR)
            dialog.Destroy()
    
    def OnAddSubcategory(self, event, category_item=None):
        """Add a new subcategory to selected category"""
        if not category_item:
            return
            
        # Check if category already has a subcategory
        has_subcategory = False
        child, cookie = self.tree.GetFirstChild(category_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data and child_data.get("type") == "subcategory":
                has_subcategory = True
                break
            child, cookie = self.tree.GetNextChild(category_item, cookie)
        
        if has_subcategory:
            wx.MessageBox("This category already has a subcategory. Only one subcategory per category is allowed.", 
                         "Cannot Add Subcategory", wx.OK | wx.ICON_INFORMATION)
            return
        
        dialog = wx.TextEntryDialog(self, "Enter subcategory name:", "Add Subcategory")
        if dialog.ShowModal() == wx.ID_OK:
            subcategory_name = dialog.GetValue().strip()
            if not subcategory_name:
                wx.MessageBox("Subcategory name cannot be empty!", "Error", wx.OK | wx.ICON_ERROR)
                dialog.Destroy()
                return
                
            subcategory_item = self.tree.AppendItem(category_item, subcategory_name)
            self.tree.SetItemData(subcategory_item, {"type": "subcategory", "name": subcategory_name})
            
            # Save the subcategory
            category_name = self.tree.GetItemText(category_item)
            self.SaveSubcategory(subcategory_item, category_name)
            
            self.tree.Expand(category_item)
        dialog.Destroy()
    
    def OnRenameSubcategory(self, event, subcategory_item=None):
        """Rename selected subcategory"""
        if not subcategory_item:
            return
            
        item_data = self.tree.GetItemData(subcategory_item)
        if item_data and item_data.get("type") == "subcategory":
            old_name = self.tree.GetItemText(subcategory_item)
            dialog = wx.TextEntryDialog(self, "Enter new subcategory name:", "Rename Subcategory", old_name)
            if dialog.ShowModal() == wx.ID_OK:
                new_name = dialog.GetValue().strip()
                if not new_name:
                    wx.MessageBox("Subcategory name cannot be empty!", "Error", wx.OK | wx.ICON_ERROR)
                    dialog.Destroy()
                    return
                    
                if new_name != old_name:
                    # Update tree
                    self.tree.SetItemText(subcategory_item, new_name)
                    item_data["name"] = new_name
                    
                    # Update links in this subcategory
                    child, cookie = self.tree.GetFirstChild(subcategory_item)
                    while child.IsOk():
                        child_data = self.tree.GetItemData(child)
                        if child_data and child_data.get("type") == "link":
                            link_data = child_data.get("data")
                            if link_data:
                                link_data.subcategory = new_name
                        child, cookie = self.tree.GetNextChild(subcategory_item, cookie)
                    
                    # Get parent category
                    category_item = self.tree.GetItemParent(subcategory_item)
                    category_name = self.tree.GetItemText(category_item)
                    
                    # Rename the subcategory file
                    category_folder = self.data_dir / category_name
                    old_file = category_folder / f"{old_name}.json"
                    new_file = category_folder / f"{new_name}.json"
                    
                    if old_file.exists():
                        old_file.rename(new_file)
                    
                    # Update filename in item data
                    item_data["filename"] = f"{new_name}.json"
            dialog.Destroy()
    
    def OnRemoveSubcategory(self, event, subcategory_item=None):
        """Remove selected subcategory"""
        if not subcategory_item:
            return
            
        item_data = self.tree.GetItemData(subcategory_item)
        if item_data and item_data.get("type") == "subcategory":
            subcategory_name = self.tree.GetItemText(subcategory_item)
            result = wx.MessageBox(f"Are you sure you want to delete '{subcategory_name}' and all its links?", 
                                 "Confirm Delete", wx.YES_NO | wx.ICON_QUESTION)
            if result == wx.YES:
                # Get parent category
                category_item = self.tree.GetItemParent(subcategory_item)
                category_name = self.tree.GetItemText(category_item)
                
                # Delete subcategory file
                category_folder = self.data_dir / category_name
                subcategory_file = category_folder / f"{subcategory_name}.json"
                
                if subcategory_file.exists():
                    subcategory_file.unlink()
                
                # Check if category folder is now empty and remove it if so
                if category_folder.exists():
                    if not any(category_folder.iterdir()):
                        try:
                            category_folder.rmdir()
                        except:
                            pass  # Ignore errors
                
                # Remove from tree
                self.tree.Delete(subcategory_item)
    
    def OnAddLink(self, event, category_item=None):
        """Add a new link to selected category"""
        if not category_item:
            return
        
        # Show dialog to add link
        dialog = LinkDialog(self, "Add Link")
        if dialog.ShowModal() == wx.ID_OK:
            url, label, about = dialog.GetValues()
            # URL validation is done in the dialog
            # Add to tree
            link_item = self.tree.AppendItem(category_item, label or url)
            link_data = LinkData(url, label or url, about)
            self.tree.SetItemData(link_item, {"type": "link", "data": link_data})
            
            # Save category
            self.SaveCategory(category_item)
            
            # Sort the links in this category
            self.SortCategoryLinks(category_item)
            
            self.tree.Expand(category_item)
        dialog.Destroy()
    
    def OnAddLinkToSubcategory(self, event, subcategory_item=None):
        """Add a new link to selected subcategory"""
        if not subcategory_item:
            return
        
        # Show dialog to add link
        dialog = LinkDialog(self, "Add Link to Subcategory")
        if dialog.ShowModal() == wx.ID_OK:
            url, label, about = dialog.GetValues()
            # URL validation is done in the dialog
            # Add to tree
            link_item = self.tree.AppendItem(subcategory_item, label or url)
            
            # Get subcategory name
            subcategory_name = self.tree.GetItemText(subcategory_item)
            
            link_data = LinkData(url, label or url, about, subcategory_name)
            self.tree.SetItemData(link_item, {"type": "link", "data": link_data})
            
            # Save subcategory
            category_item = self.tree.GetItemParent(subcategory_item)
            category_name = self.tree.GetItemText(category_item)
            self.SaveSubcategory(subcategory_item, category_name)
            
            # Sort the links in this subcategory
            self.SortSubcategoryLinks(subcategory_item)
            
            self.tree.Expand(subcategory_item)
        dialog.Destroy()
    
    def OnRemoveLink(self, event, link_item=None):
        """Remove selected link"""
        if not link_item:
            return
            
        item_data = self.tree.GetItemData(link_item)
        if item_data and item_data.get("type") == "link":
            link_data = item_data.get("data")
            result = wx.MessageBox(f"Are you sure you want to delete '{link_data.label}'?", 
                                 "Confirm Delete", wx.YES_NO | wx.ICON_QUESTION)
            if result == wx.YES:
                parent_item = self.tree.GetItemParent(link_item)
                parent_data = self.tree.GetItemData(parent_item)
                
                # Delete the link from tree
                self.tree.Delete(link_item)
                
                if parent_data and parent_data.get("type") == "subcategory":
                    # Link is in a subcategory
                    category_item = self.tree.GetItemParent(parent_item)
                    category_name = self.tree.GetItemText(category_item)
                    self.SaveSubcategory(parent_item, category_name)
                else:
                    # Link is directly in a category
                    self.SaveCategory(parent_item)
    
    def OnEditLink(self, event, link_item=None):
        """Edit selected link"""
        if not link_item:
            return
            
        item_data = self.tree.GetItemData(link_item)
        if item_data and item_data.get("type") == "link":
            link_data = item_data.get("data")
            if link_data:
                dialog = LinkDialog(self, "Edit Link", 
                                  url=link_data.url, 
                                  label=link_data.label, 
                                  about=link_data.about)
                if dialog.ShowModal() == wx.ID_OK:
                    url, label, about = dialog.GetValues()
                    # URL validation is done in the dialog
                    # Update link data
                    link_data.url = url
                    link_data.label = label or url
                    link_data.about = about
                    
                    # Update tree
                    self.tree.SetItemText(link_item, label or url)
                    
                    # Update info panel if this link is selected
                    if self.tree.GetSelection() == link_item:
                        self.info_label.SetLabel(f"Link: {link_data.label}")
                        self.info_url.SetValue(link_data.url)
                        
                        if link_data.about:
                            self.info_about.SetValue(link_data.about)
                            self.info_about.Show()
                            self.about_label.Show()
                        else:
                            self.info_about.Hide()
                            self.about_label.Hide()
                        
                        self.info_about.GetParent().Layout()
                    
                    # Save changes
                    parent_item = self.tree.GetItemParent(link_item)
                    parent_data = self.tree.GetItemData(parent_item)
                    
                    if parent_data and parent_data.get("type") == "subcategory":
                        # Link is in a subcategory
                        category_item = self.tree.GetItemParent(parent_item)
                        category_name = self.tree.GetItemText(category_item)
                        self.SaveSubcategory(parent_item, category_name)
                        self.SortSubcategoryLinks(parent_item)
                    else:
                        # Link is directly in a category
                        self.SaveCategory(parent_item)
                        self.SortCategoryLinks(parent_item)
                dialog.Destroy()
    
    def OnOpenLink(self, event, link_item=None):
        """Open link in browser"""
        if not link_item:
            return
            
        item_data = self.tree.GetItemData(link_item)
        if item_data and item_data.get("type") == "link":
            link_data = item_data.get("data")
            if link_data:
                webbrowser.open(link_data.url)
    
    def OnTreeSelectionChanged(self, event):
        """Handle tree selection change"""
        selected = self.tree.GetSelection()
        if not selected.IsOk():
            return
            
        item_data = self.tree.GetItemData(selected)
        if item_data and item_data.get("type") == "link":
            link_data = item_data.get("data")
            if link_data:
                self.info_label.SetLabel(f"Link: {link_data.label}")
                self.info_url.SetValue(link_data.url)
                
                # Only show about section if there's content
                if link_data.about:
                    self.info_about.SetValue(link_data.about)
                    self.info_about.Show()
                    self.about_label.Show()
                else:
                    self.info_about.Hide()
                    self.about_label.Hide()
                
                self.info_about.GetParent().Layout()
        else:
            self.info_label.SetLabel("Select a link to see details")
            self.info_url.SetValue("")
            self.info_about.Hide()
            self.about_label.Hide()
            self.info_about.GetParent().Layout()
    
    def OnTreeItemActivated(self, event):
        """Handle double-click or Enter on tree item"""
        selected = self.tree.GetSelection()
        if not selected.IsOk():
            return
            
        item_data = self.tree.GetItemData(selected)
        if item_data:
            if item_data.get("type") == "link":
                link_data = item_data.get("data")
                if link_data:
                    webbrowser.open(link_data.url)
            elif item_data.get("type") in ["category", "subcategory"]:
                # Toggle expand/collapse
                if self.tree.IsExpanded(selected):
                    self.tree.Collapse(selected)
                else:
                    self.tree.Expand(selected)
    
    def OnExportCategory(self, event, category_item=None):
        """Export current category to HTML"""
        if not category_item:
            return
        
        category_name = self.tree.GetItemText(category_item)
        
        # Ask where to save
        wildcard = "HTML files (*.html)|*.html"
        dialog = wx.FileDialog(self, "Export Category to HTML", 
                             defaultFile=f"{category_name}.html",
                             wildcard=wildcard,
                             style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
        
        if dialog.ShowModal() == wx.ID_OK:
            filepath = dialog.GetPath()
            self.ExportCategoryToHTML(category_item, filepath)
            wx.MessageBox(f"Category exported to {filepath}", "Export Complete", wx.OK | wx.ICON_INFORMATION)
        
        dialog.Destroy()
    
    def OnExportAll(self, event):
        """Export all categories to HTML"""
        # Check if there are any categories
        child, cookie = self.tree.GetFirstChild(self.tree_root)
        if not child.IsOk() or (self.placeholder_item and child == self.placeholder_item):
            wx.MessageBox("No categories to export", "Nothing to Export", wx.OK | wx.ICON_WARNING)
            return
        
        wildcard = "HTML files (*.html)|*.html"
        dialog = wx.FileDialog(self, "Export All to HTML", 
                             defaultFile="all_links.html",
                             wildcard=wildcard,
                             style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
        
        if dialog.ShowModal() == wx.ID_OK:
            filepath = dialog.GetPath()
            self.ExportAllToHTML(filepath)
            wx.MessageBox(f"All categories exported to {filepath}", "Export Complete", wx.OK | wx.ICON_INFORMATION)
        
        dialog.Destroy()
    
    def ExportCategoryToHTML(self, category_item, filepath):
        """Export a single category to HTML file"""
        category_name = self.tree.GetItemText(category_item)
        
        html_content = f"""<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{html.escape(category_name)} - Links</title>
    <style>
        body {{ font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }}
        h1 {{ color: #333; border-bottom: 2px solid #333; padding-bottom: 10px; }}
        h2 {{ color: #555; border-bottom: 1px solid #999; padding-bottom: 5px; margin-top: 20px; }}
        .links-container {{ background: white; padding: 20px; margin: 20px 0; border-radius: 5px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
        ul {{ list-style-type: none; padding: 0; }}
        li {{ margin: 15px 0; padding: 15px; background: #f8f8f8; border-left: 4px solid #0066cc; }}
        .link-title {{ font-size: 18px; font-weight: bold; margin-bottom: 5px; }}
        .link-url {{ color: #0066cc; text-decoration: none; }}
        .link-url:hover {{ text-decoration: underline; }}
        .link-about {{ color: #666; margin-top: 5px; font-style: italic; }}
    </style>
</head>
<body>
    <h1>{html.escape(category_name)}</h1>
"""
        
        # Collect links and subcategories
        direct_links = []
        subcategories = {}
        
        child, cookie = self.tree.GetFirstChild(category_item)
        while child.IsOk():
            child_data = self.tree.GetItemData(child)
            if child_data:
                if child_data.get("type") == "link":
                    link_data = child_data.get("data")
                    if link_data:
                        direct_links.append(link_data)
                elif child_data.get("type") == "subcategory":
                    subcategory_name = self.tree.GetItemText(child)
                    subcategory_links = []
                    
                    subchild, subcookie = self.tree.GetFirstChild(child)
                    while subchild.IsOk():
                        subchild_data = self.tree.GetItemData(subchild)
                        if subchild_data and subchild_data.get("type") == "link":
                            sublink_data = subchild_data.get("data")
                            if sublink_data:
                                subcategory_links.append(sublink_data)
                        subchild, subcookie = self.tree.GetNextChild(child, subcookie)
                    
                    if subcategory_links:
                        subcategories[subcategory_name] = sorted(subcategory_links, key=lambda x: x.label.lower())
            
            child, cookie = self.tree.GetNextChild(category_item, cookie)
        
        # Sort direct links
        direct_links.sort(key=lambda x: x.label.lower())
        
        # Add direct links
        html_content += """    <div class="links-container">
        <h2>Main Links</h2>
"""
        
        if direct_links:
            html_content += "        <ul>\n"
            for link_data in direct_links:
                html_content += f"""            <li>
                <a href="{html.escape(link_data.url)}" class="link-url" target="_blank">{html.escape(link_data.label)}</a>
"""
                if link_data.about:
                    html_content += f"""                <div class="link-about">{html.escape(link_data.about)}</div>
"""
                html_content += """            </li>
"""
            html_content += "        </ul>\n"
        else:
            html_content += """        <p>No direct links in this category.</p>
"""
        
        html_content += "    </div>\n"
        
        # Add subcategories
        for subcategory_name, subcategory_links in subcategories.items():
            html_content += f"""    <div class="links-container">
        <h2>{html.escape(subcategory_name)}</h2>
"""
            
            if subcategory_links:
                html_content += "        <ul>\n"
                for link_data in subcategory_links:
                    html_content += f"""            <li>
                <a href="{html.escape(link_data.url)}" class="link-url" target="_blank">{html.escape(link_data.label)}</a>
"""
                    if link_data.about:
                        html_content += f"""                <div class="link-about">{html.escape(link_data.about)}</div>
"""
                    html_content += """            </li>
"""
                html_content += "        </ul>\n"
            else:
                html_content += """        <p>No links in this subcategory.</p>
"""
            
            html_content += "    </div>\n"
        
        html_content += """</body>
</html>"""
        
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(html_content)
    
    def ExportAllToHTML(self, filepath):
        """Export all categories to a single HTML file"""
        html_content = """<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>All Links</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }
        h1 { color: #333; border-bottom: 3px solid #333; padding-bottom: 10px; }
        h2 { color: #555; border-bottom: 1px solid #999; padding-bottom: 5px; margin-top: 30px; }
        h3 { color: #666; margin-top: 20px; }
        .links-container { background: white; padding: 20px; margin: 20px 0; border-radius: 5px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
        ul { list-style-type: none; padding: 0; }
        li { margin: 15px 0; padding: 15px; background: #f8f8f8; border-left: 4px solid #0066cc; }
        .link-title { font-size: 18px; font-weight: bold; margin-bottom: 5px; }
        .link-url { color: #0066cc; text-decoration: none; }
        .link-url:hover { text-decoration: underline; }
        .link-about { color: #666; margin-top: 5px; font-style: italic; }
        .toc { background: white; padding: 20px; margin: 20px 0; border-radius: 5px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
        .toc h3 { margin-top: 0; }
        .toc ul { list-style-type: disc; padding-left: 20px; }
        .toc li { margin: 5px 0; padding: 0; background: none; border: none; }
        .toc a { color: #0066cc; text-decoration: none; }
        .toc a:hover { text-decoration: underline; }
        .subcategory { margin-left: 20px; }
    </style>
</head>
<body>
    <h1>All Links</h1>
    <div class="toc">
        <h3>Categories</h3>
        <ul>
"""
        
        # Add table of contents
        categories = []
        child, cookie = self.tree.GetFirstChild(self.tree_root)
        while child.IsOk():
            item_data = self.tree.GetItemData(child)
            if item_data and item_data.get("type") == "category":
                category_name = self.tree.GetItemText(child)
                category_id = category_name.replace(" ", "_").lower()
                categories.append((child, category_name, category_id))
                
                html_content += f'            <li><a href="#{html.escape(category_id)}">{html.escape(category_name)}</a>'
                
                # Check for subcategories
                has_subcategories = False
                subchild, subcookie = self.tree.GetFirstChild(child)
                while subchild.IsOk():
                    subchild_data = self.tree.GetItemData(subchild)
                    if subchild_data and subchild_data.get("type") == "subcategory":
                        has_subcategories = True
                        subcategory_name = self.tree.GetItemText(subchild)
                        subcategory_id = f"{category_id}_{subcategory_name.replace(' ', '_').lower()}"
                        
                        if not has_subcategories:
                            html_content += "\n                <ul>"
                        
                        html_content += f'\n                    <li><a href="#{html.escape(subcategory_id)}">{html.escape(subcategory_name)}</a></li>'
                    
                    subchild, subcookie = self.tree.GetNextChild(child, subcookie)
                
                if has_subcategories:
                    html_content += "\n                </ul>"
                
                html_content += "</li>\n"
            
            child, cookie = self.tree.GetNextChild(self.tree_root, cookie)
        
        html_content += """        </ul>
    </div>
"""
        
        # Add categories and links
        for category_item, category_name, category_id in categories:
            html_content += f'    <h2 id="{html.escape(category_id)}">{html.escape(category_name)}</h2>\n'
            
            # Process direct links
            direct_links = []
            subcategories = {}
            
            child, cookie = self.tree.GetFirstChild(category_item)
            while child.IsOk():
                child_data = self.tree.GetItemData(child)
                if child_data:
                    if child_data.get("type") == "link":
                        link_data = child_data.get("data")
                        if link_data:
                            direct_links.append(link_data)
                    elif child_data.get("type") == "subcategory":
                        subcategory_name = self.tree.GetItemText(child)
                        subcategory_id = f"{category_id}_{subcategory_name.replace(' ', '_').lower()}"
                        subcategory_links = []
                        
                        subchild, subcookie = self.tree.GetFirstChild(child)
                        while subchild.IsOk():
                            subchild_data = self.tree.GetItemData(subchild)
                            if subchild_data and subchild_data.get("type") == "link":
                                sublink_data = subchild_data.get("data")
                                if sublink_data:
                                    subcategory_links.append(sublink_data)
                            subchild, subcookie = self.tree.GetNextChild(child, subcookie)
                        
                        subcategories[subcategory_name] = {
                            "id": subcategory_id,
                            "links": sorted(subcategory_links, key=lambda x: x.label.lower())
                        }
                
                child, cookie = self.tree.GetNextChild(category_item, cookie)
            
            # Sort direct links
            direct_links.sort(key=lambda x: x.label.lower())
            
            html_content += '    <div class="links-container">\n'
            
            if direct_links:
                html_content += "        <ul>\n"
                for link_data in direct_links:
                    html_content += f"""            <li>
                <a href="{html.escape(link_data.url)}" class="link-url" target="_blank">{html.escape(link_data.label)}</a>
"""
                    if link_data.about:
                        html_content += f"""                <div class="link-about">{html.escape(link_data.about)}</div>
"""
                    html_content += """            </li>
"""
                html_content += "        </ul>\n"
            else:
                html_content += """        <p>No direct links in this category.</p>
"""
            
            html_content += "    </div>\n"
            
            # Add subcategories
            for subcategory_name, subcategory_data in subcategories.items():
                html_content += f'    <h3 id="{html.escape(subcategory_data["id"])}">{html.escape(subcategory_name)}</h3>\n'
                html_content += '    <div class="links-container subcategory">\n'
                
                if subcategory_data["links"]:
                    html_content += "        <ul>\n"
                    for link_data in subcategory_data["links"]:
                        html_content += f"""            <li>
                <a href="{html.escape(link_data.url)}" class="link-url" target="_blank">{html.escape(link_data.label)}</a>
"""
                        if link_data.about:
                            html_content += f"""                <div class="link-about">{html.escape(link_data.about)}</div>
"""
                        html_content += """            </li>
"""
                    html_content += "        </ul>\n"
                else:
                    html_content += """        <p>No links in this subcategory.</p>
"""
                
                html_content += "    </div>\n"
        
        html_content += """</body>
</html>"""
        
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(html_content)
    
    def OnExit(self, event):
        self.Close()

class LinkDialog(wx.Dialog):
    def __init__(self, parent, title, url="", label="", about=""):
        super().__init__(parent, title=title, size=(500, 300))
        
        panel = wx.Panel(self)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        
        # URL input
        url_label = wx.StaticText(panel, label="URL:")
        self.url_text = wx.TextCtrl(panel, value=url, size=(450, -1))
        
        # Label input
        label_label = wx.StaticText(panel, label="Label:")
        self.label_text = wx.TextCtrl(panel, value=label, size=(450, -1))
        
        # About input
        self.about_label = wx.StaticText(panel, label="About:")
        self.about_text = wx.TextCtrl(panel, value=about, size=(450, 100), style=wx.TE_MULTILINE)
        
        # Buttons
        btn_sizer = wx.StdDialogButtonSizer()
        self.ok_btn = wx.Button(panel, wx.ID_OK)
        cancel_btn = wx.Button(panel, wx.ID_CANCEL)
        btn_sizer.AddButton(self.ok_btn)
        btn_sizer.AddButton(cancel_btn)
        btn_sizer.Realize()
        
        # Add to sizer
        self.sizer.Add(url_label, 0, wx.ALL, 5)
        self.sizer.Add(self.url_text, 0, wx.ALL|wx.EXPAND, 5)
        self.sizer.Add(label_label, 0, wx.ALL, 5)
        self.sizer.Add(self.label_text, 0, wx.ALL|wx.EXPAND, 5)
        
        # Only show about section if there's content or it's a new link
        if about or not url:
            self.sizer.Add(self.about_label, 0, wx.ALL, 5)
            self.sizer.Add(self.about_text, 1, wx.ALL|wx.EXPAND, 5)
        else:
            self.about_text.Hide()
            self.about_label.Hide()
        
        self.sizer.Add(btn_sizer, 0, wx.ALL|wx.ALIGN_CENTER, 5)
        
        panel.SetSizer(self.sizer)
        
        # Bind events
        self.ok_btn.Bind(wx.EVT_BUTTON, self.OnOK)
    
    def OnOK(self, event):
        """Validate fields before accepting"""
        url = self.url_text.GetValue().strip()
        label = self.label_text.GetValue().strip()
        
        if not url:
            wx.MessageBox("URL field cannot be empty.", "Validation Error", wx.OK | wx.ICON_WARNING)
            return
        
        if not label:
            result = wx.MessageBox("Link label is empty. Use the URL as the label?", 
                                "Empty Label", wx.YES_NO | wx.ICON_QUESTION)
            if result == wx.YES:
                # Set the label to URL and continue with dialog closure
                self.label_text.SetValue(url)
                # Don't call event.Skip() here, just accept the change and close manually
                self.EndModal(wx.ID_OK)
            # If user selects NO, do nothing and keep dialog open
            return
        
        # If we get here, validation passed
        event.Skip()  # Continue with dialog closure
    
    def GetValues(self):
        return (self.url_text.GetValue().strip(), 
                self.label_text.GetValue().strip(), 
                self.about_text.GetValue().strip())

class LinkManagerApp(wx.App):
    def OnInit(self):
        frame = LinkManagerFrame()
        frame.Show()
        return True

if __name__ == "__main__":
    app = LinkManagerApp()
    app.MainLoop()