Form1.cs

// Form1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Xml.Linq;
using System.Xml;
using Formatting = Newtonsoft.Json.Formatting;

namespace mnmVis
{
    public partial class Form1 : Form
    {
        private const string REGISTRY_KEY = @"Software\mnmVis";
        private const string REGISTRY_VALUE_DRIVE = "SelectedDrive";
        
        private GameDataManager gameDataManager;
        private string streamingAssetsPath = @"E:\SteamLibrary\steamapps\common\Heroes of Might & Magic Olden Era Demo\HeroesOE_Data\StreamingAssets";
        private bool isMapView = false;
        private List<GameEntity> mapEntities = new List<GameEntity>();
        
        // Navigation history
        private List<NavigationEntry> navigationHistory = new List<NavigationEntry>();
        private int navigationIndex = -1;
        private bool isNavigating = false;
        
        // Search functionality
        private List<TreeNode> searchResults = new List<TreeNode>();
        private int currentSearchIndex = -1;
        
        // Text search results
        private List<TextSearchResult> textSearchResults = new List<TextSearchResult>();
        private int currentTextSearchIndex = -1;
        private bool isTextSearchMode = false;
        
        // Edit mode
        private bool isEditMode = false;
        private GameEntity currentEditEntity = null;
        private JObject currentEditJObject = null;
        private string currentEditFilePath = null;
        private string editModeSnapshot = null; // Snapshot of content when entering edit mode
        private ListBox autocompleteListBox;
        private string lastAutocompleteWord = "";
        
        private class NavigationEntry
        {
            public TreeNode Node { get; set; }
            public string[] NodePath { get; set; }  // Path of node texts from root to target
            public object NodeTag { get; set; }     // The tag (GameEntity, JObject, etc.)
            public bool WasMapView { get; set; }    // Which view was active
        }

        public Form1()
        {
            InitializeComponent();
            PopulateDrives();
            InitializeAutocomplete();
            
            // Initialize button states - all edit buttons disabled at start
            btnEditToggle.Enabled = false;
            btnEditToggle.BackColor = SystemColors.ControlDark;
            btnEditToggle.ForeColor = SystemColors.GrayText;
            
            btnSaveJson.Enabled = false;
            btnSaveJson.BackColor = SystemColors.ControlDark;
            btnSaveJson.ForeColor = SystemColors.GrayText;
            
            btnSaveAndClose.Enabled = false;
            btnSaveAndClose.BackColor = SystemColors.ControlDark;
            btnSaveAndClose.ForeColor = SystemColors.GrayText;
            
            btnRestoreSnapshot.Enabled = false;
            btnRestoreSnapshot.BackColor = SystemColors.ControlDark;
            btnRestoreSnapshot.ForeColor = SystemColors.GrayText;
            
            btnCancelEdit.Enabled = false;
            btnCancelEdit.BackColor = SystemColors.ControlDark;
            btnCancelEdit.ForeColor = SystemColors.GrayText;
            
            panelEditButtons.Visible = true; // Always visible
            
            // Setup context menu for richTextBox
            SetupRichTextBoxContextMenu();
            
            gameDataManager = new GameDataManager();
            LoadGameData();
        }

        private void SetupRichTextBoxContextMenu()
        {
            ContextMenuStrip contextMenu = new ContextMenuStrip();
            
            ToolStripMenuItem copyItem = new ToolStripMenuItem("Copy", null, (s, e) => richTextBoxJson.Copy());
            copyItem.ShortcutKeys = Keys.Control | Keys.C;
            
            ToolStripMenuItem cutItem = new ToolStripMenuItem("Cut", null, (s, e) => richTextBoxJson.Cut());
            cutItem.ShortcutKeys = Keys.Control | Keys.X;
            
            ToolStripMenuItem pasteItem = new ToolStripMenuItem("Paste", null, (s, e) => richTextBoxJson.Paste());
            pasteItem.ShortcutKeys = Keys.Control | Keys.V;
            
            ToolStripMenuItem selectAllItem = new ToolStripMenuItem("Select All", null, (s, e) => richTextBoxJson.SelectAll());
            selectAllItem.ShortcutKeys = Keys.Control | Keys.A;
            
            contextMenu.Items.AddRange(new ToolStripItem[] { copyItem, cutItem, pasteItem, new ToolStripSeparator(), selectAllItem });
            
            // Enable/disable items based on edit mode
            contextMenu.Opening += (s, e) =>
            {
                copyItem.Enabled = richTextBoxJson.SelectionLength > 0;
                cutItem.Enabled = !richTextBoxJson.ReadOnly && richTextBoxJson.SelectionLength > 0;
                pasteItem.Enabled = !richTextBoxJson.ReadOnly && Clipboard.ContainsText();
            };
            
            richTextBoxJson.ContextMenuStrip = contextMenu;
            richTextBoxJson.ShortcutsEnabled = true;
        }

        private void LoadGameData()
        {
            try
            {
                toolStripStatusLabel1.Text = "Loading game data...";
                Application.DoEvents();

                gameDataManager.LoadAllJsonFiles(streamingAssetsPath);
                RefreshMapEntities();
                UpdateUI();

                toolStripStatusLabel1.Text = $"Loaded {gameDataManager.GetEntityCount()} entities successfully";
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error loading game data: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                toolStripStatusLabel1.Text = "Error loading data";
            }
        }

        private void RefreshMapEntities()
        {
            mapEntities.Clear();
            var allEntities = gameDataManager.GetEntitiesByType();

            foreach (var kvp in allEntities)
            {
                foreach (var entity in kvp.Value)
                {
                    if (entity.FilePath.Contains("map_templates") &&
                        Path.GetFileName(entity.FilePath).EndsWith(".rmg.json", StringComparison.OrdinalIgnoreCase))
                    {
                        mapEntities.Add(entity);
                    }
                }
            }
        }

        private void UpdateUI()
        {
            int entityCount = gameDataManager.GetEntityCount();
            lblEntityCount.Text = $"Entities: {entityCount} total | Maps: {mapEntities.Count}";
            Text = $"Heroes OE Mod Tool - Loaded {entityCount} entities";
            txtPath.Text = streamingAssetsPath;

            PopulateEntityTree();

            if (entityCount > 0)
            {
                toolStripStatusLabel1.Text = $"Loaded {entityCount} entities successfully";
            }
        }

        private void btnBrowsePath_Click(object sender, EventArgs e)
        {
            // Build full path from current drive and path
            string currentFullPath = GetFullPath();
            folderBrowserDialog1.SelectedPath = currentFullPath;
            
            if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
            {
                string selectedPath = folderBrowserDialog1.SelectedPath;
                
                // Extract drive letter and path
                if (selectedPath.Length >= 2 && selectedPath[1] == ':')
                {
                    string driveLetter = selectedPath.Substring(0, 2);
                    string pathWithoutDrive = selectedPath.Substring(2).TrimStart('\\');
                    
                    // Update drive combo box
                    for (int i = 0; i < cmbDrive.Items.Count; i++)
                    {
                        if (cmbDrive.Items[i].ToString() == driveLetter)
                        {
                            cmbDrive.SelectedIndex = i;
                            break;
                        }
                    }
                    
                    // Update path textbox (without drive)
                    txtPath.Text = pathWithoutDrive;
                }
                else
                {
                    txtPath.Text = selectedPath;
                }
                
                streamingAssetsPath = GetFullPath();
            }
        }

        private void btnRefresh_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(txtPath.Text))
            {
                streamingAssetsPath = GetFullPath();

                gameDataManager = new GameDataManager();
                mapEntities.Clear();
                treeViewEntities.Nodes.Clear();
                listViewReferences.BeginUpdate();
                try
                {
                    listViewReferences.Items.Clear();
                }
                finally
                {
                    listViewReferences.EndUpdate();
                }
                richTextBoxJson.Clear();
                lblSelectedEntity.Text = "Select an entity to view details";
                isMapView = false;
                mapToggle.Text = "Show Maps Only";

                // Clear navigation history
                navigationHistory.Clear();
                navigationIndex = -1;
                UpdateNavigationButtons();

                LoadGameData();
            }
            else
            {
                MessageBox.Show("Please select a valid StreamingAssets folder path.", "Invalid Path", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void mapToggle_Click(object sender, EventArgs e)
        {
            isMapView = !isMapView;
            mapToggle.Text = isMapView ? "Show All Entities" : "Show Maps Only";
            PopulateEntityTree();
            toolStripStatusLabel1.Text = isMapView ? $"Map view: Showing {mapEntities.Count} maps only" : "All entities view";
        }

        private void treeViewEntities_AfterSelect(object sender, TreeViewEventArgs e)
        {
            // Check if we're in edit mode and have unsaved changes
            if (isEditMode && !string.IsNullOrEmpty(editModeSnapshot))
            {
                // Check if content has changed
                if (richTextBoxJson.Text != editModeSnapshot)
                {
                    // Ask user what to do
                    DialogResult result = MessageBox.Show(
                        "You have unsaved changes. Do you want to save them before switching nodes?",
                        "Unsaved Changes",
                        MessageBoxButtons.YesNoCancel,
                        MessageBoxIcon.Question);
                    
                    if (result == DialogResult.Yes)
                    {
                        // Save changes
                        SaveJsonChanges();
                        ExitEditMode(false);
                    }
                    else if (result == DialogResult.No)
                    {
                        // Discard changes
                        ExitEditMode(false);
                    }
                    else // Cancel
                    {
                        // Stay in edit mode, prevent node selection change
                        return;
                    }
                }
                else
                {
                    // No changes, just exit edit mode silently
                    ExitEditMode(false);
                }
            }
            
            // If we're in map view and clicked on a top-level map entity, DON'T switch to full view
            // User wants to stay in map view and explore the map details
            if (isMapView && e.Node?.Tag is GameEntity entity)
            {
                // Check if this is a top-level map node (the map itself, not a zone/connection subitem)
                bool isTopLevelMap = false;
                if (e.Node.Parent != null && e.Node.Parent.Name.StartsWith("Mode_"))
                {
                    // Direct child of a mode grouping node = top-level map
                    isTopLevelMap = true;
                }
                
                // DON'T switch to full view when clicking map name - stay in map view
                // But for zone/connection subitems, switch to full view to see all relationships
                if (!isTopLevelMap && !IsMapEntity(entity))
                {
                    // For subitems (zones, connections), switch to full view to see all relationships
                    isMapView = false;
                    mapToggle.Text = "Show Maps Only";
                    
                    // Set navigating flag to prevent adding the intermediate node to history
                    isNavigating = true;
                    PopulateEntityTree();
                    FindAndSelectTreeNode(entity.Id);
                    isNavigating = false;
                    
                    toolStripStatusLabel1.Text = "Switched to full view - showing all entities and relationships";
                    
                    // Now add to history after we've switched views and selected the node
                    if (e.Node != null)
                    {
                        AddToNavigationHistory(e.Node);
                    }
                    return;
                }
            }

            // Add to navigation history (unless we're navigating via back/forward buttons)
            if (!isNavigating && e.Node != null)
            {
                AddToNavigationHistory(e.Node);
            }

            // Display entity details if the node has a GameEntity tag
            if (e.Node?.Tag is GameEntity selectedEntity)
            {
                DisplayEntityDetails(selectedEntity);
            }
            else if (e.Node?.Tag is JObject jobj)
            {
                // For JSON objects, find the parent zone/connection entity to show references
                GameEntity parentEntity = FindParentEntity(e.Node);
                
                if (parentEntity != null)
                {
                    // Display the JSON object but use parent entity for references
                    lblSelectedEntity.Text = $"{parentEntity.Type}: {parentEntity.Id} - {e.Node.Text}";
                    richTextBoxJson.Text = jobj.ToString(Formatting.Indented);
                    DisplayReferencesForEntity(parentEntity);
                }
                else
                {
                    // No parent entity, just show JSON
                    DisplayJsonObject(jobj, e.Node.Text);
                }
            }
            else if (e.Node?.Tag is JArray jarr)
            {
                // For JSON arrays, find the parent zone/connection entity to show references
                GameEntity parentEntity = FindParentEntity(e.Node);
                
                if (parentEntity != null)
                {
                    // Display the JSON array but use parent entity for references
                    lblSelectedEntity.Text = $"{parentEntity.Type}: {parentEntity.Id} - {e.Node.Text}";
                    richTextBoxJson.Text = jarr.ToString(Formatting.Indented);
                    DisplayReferencesForEntity(parentEntity);
                }
                else
                {
                    // No parent entity, just show JSON
                    DisplayJsonArray(jarr, e.Node.Text);
                }
            }
            else if (e.Node?.Tag is JToken jtoken)
            {
                // Display any other JSON token
                DisplayJsonToken(jtoken, e.Node.Text);
            }
            else
            {
                // For nodes without tags (grouping nodes), disable edit button
                btnEditToggle.Enabled = false;
                btnEditToggle.BackColor = SystemColors.ControlDark;
                btnEditToggle.ForeColor = SystemColors.GrayText;
                
                btnSaveJson.Enabled = false;
                btnSaveJson.BackColor = SystemColors.ControlDark;
                btnSaveJson.ForeColor = SystemColors.GrayText;
                
                btnSaveAndClose.Enabled = false;
                btnSaveAndClose.BackColor = SystemColors.ControlDark;
                btnSaveAndClose.ForeColor = SystemColors.GrayText;
                
                btnCancelEdit.Enabled = false;
                btnCancelEdit.BackColor = SystemColors.ControlDark;
                btnCancelEdit.ForeColor = SystemColors.GrayText;
                
                // Find parent entity to show references
                GameEntity parentEntity = FindParentEntity(e.Node);
                
                if (parentEntity != null)
                {
                    lblSelectedEntity.Text = $"{parentEntity.Type}: {parentEntity.Id} - {e.Node.Text}";
                    richTextBoxJson.Text = $"// {e.Node.Text}\n// This is a grouping node within {parentEntity.Id}. Expand to see subitems.";
                    DisplayReferencesForEntity(parentEntity);
                    toolStripStatusLabel1.Text = $"{parentEntity.Type}: {parentEntity.Id} - {e.Node.Text}";
                }
                else
                {
                    lblSelectedEntity.Text = $"Group: {e.Node.Text}";
                    richTextBoxJson.Text = $"// {e.Node.Text}\n// This is a grouping node. Expand to see subitems.";
                    listViewReferences.BeginUpdate();
                    try
                    {
                        listViewReferences.Items.Clear();
                    }
                    finally
                    {
                        listViewReferences.EndUpdate();
                    }
                    toolStripStatusLabel1.Text = $"Group: {e.Node.Text}";
                }
                
                RestoreRichTextBoxSize(); // Restore full size for non-editable content
               // btnEditToggle.Enabled = false; // Disable edit button for grouping nodes
            }
        }

        private bool IsMapEntity(GameEntity entity)
        {
            return entity.FilePath.Contains("map_templates") &&
                   Path.GetFileName(entity.FilePath).EndsWith(".rmg.json", StringComparison.OrdinalIgnoreCase);
        }

        private void treeViewEntities_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            if (ModifierKeys == Keys.Alt || ModifierKeys == Keys.Control)
            {
                treeViewEntities.BeginUpdate();
                try
                {
                    treeViewEntities.ExpandAll();
                    toolStripStatusLabel1.Text = "Expanded all nodes";
                }
                finally
                {
                    treeViewEntities.EndUpdate();
                }
            }
        }

        private void treeViewEntities_BeforeCollapse(object sender, TreeViewCancelEventArgs e)
        {
            if (ModifierKeys == Keys.Alt || ModifierKeys == Keys.Control)
            {
                treeViewEntities.BeginUpdate();
                try
                {
                    treeViewEntities.CollapseAll();
                    toolStripStatusLabel1.Text = "Collapsed all nodes";
                }
                finally
                {
                    treeViewEntities.EndUpdate();
                }
            }
        }

        private void treeViewEntities_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if (ModifierKeys == Keys.Alt || ModifierKeys == Keys.Control)
            {
                if (e.X <= 20)
                {
                    treeViewEntities.BeginUpdate();
                    try
                    {
                        if (e.Node.IsExpanded || HasExpandedChildren(e.Node))
                        {
                            treeViewEntities.CollapseAll();
                            toolStripStatusLabel1.Text = "Collapsed all nodes (Ctrl/Alt + Click)";
                        }
                        else
                        {
                            treeViewEntities.ExpandAll();
                            toolStripStatusLabel1.Text = "Expanded all nodes (Ctrl/Alt + Click)";
                        }
                    }
                    finally
                    {
                        treeViewEntities.EndUpdate();
                    }
                }
            }
        }

        private void btnToggleExpand_Click(object sender, EventArgs e)
        {
            treeViewEntities.BeginUpdate();
            try
            {
                if (btnToggleExpand.Text == "Collapse All")
                {
                    treeViewEntities.CollapseAll();
                    btnToggleExpand.Text = "Expand All";
                    toolStripStatusLabel1.Text = "Collapsed all nodes";
                }
                else
                {
                    treeViewEntities.ExpandAll();
                    btnToggleExpand.Text = "Collapse All";
                    toolStripStatusLabel1.Text = "Expanded all nodes";
                }
            }
            finally
            {
                treeViewEntities.EndUpdate();
            }
        }

        private bool HasExpandedChildren(TreeNode node)
        {
            foreach (TreeNode child in node.Nodes)
            {
                if (child.IsExpanded)
                    return true;
                if (HasExpandedChildren(child))
                    return true;
            }
            return false;
        }

        private void ResizeRichTextBoxForEditing()
        {
            // Do nothing - buttons are always visible at bottom
        }

        private void RestoreRichTextBoxSize()
        {
            // Do nothing - buttons are always visible at bottom
        }

        private void listViewReferences_SelectedIndexChanged(object sender, EventArgs e)
        {
            // Defer the actual handling to avoid conflicts with ListView internal processing
            BeginInvoke(new Action(() => HandleListViewSelection()));
        }

        private void HandleListViewSelection()
        {
            try
            {
                // Guard against invalid selections
                if (listViewReferences.SelectedItems.Count == 0 || 
                    listViewReferences.SelectedIndices.Count == 0)
                {
                    return;
                }
                
                // Validate the selected index is within bounds
                int selectedIndex = listViewReferences.SelectedIndices[0];
                if (selectedIndex < 0 || selectedIndex >= listViewReferences.Items.Count)
                {
                    return;
                }
                
                string entityId = listViewReferences.SelectedItems[0].Text;
                
                // Add current node to history BEFORE navigating away
                if (treeViewEntities.SelectedNode != null)
                {
                    AddToNavigationHistory(treeViewEntities.SelectedNode);
                }
                
                // Now navigate to the referenced entity
                GameEntity referencedEntity = gameDataManager.GetEntity(entityId);
                if (referencedEntity != null)
                {
                    // Set navigating flag to prevent adding duplicate history entry
                    isNavigating = true;
                    
                    // Find and select the tree node for this entity
                    bool found = FindAndSelectTreeNode(entityId);
                    
                    // If not found in current view, might need to switch views
                    if (!found)
                    {
                        // Check if it's a map entity and we're not in map view
                        if (IsMapEntity(referencedEntity) && !isMapView)
                        {
                            isMapView = true;
                            mapToggle.Text = "Show All Entities";
                            PopulateEntityTree();
                            FindAndSelectTreeNode(entityId);
                        }
                        else if (!IsMapEntity(referencedEntity) && isMapView)
                        {
                            isMapView = false;
                            mapToggle.Text = "Show Maps Only";
                            PopulateEntityTree();
                            FindAndSelectTreeNode(entityId);
                        }
                    }
                    
                    isNavigating = false;
                }
            }
            catch (ArgumentOutOfRangeException)
            {
                // Silently handle index out of range - likely a timing issue with selection
                return;
            }
            catch (Exception ex)
            {
                toolStripStatusLabel1.Text = $"Navigation error: {ex.Message}";
            }
        }

        private void PopulateEntityTree()
        {
            treeViewEntities.Nodes.Clear();

            if (isMapView)
            {
                var maps = gameDataManager.GetMapEntitiesWithDetails();
                var mapsByMode = maps.GroupBy(m =>
                {
                    try
                    {
                        return m.RawData["gameMode"]?.ToString() ?? "Unknown";
                    }
                    catch
                    {
                        return "Unknown";
                    }
                }).OrderBy(g => g.Key);

                foreach (var modeGroup in mapsByMode)
                {
                    TreeNode modeNode = new TreeNode($"{modeGroup.Key} Maps ({modeGroup.Count()})")
                    {
                        Name = $"Mode_{modeGroup.Key}",
                        ImageIndex = 0,
                        SelectedImageIndex = 0
                    };

                    foreach (var map in modeGroup.OrderBy(x => x.Name))
                    {
                        TreeNode mapNode = new TreeNode(map.Name)
                        {
                            Tag = map,
                            Name = map.Id,
                            ImageIndex = 1,
                            SelectedImageIndex = 1,
                            ToolTipText = map.ToolTipText
                        };

                        try
                        {
                            var zones = map.RawData["variants"]?[0]?["zones"] as JArray;
                            var connections = map.RawData["variants"]?[0]?["connections"] as JArray;
                            var contentLists = map.RawData["contentLists"] as JArray;

                            // Build dictionary of content pools from this map's contentLists
                            var mapContentPools = new Dictionary<string, GameEntity>();
                            if (contentLists != null)
                            {
                                foreach (var item in contentLists)
                                {
                                    string itemName = item["name"]?.ToString();
                                    if (!string.IsNullOrEmpty(itemName))
                                    {
                                        var contentEntity = new GameEntity
                                        {
                                            Id = itemName,
                                            Type = "content_pools",
                                            Name = itemName,
                                            FilePath = map.FilePath,
                                            RawData = item as JObject
                                        };
                                        mapContentPools[itemName] = contentEntity;
                                    }
                                }
                            }

                            // Create virtual GameEntity objects for each zone so they can be navigated
                            var zoneEntities = new Dictionary<string, GameEntity>();
                            var connectionEntities = new Dictionary<string, GameEntity>();
                            
                            if (zones != null)
                            {
                                foreach (var zone in zones)
                                {
                                    string zoneName = zone["name"]?.ToString();
                                    if (!string.IsNullOrEmpty(zoneName))
                                    {
                                        var zoneEntity = new GameEntity
                                        {
                                            Id = zoneName,  // Use just the zone name as ID so it can be found
                                            Type = "Zone",
                                            Name = zoneName,
                                            FilePath = map.FilePath,
                                            RawData = zone as JObject
                                        };
                                        zoneEntities[zoneName] = zoneEntity;
                                    }
                                }
                            }

                            // Create virtual GameEntity objects for connections
                            if (connections != null)
                            {
                                foreach (var conn in connections)
                                {
                                    string connName = conn["name"]?.ToString();
                                    if (!string.IsNullOrEmpty(connName))
                                    {
                                        var connEntity = new GameEntity
                                        {
                                            Id = connName,  // Connection name as ID
                                            Type = "Connection",
                                            Name = connName,
                                            FilePath = map.FilePath,
                                            RawData = conn as JObject
                                        };
                                        connectionEntities[connName] = connEntity;
                                    }
                                }
                            }

                            // Build references for all virtual entities
                            var allVirtualEntities = zoneEntities.Values.Concat(connectionEntities.Values).ToList();
                            foreach (var entity in allVirtualEntities)
                            {
                                BuildReferencesForEntity(entity, zoneEntities, connectionEntities);
                            }

                            // Add comprehensive zone breakdown
                            if (zones != null && zones.Count > 0)
                            {
                                // Group zones by type for better organization
                                var spawnZones = zones.Where(z => z["name"]?.ToString()?.StartsWith("Spawn-") == true).ToList();
                                var treasureZones = zones.Where(z => z["name"]?.ToString()?.StartsWith("Treasure-") == true).ToList();
                                var otherZones = zones.Where(z => !z["name"]?.ToString()?.StartsWith("Spawn-") == true &&
                                                                 !z["name"]?.ToString()?.StartsWith("Treasure-") == true).ToList();

                                // Spawn zones
                                if (spawnZones.Any())
                                {
                                    TreeNode spawnNode = new TreeNode($"Spawn Zones ({spawnZones.Count})")
                                    {
                                        ForeColor = Color.DarkGreen
                                    };
                                    foreach (var zone in spawnZones)
                                    {
                                        string zoneName = zone["name"]?.ToString() ?? "Unknown";
                                        var mainObjects = zone["mainObjects"] as JArray;
                                        string objInfo = mainObjects?.Count > 0 ? $" - {mainObjects.Count} objects" : "";

                                        TreeNode zoneNode = new TreeNode($"{zoneName}{objInfo}")
                                        {
                                            ForeColor = Color.DarkGreen
                                        };
                                        
                                        // Tag with the actual zone entity
                                        if (zoneEntities.ContainsKey(zoneName))
                                        {
                                            zoneNode.Tag = zoneEntities[zoneName];
                                            zoneNode.ToolTipText = $"Zone: {zoneName}\nLayout: {zone["layout"]}\nSize: {zone["size"]}";
                                        }
                                        
                                        // Add zone details as subitems
                                        AddZoneDetails(zoneNode, zone, zoneEntities, mapContentPools);
                                        
                                        spawnNode.Nodes.Add(zoneNode);
                                    }
                                    mapNode.Nodes.Add(spawnNode);
                                }

                                // Treasure zones
                                if (treasureZones.Any())
                                {
                                    TreeNode treasureNode = new TreeNode($"Treasure Zones ({treasureZones.Count})")
                                    {
                                        ForeColor = Color.DarkOrange
                                    };
                                    foreach (var zone in treasureZones)
                                    {
                                        string zoneName = zone["name"]?.ToString() ?? "Unknown";
                                        var mainObjects = zone["mainObjects"] as JArray;
                                        string objInfo = mainObjects?.Count > 0 ? $" - {mainObjects.Count} objects" : "";

                                        TreeNode zoneNode = new TreeNode($"{zoneName}{objInfo}")
                                        {
                                            ForeColor = Color.DarkOrange
                                        };
                                        
                                        // Tag with the actual zone entity
                                        if (zoneEntities.ContainsKey(zoneName))
                                        {
                                            zoneNode.Tag = zoneEntities[zoneName];
                                            zoneNode.ToolTipText = $"Zone: {zoneName}\nLayout: {zone["layout"]}\nSize: {zone["size"]}";
                                        }
                                        
                                        // Add zone details as subitems
                                        AddZoneDetails(zoneNode, zone, zoneEntities, mapContentPools);
                                        
                                        treasureNode.Nodes.Add(zoneNode);
                                    }
                                    mapNode.Nodes.Add(treasureNode);
                                }

                                // Other zones
                                if (otherZones.Any())
                                {
                                    TreeNode otherNode = new TreeNode($"Other Zones ({otherZones.Count})")
                                    {
                                        ForeColor = Color.Gray
                                    };
                                    foreach (var zone in otherZones)
                                    {
                                        string zoneName = zone["name"]?.ToString() ?? "Unknown";
                                        
                                        TreeNode zoneNode = new TreeNode(zoneName)
                                        {
                                            ForeColor = Color.Gray
                                        };
                                        
                                        // Tag with the actual zone entity
                                        if (zoneEntities.ContainsKey(zoneName))
                                        {
                                            zoneNode.Tag = zoneEntities[zoneName];
                                            zoneNode.ToolTipText = $"Zone: {zoneName}\nLayout: {zone["layout"]}\nSize: {zone["size"]}";
                                        }
                                        
                                        // Add zone details as subitems
                                        AddZoneDetails(zoneNode, zone, zoneEntities, mapContentPools);
                                        
                                        otherNode.Nodes.Add(zoneNode);
                                    }
                                    mapNode.Nodes.Add(otherNode);
                                }
                            }

                            // Add detailed road/connection analysis
                            if (connections != null && connections.Count > 0)
                            {
                                // Group connections by type
                                var roadConnections = connections.Where(c => c["road"]?.ToString() == "True").ToList();
                                var portalConnections = connections.Where(c => c["connectionType"]?.ToString() == "Portal").ToList();
                                var directConnections = connections.Where(c => c["connectionType"]?.ToString() == "Direct").ToList();

                                TreeNode connectionNode = new TreeNode($"Connections ({connections.Count})")
                                {
                                    ForeColor = Color.Purple
                                };

                                // Road network analysis
                                if (roadConnections.Any())
                                {
                                    TreeNode roadNode = new TreeNode($"Roads ({roadConnections.Count})")
                                    {
                                        ForeColor = Color.Brown
                                    };

                                    foreach (var road in roadConnections)
                                    {
                                        string roadName = road["name"]?.ToString() ?? "Unnamed";
                                        string roadType = road["connectionType"]?.ToString() ?? "Unknown";
                                        string guardValue = road["guardValue"]?.ToString();
                                        string guardIncrement = road["guardWeeklyIncrement"]?.ToString();
                                        string fromZone = road["from"]?.ToString() ?? "?";
                                        string toZone = road["to"]?.ToString() ?? "?";

                                        TreeNode roadItemNode = new TreeNode($"{roadName} ({fromZone} → {toZone})")
                                        {
                                            ForeColor = Color.Brown,
                                            ToolTipText = $"Type: {roadType}\n{fromZone} → {toZone}\nGuard: {guardValue}\nWeekly Increment: {guardIncrement}"
                                        };
                                        
                                        // Add subitems showing the zone endpoints
                                        if (!string.IsNullOrEmpty(fromZone) && fromZone != "?")
                                        {
                                            TreeNode fromNode = new TreeNode($"From: {fromZone}")
                                            {
                                                ForeColor = Color.DarkGreen
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(fromZone))
                                            {
                                                fromNode.Tag = zoneEntities[fromZone];
                                                var fromZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == fromZone);
                                                if (fromZoneData != null)
                                                {
                                                    fromNode.ToolTipText = $"Zone: {fromZone}\nLayout: {fromZoneData["layout"]}\nSize: {fromZoneData["size"]}";
                                                }
                                            }
                                            roadItemNode.Nodes.Add(fromNode);
                                        }
                                        
                                        if (!string.IsNullOrEmpty(toZone) && toZone != "?")
                                        {
                                            TreeNode toNode = new TreeNode($"To: {toZone}")
                                            {
                                                ForeColor = Color.DarkOrange
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(toZone))
                                            {
                                                toNode.Tag = zoneEntities[toZone];
                                                var toZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == toZone);
                                                if (toZoneData != null)
                                                {
                                                    toNode.ToolTipText = $"Zone: {toZone}\nLayout: {toZoneData["layout"]}\nSize: {toZoneData["size"]}";
                                                }
                                            }
                                            roadItemNode.Nodes.Add(toNode);
                                        }
                                        
                                        roadNode.Nodes.Add(roadItemNode);
                                    }
                                    connectionNode.Nodes.Add(roadNode);
                                }

                                // Portal connections
                                if (portalConnections.Any())
                                {
                                    TreeNode portalNode = new TreeNode($"Portals ({portalConnections.Count})")
                                    {
                                        ForeColor = Color.Magenta
                                    };
                                    foreach (var portal in portalConnections)
                                    {
                                        string portalName = portal["name"]?.ToString() ?? "Unnamed";
                                        string fromZone = portal["from"]?.ToString() ?? "?";
                                        string toZone = portal["to"]?.ToString() ?? "?";
                                        string guardValue = portal["guardValue"]?.ToString();
                                        string guardIncrement = portal["guardWeeklyIncrement"]?.ToString();

                                        TreeNode portalItemNode = new TreeNode($"{portalName} ({fromZone} ⟷ {toZone})")
                                        {
                                            ForeColor = Color.Magenta,
                                            ToolTipText = $"Portal\n{fromZone} ⟷ {toZone}\nGuard: {guardValue}\nWeekly Increment: {guardIncrement}"
                                        };
                                        
                                        // Add subitems showing the zone endpoints
                                        if (!string.IsNullOrEmpty(fromZone) && fromZone != "?")
                                        {
                                            TreeNode fromNode = new TreeNode($"From: {fromZone}")
                                            {
                                                ForeColor = Color.DarkGreen
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(fromZone))
                                            {
                                                fromNode.Tag = zoneEntities[fromZone];
                                                var fromZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == fromZone);
                                                if (fromZoneData != null)
                                                {
                                                    fromNode.ToolTipText = $"Zone: {fromZone}\nLayout: {fromZoneData["layout"]}\nSize: {fromZoneData["size"]}";
                                                }
                                            }
                                            portalItemNode.Nodes.Add(fromNode);
                                        }
                                        
                                        if (!string.IsNullOrEmpty(toZone) && toZone != "?")
                                        {
                                            TreeNode toNode = new TreeNode($"To: {toZone}")
                                            {
                                                ForeColor = Color.DarkOrange
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(toZone))
                                            {
                                                toNode.Tag = zoneEntities[toZone];
                                                var toZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == toZone);
                                                if (toZoneData != null)
                                                {
                                                    toNode.ToolTipText = $"Zone: {toZone}\nLayout: {toZoneData["layout"]}\nSize: {toZoneData["size"]}";
                                                }
                                            }
                                            portalItemNode.Nodes.Add(toNode);
                                        }
                                        
                                        portalNode.Nodes.Add(portalItemNode);
                                    }
                                    connectionNode.Nodes.Add(portalNode);
                                }

                                // Direct connections
                                if (directConnections.Any())
                                {
                                    TreeNode directNode = new TreeNode($"Direct Paths ({directConnections.Count})")
                                    {
                                        ForeColor = Color.DarkBlue
                                    };
                                    foreach (var direct in directConnections)
                                    {
                                        string directName = direct["name"]?.ToString() ?? "Unnamed";
                                        string fromZone = direct["from"]?.ToString() ?? "?";
                                        string toZone = direct["to"]?.ToString() ?? "?";
                                        string guardValue = direct["guardValue"]?.ToString();
                                        string guardIncrement = direct["guardWeeklyIncrement"]?.ToString();

                                        TreeNode directItemNode = new TreeNode($"{directName} ({fromZone} ↔ {toZone})")
                                        {
                                            ForeColor = Color.DarkBlue,
                                            ToolTipText = $"Direct Path\n{fromZone} ↔ {toZone}\nGuard: {guardValue}\nWeekly Increment: {guardIncrement}"
                                        };
                                        
                                        // Add subitems showing the zone endpoints
                                        if (!string.IsNullOrEmpty(fromZone) && fromZone != "?")
                                        {
                                            TreeNode fromNode = new TreeNode($"From: {fromZone}")
                                            {
                                                ForeColor = Color.DarkGreen
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(fromZone))
                                            {
                                                fromNode.Tag = zoneEntities[fromZone];
                                                var fromZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == fromZone);
                                                if (fromZoneData != null)
                                                {
                                                    fromNode.ToolTipText = $"Zone: {fromZone}\nLayout: {fromZoneData["layout"]}\nSize: {fromZoneData["size"]}";
                                                }
                                            }
                                            directItemNode.Nodes.Add(fromNode);
                                        }
                                        
                                        if (!string.IsNullOrEmpty(toZone) && toZone != "?")
                                        {
                                            TreeNode toNode = new TreeNode($"To: {toZone}")
                                            {
                                                ForeColor = Color.DarkOrange
                                            };
                                            
                                            // Tag with the actual zone entity
                                            if (zoneEntities.ContainsKey(toZone))
                                            {
                                                toNode.Tag = zoneEntities[toZone];
                                                var toZoneData = zones?.FirstOrDefault(z => z["name"]?.ToString() == toZone);
                                                if (toZoneData != null)
                                                {
                                                    toNode.ToolTipText = $"Zone: {toZone}\nLayout: {toZoneData["layout"]}\nSize: {toZoneData["size"]}";
                                                }
                                            }
                                            directItemNode.Nodes.Add(toNode);
                                        }
                                        
                                        directNode.Nodes.Add(directItemNode);
                                    }
                                    connectionNode.Nodes.Add(directNode);
                                }

                                mapNode.Nodes.Add(connectionNode);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Error adding detailed map analysis: {ex.Message}");
                        }

                        modeNode.Nodes.Add(mapNode);
                    }

                    treeViewEntities.Nodes.Add(modeNode);
                    modeNode.Expand();
                }
            }
            else
            {
                var entitiesByType = gameDataManager.GetEntitiesByType();

                foreach (var kvp in entitiesByType.OrderBy(x => x.Key))
                {
                    TreeNode typeNode = new TreeNode($"{kvp.Key} ({kvp.Value.Count})")
                    {
                        Name = kvp.Key,
                        ImageIndex = 0,
                        SelectedImageIndex = 0
                    };

                    foreach (var entity in kvp.Value.OrderBy(x => x.Name))
                    {
                        TreeNode entityNode = new TreeNode($"{entity.Name} ({entity.Id})")
                        {
                            Tag = entity,
                            Name = entity.Id,
                            ImageIndex = 1,
                            SelectedImageIndex = 1,
                            ToolTipText = $"Type: {entity.Type}\nFile: {Path.GetFileName(entity.FilePath)}\nReferences: {entity.References.Count}\nReferenced by: {entity.ReferencedBy.Count}"
                        };
                        typeNode.Nodes.Add(entityNode);
                    }

                    treeViewEntities.Nodes.Add(typeNode);
                }

                foreach (TreeNode node in treeViewEntities.Nodes)
                {
                    node.Expand();
                }
            }
        }


        private void DisplayEntityDetails(GameEntity entity)
        {
            lblSelectedEntity.Text = $"Entity: {entity.Name} (ID: {entity.Id}) - Type: {entity.Type}";

            listViewReferences.BeginUpdate();
            try
            {
                listViewReferences.Items.Clear();

                if (entity.References.Count > 0)
                {
                    foreach (var reference in entity.References)
                    {
                        ListViewItem item = new ListViewItem(reference.TargetEntityId);
                        item.SubItems.Add(reference.TargetEntityType);
                        item.SubItems.Add(reference.PropertyPath);
                        item.SubItems.Add("References");
                        item.ForeColor = Color.Blue;
                        listViewReferences.Items.Add(item);
                    }
                }

                if (entity.ReferencedBy.Count > 0)
                {
                    foreach (var reference in entity.ReferencedBy)
                    {
                        ListViewItem item = new ListViewItem(reference.TargetEntityId);
                        item.SubItems.Add(reference.TargetEntityType);
                        item.SubItems.Add(reference.PropertyPath);
                        item.SubItems.Add("Referenced by");
                        item.ForeColor = Color.Green;
                        listViewReferences.Items.Add(item);
                    }
                }
            }
            finally
            {
                listViewReferences.EndUpdate();
            }

            try
            {
                richTextBoxJson.Text = entity.RawData.ToString(Formatting.Indented);
                HighlightJsonSyntax();
                UpdateEditButtonState(); // Update edit button based on selection
                ResizeRichTextBoxForEditing(); // Resize to show edit buttons are available
                
                // Ensure save buttons are disabled when not in edit mode
                if (!isEditMode)
                {
                    btnSaveJson.Enabled = false;
                    btnSaveJson.BackColor = SystemColors.ControlDark;
                    btnSaveJson.ForeColor = SystemColors.GrayText;
                    
                    btnSaveAndClose.Enabled = false;
                    btnSaveAndClose.BackColor = SystemColors.ControlDark;
                    btnSaveAndClose.ForeColor = SystemColors.GrayText;
                    
                    btnCancelEdit.Enabled = false;
                    btnCancelEdit.BackColor = SystemColors.ControlDark;
                    btnCancelEdit.ForeColor = SystemColors.GrayText;
                }
            }
            catch
            {
                richTextBoxJson.Text = entity.RawData.ToString();
                btnEditToggle.Enabled = false; // Disable edit button for invalid JSON
                btnEditToggle.BackColor = SystemColors.ControlDark;
                btnEditToggle.ForeColor = SystemColors.GrayText;
                
                btnSaveJson.Enabled = false;
                btnSaveJson.BackColor = SystemColors.ControlDark;
                btnSaveJson.ForeColor = SystemColors.GrayText;
                
                btnSaveAndClose.Enabled = false;
                btnSaveAndClose.BackColor = SystemColors.ControlDark;
                btnSaveAndClose.ForeColor = SystemColors.GrayText;
                
                btnCancelEdit.Enabled = false;
                btnCancelEdit.BackColor = SystemColors.ControlDark;
                btnCancelEdit.ForeColor = SystemColors.GrayText;
                
                RestoreRichTextBoxSize(); // Hide edit buttons for invalid JSON
            }

            toolStripStatusLabel1.Text = $"Entity: {entity.Name} | References: {entity.References.Count} | Referenced by: {entity.ReferencedBy.Count} | File: {Path.GetFileName(entity.FilePath)} | EDITING AVAILABLE";
        }

        private GameEntity FindParentEntity(TreeNode node)
        {
            TreeNode current = node?.Parent;
            while (current != null)
            {
                if (current.Tag is GameEntity ge)
                {
                    return ge;
                }
                current = current.Parent;
            }
            return null;
        }

        private void DisplayReferencesForEntity(GameEntity entity)
        {
            listViewReferences.BeginUpdate();
            try
            {
                listViewReferences.Items.Clear();

                if (entity.References != null && entity.References.Count > 0)
                {
                    foreach (var reference in entity.References)
                    {
                        ListViewItem item = new ListViewItem(reference.TargetEntityId);
                        item.SubItems.Add(reference.TargetEntityType);
                        item.SubItems.Add(reference.PropertyPath);
                        item.SubItems.Add("References");
                        item.ForeColor = Color.Blue;
                        item.Tag = reference;
                        listViewReferences.Items.Add(item);
                    }
                }

                if (entity.ReferencedBy != null && entity.ReferencedBy.Count > 0)
                {
                    foreach (var reference in entity.ReferencedBy)
                    {
                        ListViewItem item = new ListViewItem(reference.TargetEntityId);
                        item.SubItems.Add(reference.TargetEntityType);
                        item.SubItems.Add(reference.PropertyPath);
                        item.SubItems.Add("Referenced by");
                        item.ForeColor = Color.Green;
                        item.Tag = reference;
                        listViewReferences.Items.Add(item);
                    }
                }
            }
            finally
            {
                listViewReferences.EndUpdate();
            }
        }

        private void DisplayJsonObject(JObject obj, string title)
        {
            lblSelectedEntity.Text = $"Object: {title}";
            listViewReferences.BeginUpdate();
            try
            {
                listViewReferences.Items.Clear();
            }
            finally
            {
                listViewReferences.EndUpdate();
            }
            
            try
            {
                richTextBoxJson.Text = obj.ToString(Formatting.Indented);
                HighlightJsonSyntax();
                UpdateEditButtonState(); // Update edit button based on selection
                ResizeRichTextBoxForEditing(); // Resize to show edit buttons are available
                
                // Ensure save buttons are disabled when not in edit mode
                if (!isEditMode)
                {
                    btnSaveJson.Enabled = false;
                    btnSaveJson.BackColor = SystemColors.ControlDark;
                    btnSaveJson.ForeColor = SystemColors.GrayText;
                    
                    btnSaveAndClose.Enabled = false;
                    btnSaveAndClose.BackColor = SystemColors.ControlDark;
                    btnSaveAndClose.ForeColor = SystemColors.GrayText;
                    
                    btnCancelEdit.Enabled = false;
                    btnCancelEdit.BackColor = SystemColors.ControlDark;
                    btnCancelEdit.ForeColor = SystemColors.GrayText;
                }
            }
            catch
            {
                richTextBoxJson.Text = obj.ToString();
                btnEditToggle.Enabled = false;
                btnEditToggle.BackColor = SystemColors.ControlDark;
                btnEditToggle.ForeColor = SystemColors.GrayText;
                
                btnSaveJson.Enabled = false;
                btnSaveJson.BackColor = SystemColors.ControlDark;
                btnSaveJson.ForeColor = SystemColors.GrayText;
                
                btnSaveAndClose.Enabled = false;
                btnSaveAndClose.BackColor = SystemColors.ControlDark;
                btnSaveAndClose.ForeColor = SystemColors.GrayText;
                
                btnCancelEdit.Enabled = false;
                btnCancelEdit.BackColor = SystemColors.ControlDark;
                btnCancelEdit.ForeColor = SystemColors.GrayText;
                
                RestoreRichTextBoxSize(); // Hide edit buttons
            }
            
            toolStripStatusLabel1.Text = $"Object: {title} | EDITING AVAILABLE";
        }

        private void DisplayJsonArray(JArray arr, string title)
        {
            lblSelectedEntity.Text = $"Array: {title} ({arr.Count} items)";
            listViewReferences.BeginUpdate();
            try
            {
                listViewReferences.Items.Clear();
            }
            finally
            {
                listViewReferences.EndUpdate();
            }
            
            try
            {
                richTextBoxJson.Text = arr.ToString(Formatting.Indented);
                HighlightJsonSyntax();
                ResizeRichTextBoxForEditing(); // Resize to show edit buttons are available
                
                // Ensure save buttons are disabled when not in edit mode
                if (!isEditMode)
                {
                    btnSaveJson.Enabled = false;
                    btnSaveJson.BackColor = SystemColors.ControlDark;
                    btnSaveJson.ForeColor = SystemColors.GrayText;
                    
                    btnSaveAndClose.Enabled = false;
                    btnSaveAndClose.BackColor = SystemColors.ControlDark;
                    btnSaveAndClose.ForeColor = SystemColors.GrayText;
                    
                    btnCancelEdit.Enabled = false;
                    btnCancelEdit.BackColor = SystemColors.ControlDark;
                    btnCancelEdit.ForeColor = SystemColors.GrayText;
                }
            }
            catch
            {
                richTextBoxJson.Text = arr.ToString();
                btnSaveJson.Enabled = false;
                btnSaveJson.BackColor = SystemColors.ControlDark;
                btnSaveJson.ForeColor = SystemColors.GrayText;
                
                btnSaveAndClose.Enabled = false;
                btnSaveAndClose.BackColor = SystemColors.ControlDark;
                btnSaveAndClose.ForeColor = SystemColors.GrayText;
                
                btnCancelEdit.Enabled = false;
                btnCancelEdit.BackColor = SystemColors.ControlDark;
                btnCancelEdit.ForeColor = SystemColors.GrayText;
                
                RestoreRichTextBoxSize(); // Hide edit buttons
            }
            
            toolStripStatusLabel1.Text = $"Array: {title} - {arr.Count} items | EDITING AVAILABLE";
        }

        private void DisplayJsonToken(JToken token, string title)
        {
            lblSelectedEntity.Text = $"Data: {title}";
            listViewReferences.BeginUpdate();
            try
            {
                listViewReferences.Items.Clear();
            }
            finally
            {
                listViewReferences.EndUpdate();
            }
            
            try
            {
                richTextBoxJson.Text = token.ToString(Formatting.Indented);
                HighlightJsonSyntax();
                ResizeRichTextBoxForEditing(); // Resize to show edit buttons are available
                
                // Ensure save buttons are disabled when not in edit mode
                if (!isEditMode)
                {
                    btnSaveJson.Enabled = false;
                    btnSaveJson.BackColor = SystemColors.ControlDark;
                    btnSaveJson.ForeColor = SystemColors.GrayText;
                    
                    btnSaveAndClose.Enabled = false;
                    btnSaveAndClose.BackColor = SystemColors.ControlDark;
                    btnSaveAndClose.ForeColor = SystemColors.GrayText;
                    
                    btnCancelEdit.Enabled = false;
                    btnCancelEdit.BackColor = SystemColors.ControlDark;
                    btnCancelEdit.ForeColor = SystemColors.GrayText;
                }
            }
            catch
            {
                richTextBoxJson.Text = token.ToString();
                btnSaveJson.Enabled = false;
                btnSaveJson.BackColor = SystemColors.ControlDark;
                btnSaveJson.ForeColor = SystemColors.GrayText;
                
                btnSaveAndClose.Enabled = false;
                btnSaveAndClose.BackColor = SystemColors.ControlDark;
                btnSaveAndClose.ForeColor = SystemColors.GrayText;
                
                btnCancelEdit.Enabled = false;
                btnCancelEdit.BackColor = SystemColors.ControlDark;
                btnCancelEdit.ForeColor = SystemColors.GrayText;
                
                RestoreRichTextBoxSize(); // Hide edit buttons
            }
            
            toolStripStatusLabel1.Text = $"Data: {title} | EDITING AVAILABLE";
        }

        private void BuildReferencesForEntity(GameEntity entity, Dictionary<string, GameEntity> zoneEntities, Dictionary<string, GameEntity> connectionEntities)
        {
            // Scan through all JSON properties looking for references to other entities
            FindReferencesInJsonToken(entity.RawData, entity, "", zoneEntities, connectionEntities);
        }

        private void FindReferencesInJsonToken(JToken token, GameEntity sourceEntity, string path, Dictionary<string, GameEntity> zoneEntities, Dictionary<string, GameEntity> connectionEntities)
        {
            if (token == null) return;

            switch (token.Type)
            {
                case JTokenType.Object:
                    foreach (var prop in ((JObject)token).Properties())
                    {
                        string newPath = string.IsNullOrEmpty(path) ? prop.Name : $"{path}.{prop.Name}";
                        FindReferencesInJsonToken(prop.Value, sourceEntity, newPath, zoneEntities, connectionEntities);
                    }
                    break;

                case JTokenType.Array:
                    JArray array = (JArray)token;
                    for (int i = 0; i < array.Count; i++)
                    {
                        FindReferencesInJsonToken(array[i], sourceEntity, $"{path}[{i}]", zoneEntities, connectionEntities);
                    }
                    break;

                case JTokenType.String:
                    string stringValue = token.ToString();
                    CheckForVirtualEntityReference(stringValue, sourceEntity, path, zoneEntities, connectionEntities);
                    break;
            }
        }

        private void CheckForVirtualEntityReference(string value, GameEntity sourceEntity, string path, Dictionary<string, GameEntity> zoneEntities, Dictionary<string, GameEntity> connectionEntities)
        {
            GameEntity targetEntity = null;

            // Check if it's a zone reference
            if (zoneEntities.ContainsKey(value))
            {
                targetEntity = zoneEntities[value];
            }
            // Check if it's a connection reference
            else if (connectionEntities.ContainsKey(value))
            {
                targetEntity = connectionEntities[value];
            }
            // Check if it's a global entity reference
            else
            {
                targetEntity = gameDataManager.GetEntity(value);
            }

            if (targetEntity != null)
            {
                EntityReference reference = new EntityReference
                {
                    TargetEntityId = targetEntity.Id,
                    TargetEntityType = targetEntity.Type,
                    PropertyPath = path,
                    ReferenceType = "direct"
                };

                sourceEntity.References.Add(reference);
                targetEntity.ReferencedBy.Add(new EntityReference
                {
                    TargetEntityId = sourceEntity.Id,
                    TargetEntityType = sourceEntity.Type,
                    PropertyPath = path,
                    ReferenceType = "direct"
                });
            }
        }

        private void AddZoneDetails(TreeNode zoneNode, JToken zone, Dictionary<string, GameEntity> zoneEntities, Dictionary<string, GameEntity> mapContentPools)
        {
            // Main Objects (cities, spawns, etc.)
            var mainObjects = zone["mainObjects"] as JArray;
            if (mainObjects != null && mainObjects.Count > 0)
            {
                TreeNode mainObjNode = new TreeNode($"Main Objects ({mainObjects.Count})")
                {
                    ForeColor = Color.Blue,
                    Tag = mainObjects  // Tag with the array so clicking shows all objects
                };
                
                foreach (var obj in mainObjects)
                {
                    string objType = obj["type"]?.ToString() ?? "Unknown";
                    string spawn = obj["spawn"]?.ToString();
                    string faction = obj["faction"]?["type"]?.ToString();
                    string displayText = objType;
                    if (!string.IsNullOrEmpty(spawn)) displayText += $" ({spawn})";
                    else if (!string.IsNullOrEmpty(faction)) displayText += $" (Faction: {faction})";
                    
                    TreeNode objNode = new TreeNode(displayText) 
                    { 
                        ForeColor = Color.Blue,
                        Tag = obj  // Tag with the individual object JSON
                    };
                    mainObjNode.Nodes.Add(objNode);
                }
                zoneNode.Nodes.Add(mainObjNode);
            }

            // Content Pools
            AddEntityArrayNode(zoneNode, zone, "guardedContentPool", "Guarded Content Pools", Color.DarkRed, mapContentPools);
            AddEntityArrayNode(zoneNode, zone, "unguardedContentPool", "Unguarded Content Pools", Color.DarkOliveGreen, mapContentPools);
            AddEntityArrayNode(zoneNode, zone, "resourcesContentPool", "Resource Content Pools", Color.DarkGoldenrod, mapContentPools);
            
            // Mandatory Content
            AddEntityArrayNode(zoneNode, zone, "mandatoryContent", "Mandatory Content", Color.Purple, mapContentPools);
            
            // Content Count Limits
            AddEntityArrayNode(zoneNode, zone, "contentCountLimits", "Content Limits", Color.Maroon, mapContentPools);

            // Layout reference
            string layout = zone["layout"]?.ToString();
            if (!string.IsNullOrEmpty(layout))
            {
                GameEntity layoutEntity = gameDataManager.GetEntity(layout);
                if (layoutEntity != null)
                {
                    TreeNode layoutNode = new TreeNode($"Layout: {layout}")
                    {
                        ForeColor = Color.DarkCyan,
                        Tag = layoutEntity
                    };
                    zoneNode.Nodes.Add(layoutNode);
                }
            }

            // Biome references
            AddBiomeNode(zoneNode, zone, "zoneBiome", "Zone Biome");
            AddBiomeNode(zoneNode, zone, "contentBiome", "Content Biome");
            AddBiomeNode(zoneNode, zone, "metaObjectsBiome", "Meta Objects Biome");
            
            // Roads within the zone
            var roads = zone["roads"] as JArray;
            if (roads != null && roads.Count > 0)
            {
                TreeNode roadsNode = new TreeNode($"Internal Roads ({roads.Count})")
                {
                    ForeColor = Color.SaddleBrown,
                    Tag = roads  // Tag with the array
                };
                
                foreach (var road in roads)
                {
                    string roadType = road["type"]?.ToString() ?? "Unknown";
                    string from = road["from"]?["type"]?.ToString() ?? "?";
                    string to = road["to"]?["type"]?.ToString() ?? "?";
                    
                    TreeNode roadNode = new TreeNode($"{roadType}: {from} → {to}")
                    {
                        ForeColor = Color.SaddleBrown,
                        Tag = road  // Tag with individual road JSON
                    };
                    roadsNode.Nodes.Add(roadNode);
                }
                zoneNode.Nodes.Add(roadsNode);
            }
        }

        private void AddEntityArrayNode(TreeNode parent, JToken zone, string propertyName, string displayName, Color color, Dictionary<string, GameEntity> mapContentPools)
        {
            var array = zone[propertyName] as JArray;
            if (array != null && array.Count > 0)
            {
                TreeNode arrayNode = new TreeNode($"{displayName} ({array.Count})")
                {
                    ForeColor = color,
                    Tag = array  // Tag with the array so clicking shows the content
                };
                
                int foundCount = 0;
                
                foreach (var item in array)
                {
                    string itemId = item.ToString();
                    // Look up in map's content pools first, then fall back to global
                    GameEntity entity = mapContentPools.ContainsKey(itemId) ? mapContentPools[itemId] : gameDataManager.GetEntity(itemId);
                    
                    if (entity != null)
                    {
                        foundCount++;
                        
                        // Found the entity - create node for it
                        TreeNode itemNode = new TreeNode(itemId)
                        {
                            ForeColor = color,
                            Tag = entity,  // Tag with the entity
                            ToolTipText = $"Type: {entity.Type}"
                        };
                        
                        // If it's a content pool, expand its contents
                        if (entity.Type == "content_pools" && entity.RawData != null)
                        {
                            var contentArray = entity.RawData["content"] as JArray;
                            if (contentArray != null && contentArray.Count > 0)
                            {
                                foreach (var contentItem in contentArray)
                                {
                                    string sid = contentItem["sid"]?.ToString() ?? "Unknown";
                                    int variant = contentItem["variant"]?.ToObject<int>() ?? -1;
                                    string variantText = variant >= 0 ? $" (Variant: {variant})" : "";
                                    
                                    TreeNode contentNode = new TreeNode($"{sid}{variantText}")
                                    {
                                        ForeColor = Color.DarkMagenta,
                                        Tag = contentItem
                                    };
                                    itemNode.Nodes.Add(contentNode);
                                }
                            }
                        }
                        
                        arrayNode.Nodes.Add(itemNode);
                    }
                    // Skip items that aren't found - don't add them to the tree
                }
                
                // Only add the array node if we found at least one valid item
                if (foundCount > 0)
                {
                    // Update the count to reflect only found items
                    arrayNode.Text = $"{displayName} ({foundCount})";
                    parent.Nodes.Add(arrayNode);
                }
            }
        }

        private void AddBiomeNode(TreeNode parent, JToken zone, string propertyName, string displayName)
        {
            var biome = zone[propertyName];
            if (biome != null)
            {
                string biomeType = biome["type"]?.ToString();
                if (!string.IsNullOrEmpty(biomeType))
                {
                    TreeNode biomeNode = new TreeNode($"{displayName}: {biomeType}")
                    {
                        ForeColor = Color.DarkSeaGreen,
                        Tag = biome  // Tag with the biome JToken
                    };
                    parent.Nodes.Add(biomeNode);
                }
            }
        }

        private bool FindAndSelectTreeNode(string entityId)
        {
            // Recursively search all nodes
            TreeNode found = FindNodeById(treeViewEntities.Nodes, entityId);
            
            if (found != null)
            {
                // Expand parent nodes to ensure visibility
                TreeNode parent = found.Parent;
                while (parent != null)
                {
                    parent.Expand();
                    parent = parent.Parent;
                }
                
                // Select and scroll to the node
                treeViewEntities.SelectedNode = found;
                treeViewEntities.Focus();
                found.EnsureVisible();
                
                // Flash the node to make navigation obvious
                FlashTreeNode(found);
                
                return true;
            }
            
            return false;
        }
        
        private TreeNode FindNodeById(TreeNodeCollection nodes, string entityId)
        {
            foreach (TreeNode node in nodes)
            {
                // Check if this node matches by Name or by GameEntity ID
                if (node.Name == entityId)
                {
                    return node;
                }
                
                if (node.Tag is GameEntity entity && entity.Id == entityId)
                {
                    return node;
                }
                
                // Recursively search children
                TreeNode found = FindNodeById(node.Nodes, entityId);
                if (found != null)
                {
                    return found;
                }
            }
            
            return null;
        }

        private void AddToNavigationHistory(TreeNode node)
        {
            if (isNavigating) return;
            if (node == null) return;

            // If we're not at the end of history, remove everything after current position
            if (navigationIndex < navigationHistory.Count - 1)
            {
                navigationHistory.RemoveRange(navigationIndex + 1, navigationHistory.Count - navigationIndex - 1);
            }

            // Build path from root to this node
            List<string> path = new List<string>();
            TreeNode current = node;
            while (current != null)
            {
                path.Insert(0, current.Text);
                current = current.Parent;
            }

            var entry = new NavigationEntry
            {
                Node = node,
                NodePath = path.ToArray(),
                NodeTag = node.Tag,
                WasMapView = isMapView
            };

            // Store both the node and the current view state
            navigationHistory.Add(entry);
            navigationIndex = navigationHistory.Count - 1;

            // Update button states
            UpdateNavigationButtons();
        }

        private void UpdateNavigationButtons()
        {
            btnBack.Enabled = navigationIndex > 0;
            btnForward.Enabled = navigationIndex < navigationHistory.Count - 1;
        }

        private void btnBack_Click(object sender, EventArgs e)
        {
            if (navigationIndex > 0)
            {
                navigationIndex--;
                isNavigating = true;
                
                NavigateToHistoryEntry(navigationHistory[navigationIndex]);
                
                isNavigating = false;
                UpdateNavigationButtons();
                toolStripStatusLabel1.Text = $"Navigated back ({navigationIndex + 1}/{navigationHistory.Count})";
            }
        }

        private void btnForward_Click(object sender, EventArgs e)
        {
            if (navigationIndex < navigationHistory.Count - 1)
            {
                navigationIndex++;
                isNavigating = true;
                
                NavigateToHistoryEntry(navigationHistory[navigationIndex]);
                
                isNavigating = false;
                UpdateNavigationButtons();
                toolStripStatusLabel1.Text = $"Navigated forward ({navigationIndex + 1}/{navigationHistory.Count})";
            }
        }

        private void NavigateToHistoryEntry(NavigationEntry entry)
        {
            // Switch to the correct view if needed
            if (entry.WasMapView != isMapView)
            {
                isMapView = entry.WasMapView;
                mapToggle.Text = isMapView ? "Show All Entities" : "Show Maps Only";
                PopulateEntityTree();
            }
            
            // Try to find the node by following the path
            TreeNode targetNode = FindNodeByPath(entry.NodePath);
            
            if (targetNode != null)
            {
                // Expand parent nodes to ensure visibility
                TreeNode parent = targetNode.Parent;
                while (parent != null)
                {
                    parent.Expand();
                    parent = parent.Parent;
                }
                
                // Select and scroll to the node
                treeViewEntities.SelectedNode = targetNode;
                treeViewEntities.Focus();
                targetNode.EnsureVisible();
                
                // Flash the node to make navigation obvious
                FlashTreeNode(targetNode);
            }
        }
        
        private void FlashTreeNode(TreeNode node)
        {
            if (node == null) return;
            
            // Store original colors
            Color originalBack = node.BackColor;
            Color originalFore = node.ForeColor;
            
            // Flash yellow background 2 times
            for (int i = 0; i < 2; i++)
            {
                node.BackColor = Color.Yellow;
                node.ForeColor = Color.Black;
                System.Threading.Thread.Sleep(150);
                Application.DoEvents(); // Process UI updates
                
                node.BackColor = originalBack;
                node.ForeColor = originalFore;
                System.Threading.Thread.Sleep(150);
                Application.DoEvents(); // Process UI updates
            }
        }
        
        private TreeNode FindNodeByPath(string[] path)
        {
            if (path == null || path.Length == 0) return null;
            
            TreeNode current = null;
            TreeNodeCollection nodes = treeViewEntities.Nodes;
            
            foreach (string nodeName in path)
            {
                TreeNode found = null;
                foreach (TreeNode node in nodes)
                {
                    if (node.Text == nodeName)
                    {
                        found = node;
                        break;
                    }
                }
                
                if (found == null) return null;
                
                current = found;
                nodes = current.Nodes;
            }
            
            return current;
        }

        private void HighlightJsonSyntax()
        {
            richTextBoxJson.SelectAll();
            richTextBoxJson.SelectionColor = Color.Black;

            string text = richTextBoxJson.Text;

            for (int i = 0; i < text.Length - 1; i++)
            {
                if (text[i] == '"')
                {
                    int start = i;
                    i++;

                    while (i < text.Length && text[i] != '"')
                    {
                        if (text[i] == '\\' && i + 1 < text.Length)
                            i++;
                        i++;
                    }

                    if (i < text.Length)
                    {
                        richTextBoxJson.Select(start, i - start + 1);

                        int nextNonWhitespace = i + 1;
                        while (nextNonWhitespace < text.Length && char.IsWhiteSpace(text[nextNonWhitespace]))
                            nextNonWhitespace++;

                        if (nextNonWhitespace < text.Length && nextNonWhitespace >= 0 && text[nextNonWhitespace] == ':')
                        {
                            richTextBoxJson.SelectionColor = Color.DarkBlue; // Property names
                        }
                        else
                        {
                            richTextBoxJson.SelectionColor = Color.DarkGreen; // String values
                        }
                    }
                }
            }

            richTextBoxJson.Select(0, 0);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Extract drive and path from streamingAssetsPath
            if (streamingAssetsPath.Length >= 2 && streamingAssetsPath[1] == ':')
            {
                string driveLetter = streamingAssetsPath.Substring(0, 2);
                string pathWithoutDrive = streamingAssetsPath.Substring(2).TrimStart('\\');
                
                // Try to select the drive in the combo box
                for (int i = 0; i < cmbDrive.Items.Count; i++)
                {
                    if (cmbDrive.Items[i].ToString() == driveLetter)
                    {
                        cmbDrive.SelectedIndex = i;
                        break;
                    }
                }
                
                txtPath.Text = pathWithoutDrive;
            }
            else
            {
                txtPath.Text = streamingAssetsPath;
            }
            
            lblSelectedEntity.Text = "Select an entity to view details";
            
            // Ensure edit buttons are on top of richTextBox
            btnEditToggle.BringToFront();
            panelEditButtons.BringToFront();

            if (listViewReferences.Columns.Count == 3)
            {
                listViewReferences.Columns.Add("Direction", 100);
            }

            // Initialize navigation buttons as disabled
            UpdateNavigationButtons();
            
            // Ensure status bar doesn't show editing available on startup
            toolStripStatusLabel1.Text = "Ready - Select an entity to view details";
        }

        // Search functionality
        private void btnToggleSearch_Click(object sender, EventArgs e)
        {
            ToggleSearchPanel();
        }

        private void ToggleSearchPanel()
        {
            panelSearch.Visible = !panelSearch.Visible;
            
            // Adjust tree view dock so scrollbar isn't hidden
            if (panelSearch.Visible)
            {
                treeViewEntities.Dock = DockStyle.None;
                treeViewEntities.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
                treeViewEntities.Height = groupBox1.ClientSize.Height - panelSearch.Height - 19;
            }
            else
            {
                treeViewEntities.Anchor = AnchorStyles.None;
                treeViewEntities.Dock = DockStyle.Fill;
            }
            
            if (panelSearch.Visible)
            {
                txtSearch.Focus();
                txtSearch.SelectAll();
            }
        }

        private void btnCloseSearch_Click(object sender, EventArgs e)
        {
            ToggleSearchPanel();
            ClearSearch();
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            // Handle Ctrl+F to toggle search panel
            if (keyData == (Keys.Control | Keys.F))
            {
                ToggleSearchPanel();
                return true;
            }
            return base.ProcessCmdKey(ref msg, keyData);
        }

        private void txtSearch_TextChanged(object sender, EventArgs e)
        {
            string searchText = txtSearch.Text.Trim();
            
            // Only search if 3 or more characters
            if (searchText.Length >= 3)
            {
                PerformSearch(searchText);
            }
            else
            {
                ClearSearch();
            }
        }

        private void PerformSearch(string searchText)
        {
            searchResults.Clear();
            textSearchResults.Clear();
            currentSearchIndex = -1;
            currentTextSearchIndex = -1;
            
            treeViewEntities.BeginUpdate();
            try
            {
                // Clear any previous highlighting
                ClearSearchHighlighting(treeViewEntities.Nodes);
                
                if (isTextSearchMode)
                {
                    // Perform exhaustive text search through entity JSON content
                    PerformTextSearch(treeViewEntities.Nodes, searchText.ToLowerInvariant());
                    
                    if (textSearchResults.Count > 0)
                    {
                        currentTextSearchIndex = 0;
                        HighlightTextSearchResults();
                        
                        // Navigate to first result
                        NavigateToTextSearchResult(0);
                        
                        // Update label and show navigation buttons
                        lblSearchResults.Text = $"{currentTextSearchIndex + 1} of {textSearchResults.Count} (text)";
                        btnSearchPrev.Visible = true;
                        btnSearchNext.Visible = true;
                    }
                    else
                    {
                        lblSearchResults.Text = "No text results";
                        btnSearchPrev.Visible = false;
                        btnSearchNext.Visible = false;
                    }
                }
                else
                {
                    // Search through all nodes (original entity search)
                    SearchNodes(treeViewEntities.Nodes, searchText.ToLowerInvariant());
                    
                    // Highlight and expand results
                    if (searchResults.Count > 0)
                    {
                        currentSearchIndex = 0;
                        HighlightSearchResults();
                        
                        // Navigate to first result
                        NavigateToSearchResult(0);
                        
                        // Update label and show navigation buttons
                        lblSearchResults.Text = $"{currentSearchIndex + 1} of {searchResults.Count}";
                        btnSearchPrev.Visible = true;
                        btnSearchNext.Visible = true;
                    }
                    else
                    {
                        lblSearchResults.Text = "No results";
                        btnSearchPrev.Visible = false;
                        btnSearchNext.Visible = false;
                    }
                }
            }
            finally
            {
                treeViewEntities.EndUpdate();
            }
        }

        private void SearchNodes(TreeNodeCollection nodes, string searchText)
        {
            foreach (TreeNode node in nodes)
            {
                // Search in node text
                if (node.Text.ToLowerInvariant().Contains(searchText))
                {
                    searchResults.Add(node);
                }
                
                // Also search in entity ID if the node has a GameEntity tag
                if (node.Tag is GameEntity entity)
                {
                    if (entity.Id.ToLowerInvariant().Contains(searchText) && !searchResults.Contains(node))
                    {
                        searchResults.Add(node);
                    }
                }
                
                // Recursively search child nodes
                if (node.Nodes.Count > 0)
                {
                    SearchNodes(node.Nodes, searchText);
                }
            }
        }

        private void PerformTextSearch(TreeNodeCollection nodes, string searchText)
        {
            foreach (TreeNode node in nodes)
            {
                // Search in entity JSON content
                if (node.Tag is GameEntity entity)
                {
                    SearchInJsonToken(entity.RawData, entity, node, searchText, "");
                }
                else if (node.Tag is JObject jobj)
                {
                    var parentEntity = FindParentEntity(node);
                    if (parentEntity != null)
                    {
                        SearchInJsonToken(jobj, parentEntity, node, searchText, "");
                    }
                }
                else if (node.Tag is JArray jarr)
                {
                    var parentEntity = FindParentEntity(node);
                    if (parentEntity != null)
                    {
                        SearchInJsonToken(jarr, parentEntity, node, searchText, "");
                    }
                }
                
                // Recursively search child nodes
                if (node.Nodes.Count > 0)
                {
                    PerformTextSearch(node.Nodes, searchText);
                }
            }
        }

        private void SearchInJsonToken(JToken token, GameEntity entity, TreeNode node, string searchText, string path)
        {
            if (token == null) return;

            switch (token.Type)
            {
                case JTokenType.Object:
                    foreach (var prop in ((JObject)token).Properties())
                    {
                        string newPath = string.IsNullOrEmpty(path) ? prop.Name : $"{path}.{prop.Name}";
                        SearchInJsonToken(prop.Value, entity, node, searchText, newPath);
                    }
                    break;

                case JTokenType.Array:
                    JArray array = (JArray)token;
                    for (int i = 0; i < array.Count; i++)
                    {
                        SearchInJsonToken(array[i], entity, node, searchText, $"{path}[{i}]");
                    }
                    break;

                case JTokenType.String:
                    string stringValue = token.ToString();
                    if (stringValue.ToLowerInvariant().Contains(searchText))
                    {
                        AddTextSearchResult(entity, node, path, stringValue, searchText);
                    }
                    break;

                case JTokenType.Integer:
                case JTokenType.Float:
                case JTokenType.Boolean:
                    string valueStr = token.ToString();
                    if (valueStr.ToLowerInvariant().Contains(searchText))
                    {
                        AddTextSearchResult(entity, node, path, valueStr, searchText);
                    }
                    break;
            }
        }

        private void AddTextSearchResult(GameEntity entity, TreeNode node, string path, string value, string searchText)
        {
            // Store the full path and value - we'll calculate position later in the actual richTextBox
            // Count how many results we already have for this entity to track occurrence index
            int occurrenceIndex = textSearchResults.Count(r => r.Entity == entity);

            textSearchResults.Add(new TextSearchResult
            {
                Entity = entity,
                Node = node,
                PropertyPath = path,
                MatchedText = value,
                CharacterPosition = occurrenceIndex, // Use this to track which occurrence within entity
                LineNumber = 0 // Will be calculated when displaying
            });
        }

        private void HighlightTextSearchResults()
        {
            // Highlight the nodes that contain text matches
            var uniqueNodes = textSearchResults.Select(r => r.Node).Distinct();
            foreach (var node in uniqueNodes)
            {
                node.BackColor = Color.LightGreen;
                node.ForeColor = Color.Black;
            }
        }

        private void NavigateToTextSearchResult(int index)
        {
            if (index < 0 || index >= textSearchResults.Count) return;
            
            TextSearchResult result = textSearchResults[index];
            
            // Expand to and select the node
            ExpandToNode(result.Node);
            treeViewEntities.SelectedNode = result.Node;
            result.Node.EnsureVisible();
            currentTextSearchIndex = index;
            
            // Update the richTextBox to show the entity and scroll to the match
            DisplayEntityDetails(result.Entity);
            
            // Scroll to and highlight the matched text in richTextBox
            ScrollToAndHighlightTextInRichTextBox(result);
            
            lblSearchResults.Text = $"{currentTextSearchIndex + 1} of {textSearchResults.Count} (text) - {result.PropertyPath}";
        }

        private void ScrollToAndHighlightTextInRichTextBox(TextSearchResult result)
        {
            // Save txtSearch cursor position and focus state
            bool txtSearchHadFocus = txtSearch.Focused;
            int txtSearchCursorPos = txtSearch.SelectionStart;
            
            string jsonText = richTextBoxJson.Text;
            string searchText = txtSearch.Text.Trim();
            
            // Find all occurrences and highlight them
            int startIndex = 0;
            List<int> allPositions = new List<int>();
            
            richTextBoxJson.SelectAll();
            richTextBoxJson.SelectionBackColor = Color.White;
            
            while (startIndex < jsonText.Length)
            {
                int foundIndex = jsonText.IndexOf(searchText, startIndex, StringComparison.OrdinalIgnoreCase);
                if (foundIndex == -1) break;
                
                allPositions.Add(foundIndex);
                richTextBoxJson.Select(foundIndex, searchText.Length);
                richTextBoxJson.SelectionBackColor = Color.Yellow;
                
                startIndex = foundIndex + searchText.Length;
            }
            
            // Find the correct occurrence based on the property path
            // Re-calculate position in the actual richTextBox text
            int targetPos = FindPositionInRichTextBox(result, jsonText, searchText);
            
            // Scroll to and select the specific occurrence
            if (targetPos >= 0 && targetPos < jsonText.Length)
            {
                richTextBoxJson.Select(targetPos, searchText.Length);
                richTextBoxJson.SelectionBackColor = Color.Orange; // Different color for current match
                richTextBoxJson.ScrollToCaret();
            }
            
            // Restore focus to txtSearch if it had focus
            if (txtSearchHadFocus)
            {
                txtSearch.Focus();
                txtSearch.SelectionStart = txtSearchCursorPos;
                txtSearch.SelectionLength = 0;
            }
        }
        
        private int FindPositionInRichTextBox(TextSearchResult result, string jsonText, string searchText)
        {
            // Find ALL occurrences of the search text in the richTextBox
            List<int> allOccurrences = new List<int>();
            int startIndex = 0;
            
            while (startIndex < jsonText.Length)
            {
                int foundIndex = jsonText.IndexOf(searchText, startIndex, StringComparison.OrdinalIgnoreCase);
                if (foundIndex == -1) break;
                
                allOccurrences.Add(foundIndex);
                startIndex = foundIndex + searchText.Length;
            }
            
            // Get the occurrence index for this result
            // Count how many results come before this one for the same entity
            int occurrenceIndex = 0;
            for (int i = 0; i < textSearchResults.Count; i++)
            {
                if (textSearchResults[i] == result)
                {
                    break;
                }
                if (textSearchResults[i].Entity == result.Entity)
                {
                    occurrenceIndex++;
                }
            }
            
            // Return the nth occurrence position
            if (occurrenceIndex < allOccurrences.Count)
            {
                return allOccurrences[occurrenceIndex];
            }
            
            // Fallback: try to find by property path
            string propertyName = "";
            if (!string.IsNullOrEmpty(result.PropertyPath))
            {
                var parts = result.PropertyPath.Split('.');
                var lastPart = parts[parts.Length - 1];
                propertyName = lastPart.Replace("[", "").Replace("]", "");
                if (int.TryParse(propertyName, out _))
                {
                    if (parts.Length > 1)
                    {
                        propertyName = parts[parts.Length - 2].Replace("[", "").Replace("]", "");
                    }
                }
            }
            
            int searchStart = 0;
            if (!string.IsNullOrEmpty(propertyName))
            {
                string pattern = $"\"{propertyName}\"";
                int propIndex = jsonText.IndexOf(pattern, StringComparison.OrdinalIgnoreCase);
                if (propIndex >= 0)
                {
                    searchStart = propIndex;
                }
            }
            
            return jsonText.IndexOf(searchText, searchStart, StringComparison.OrdinalIgnoreCase);
        }

        private void HighlightSearchResults()
        {
            foreach (var node in searchResults)
            {
                node.BackColor = Color.Yellow;
                node.ForeColor = Color.Black;
            }
        }

        private void ClearSearchHighlighting(TreeNodeCollection nodes)
        {
            foreach (TreeNode node in nodes)
            {
                node.BackColor = Color.White;
                // Restore original foreground color (preserve existing colors)
                if (node.ForeColor == Color.Black || node.BackColor == Color.Yellow)
                {
                    node.ForeColor = node.ForeColor; // Keep existing color
                }
                
                if (node.Nodes.Count > 0)
                {
                    ClearSearchHighlighting(node.Nodes);
                }
            }
        }

        private void ExpandToNode(TreeNode node)
        {
            TreeNode parent = node.Parent;
            while (parent != null)
            {
                parent.Expand();
                parent = parent.Parent;
            }
        }

        private void ClearSearch()
        {
            searchResults.Clear();
            textSearchResults.Clear();
            currentSearchIndex = -1;
            currentTextSearchIndex = -1;
            lblSearchResults.Text = "";
            btnSearchPrev.Visible = false;
            btnSearchNext.Visible = false;
            
            treeViewEntities.BeginUpdate();
            try
            {
                ClearSearchHighlighting(treeViewEntities.Nodes);
            }
            finally
            {
                treeViewEntities.EndUpdate();
            }
            
            // Clear highlighting in richTextBox
            if (richTextBoxJson.Text.Length > 0)
            {
                richTextBoxJson.SelectAll();
                richTextBoxJson.SelectionBackColor = Color.White;
                richTextBoxJson.Select(0, 0);
            }
        }

        private void NavigateToSearchResult(int index)
        {
            if (index < 0 || index >= searchResults.Count) return;
            
            TreeNode result = searchResults[index];
            ExpandToNode(result);
            treeViewEntities.SelectedNode = result;
            result.EnsureVisible();
            currentSearchIndex = index;
            
            lblSearchResults.Text = $"{currentSearchIndex + 1} of {searchResults.Count}";
        }

        private void btnSearchPrev_Click(object sender, EventArgs e)
        {
            if (isTextSearchMode)
            {
                if (textSearchResults.Count == 0) return;
                
                int newIndex = currentTextSearchIndex - 1;
                if (newIndex < 0) newIndex = textSearchResults.Count - 1; // Wrap to end
                
                NavigateToTextSearchResult(newIndex);
            }
            else
            {
                if (searchResults.Count == 0) return;
                
                int newIndex = currentSearchIndex - 1;
                if (newIndex < 0) newIndex = searchResults.Count - 1; // Wrap to end
                
                NavigateToSearchResult(newIndex);
            }
        }

        private void btnSearchNext_Click(object sender, EventArgs e)
        {
            if (isTextSearchMode)
            {
                if (textSearchResults.Count == 0) return;
                
                int newIndex = currentTextSearchIndex + 1;
                if (newIndex >= textSearchResults.Count) newIndex = 0; // Wrap to start
                
                NavigateToTextSearchResult(newIndex);
            }
            else
            {
                if (searchResults.Count == 0) return;
                
                int newIndex = currentSearchIndex + 1;
                if (newIndex >= searchResults.Count) newIndex = 0; // Wrap to start
                
                NavigateToSearchResult(newIndex);
            }
        }

        private void chkSearchText_CheckedChanged(object sender, EventArgs e)
        {
            isTextSearchMode = chkSearchText.Checked;
            
            // Re-perform search if there's already text in the search box
            string searchText = txtSearch.Text.Trim();
            if (searchText.Length >= 3)
            {
                PerformSearch(searchText);
            }
            else
            {
                ClearSearch();
            }
        }

        // Drive selector functionality
        private void PopulateDrives()
        {
            cmbDrive.Items.Clear();
            
            // Get all logical drives
            DriveInfo[] drives = DriveInfo.GetDrives();
            
            foreach (DriveInfo drive in drives)
            {
                // Add drive letter with colon (e.g., "E:")
                if (drive.IsReady)
                {
                    cmbDrive.Items.Add(drive.Name.Substring(0, 2));
                }
            }
            
            // Load saved drive from registry or default to E: or C:
            string savedDrive = LoadSelectedDriveFromRegistry();
            
            if (!string.IsNullOrEmpty(savedDrive))
            {
                // Try to select saved drive
                for (int i = 0; i < cmbDrive.Items.Count; i++)
                {
                    if (cmbDrive.Items[i].ToString() == savedDrive)
                    {
                        cmbDrive.SelectedIndex = i;
                        return;
                    }
                }
            }
            
            // If saved drive not found, default to E: if available
            for (int i = 0; i < cmbDrive.Items.Count; i++)
            {
                if (cmbDrive.Items[i].ToString() == "E:")
                {
                    cmbDrive.SelectedIndex = i;
                    return;
                }
            }
            
            // If E: not available, fallback to C:
            for (int i = 0; i < cmbDrive.Items.Count; i++)
            {
                if (cmbDrive.Items[i].ToString() == "C:")
                {
                    cmbDrive.SelectedIndex = i;
                    return;
                }
            }
            
            // If nothing selected, select first available drive
            if (cmbDrive.Items.Count > 0)
            {
                cmbDrive.SelectedIndex = 0;
            }
        }

        private string LoadSelectedDriveFromRegistry()
        {
            try
            {
                using (var key = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(REGISTRY_KEY))
                {
                    if (key != null)
                    {
                        return key.GetValue(REGISTRY_VALUE_DRIVE) as string;
                    }
                }
            }
            catch
            {
                // Ignore errors reading registry
            }
            
            return null;
        }

        private void SaveSelectedDriveToRegistry(string drive)
        {
            try
            {
                using (var key = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(REGISTRY_KEY))
                {
                    if (key != null)
                    {
                        key.SetValue(REGISTRY_VALUE_DRIVE, drive);
                    }
                }
            }
            catch
            {
                // Ignore errors writing registry
            }
        }

        private void cmbDrive_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cmbDrive.SelectedItem != null)
            {
                string selectedDrive = cmbDrive.SelectedItem.ToString();
                SaveSelectedDriveToRegistry(selectedDrive);
                
                // Update the streaming assets path with new drive
                streamingAssetsPath = GetFullPath();
            }
        }

        private string GetFullPath()
        {
            if (cmbDrive.SelectedItem == null || string.IsNullOrEmpty(txtPath.Text))
            {
                return txtPath.Text;
            }
            
            string drive = cmbDrive.SelectedItem.ToString();
            string path = StripDriveLetter(txtPath.Text);
            
            return drive + "\\" + path;
        }
        
        private string StripDriveLetter(string path)
        {
            if (string.IsNullOrEmpty(path))
                return path;
                
            path = path.TrimStart('\\');
            
            // Remove any drive letter and colon from the path (e.g., "E:" or "E:\")
            if (path.Length >= 2 && path[1] == ':')
            {
                path = path.Substring(2).TrimStart('\\');
            }
            
            return path;
        }
        
        private void txtPath_TextChanged(object sender, EventArgs e)
        {
            // Strip any drive letters from the path automatically
            string currentText = txtPath.Text;
            string strippedText = StripDriveLetter(currentText);
            
            if (currentText != strippedText)
            {
                int cursorPos = txtPath.SelectionStart;
                txtPath.Text = strippedText;
                // Restore cursor position, accounting for removed characters
                txtPath.SelectionStart = Math.Max(0, cursorPos - (currentText.Length - strippedText.Length));
            }
        }
    }

    public class GameEntity
    {
        public string Id { get; set; }
        public string Type { get; set; }
        public string Name { get; set; }
        public string FilePath { get; set; }
        public JObject RawData { get; set; }
        public string ToolTipText { get; set; }
        public List<EntityReference> References { get; set; }
        public List<EntityReference> ReferencedBy { get; set; }

        public GameEntity()
        {
            References = new List<EntityReference>();
            ReferencedBy = new List<EntityReference>();
        }
    }

    public class EntityReference
    {
        public string TargetEntityId { get; set; }
        public string TargetEntityType { get; set; }
        public string PropertyPath { get; set; }
        public string ReferenceType { get; set; }
    }

    public class GameDataManager
    {
        private readonly Dictionary<string, GameEntity> entities;
        private readonly Dictionary<string, List<GameEntity>> entitiesByType;
        private readonly Dictionary<string, List<string>> fileTypeMapping;

        public GameDataManager()
        {
            entities = new Dictionary<string, GameEntity>();
            entitiesByType = new Dictionary<string, List<GameEntity>>();
            fileTypeMapping = new Dictionary<string, List<string>>();
        }

        public void LoadAllJsonFiles(string rootPath)
        {
            if (!Directory.Exists(rootPath))
            {
                throw new DirectoryNotFoundException($"Path not found: {rootPath}");
            }

            entities.Clear();
            entitiesByType.Clear();
            fileTypeMapping.Clear();

            LoadEntitiesFromDirectory(rootPath);
            BuildEntityRelationships();
            AnalyzeMapTemplates(Path.Combine(rootPath, "map_templates"));
        }

        private void LoadEntitiesFromDirectory(string dirPath)
        {
            foreach (string file in Directory.GetFiles(dirPath, "*.json", SearchOption.AllDirectories))
            {
                // Skip files in .vs folders (Visual Studio workspace files)
                if (file.Contains("\\.vs\\") || file.Contains("/.vs/"))
                {
                    continue;
                }
                
                try
                {
                    LoadEntitiesFromFile(file);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error loading {file}: {ex.Message}");
                }
            }
        }

        private void LoadEntitiesFromFile(string filePath)
        {
            string json = File.ReadAllText(filePath);
            string fileName = Path.GetFileNameWithoutExtension(filePath);

            // Track file types for better organization
            string fileType = DetermineFileType(filePath);
            if (!fileTypeMapping.ContainsKey(fileType))
            {
                fileTypeMapping[fileType] = new List<string>();
            }
            fileTypeMapping[fileType].Add(filePath);

            try
            {
                JToken root = JToken.Parse(json);

                if (root.Type == JTokenType.Array)
                {
                    JArray array = (JArray)root;
                    for (int i = 0; i < array.Count; i++)
                    {
                        ProcessEntity(array[i], filePath, fileType, $"{fileName}[{i}]");
                    }
                }
                else if (root.Type == JTokenType.Object)
                {
                    ProcessEntityOrContainer(root, filePath, fileType, fileName);
                }
            }
            catch (JsonException ex)
            {
                Console.WriteLine($"JSON parsing error in {filePath}: {ex.Message}");
            }
        }

        private void ProcessEntityOrContainer(JToken token, string filePath, string fileType, string baseName)
        {
            JObject obj = (JObject)token;

            bool isContainer = obj.Properties().All(p => p.Value.Type == JTokenType.Object);

            if (isContainer && obj.Properties().Count() > 1)
            {
                foreach (var prop in obj.Properties())
                {
                    ProcessEntity(prop.Value, filePath, fileType, prop.Name);
                }
            }
            else
            {
                ProcessEntity(token, filePath, fileType, baseName);
            }
        }

        private void ProcessEntity(JToken entityToken, string filePath, string fileType, string entityName)
        {
            if (entityToken.Type != JTokenType.Object) return;

            JObject entityObj = (JObject)entityToken;

            string entityId = ExtractEntityId(entityObj, entityName);

            if (entities.ContainsKey(entityId))
            {
                entityId = $"{entityId}_{Path.GetFileNameWithoutExtension(filePath)}";
            }

            GameEntity entity = new GameEntity
            {
                Id = entityId,
                Type = fileType,
                Name = ExtractEntityName(entityObj, entityName),
                FilePath = filePath,
                RawData = entityObj
            };

            entities[entityId] = entity;

            if (!entitiesByType.ContainsKey(fileType))
            {
                entitiesByType[fileType] = new List<GameEntity>();
            }
            entitiesByType[fileType].Add(entity);
            
            // Extract embedded content lists and content pools from map templates
            if (filePath.Contains("map_templates"))
            {
                ExtractEmbeddedContentLists(entityObj, filePath);
            }
        }

        private void ExtractEmbeddedContentLists(JObject mapObj, string filePath)
        {
            // Extract contentLists array (contains content_pools and contentCountLimits)
            var contentLists = mapObj["contentLists"] as JArray;
            if (contentLists != null && contentLists.Count > 0)
            {
                foreach (var item in contentLists)
                {
                    if (item is JObject itemObj)
                    {
                        string itemName = itemObj["name"]?.ToString();
                        if (!string.IsNullOrEmpty(itemName))
                        {
                            // Use unique ID if duplicate
                            string uniqueId = itemName;
                            if (entities.ContainsKey(itemName))
                            {
                                uniqueId = $"{itemName}_{Path.GetFileNameWithoutExtension(filePath)}";
                            }
                            
                            GameEntity contentEntity = new GameEntity
                            {
                                Id = uniqueId,
                                Type = "content_pools",
                                Name = itemName,
                                FilePath = filePath,
                                RawData = itemObj
                            };
                            
                            entities[uniqueId] = contentEntity;
                            
                            // ALSO add with original name if not already there
                            if (!entities.ContainsKey(itemName))
                            {
                                entities[itemName] = contentEntity;
                            }
                            
                            if (!entitiesByType.ContainsKey("content_pools"))
                            {
                                entitiesByType["content_pools"] = new List<GameEntity>();
                            }
                            entitiesByType["content_pools"].Add(contentEntity);
                        }
                    }
                }
            }
        }

        private string ExtractEntityId(JObject obj, string fallbackName)
        {
            string[] idFields = { "id", "ID", "Id", "name", "Name", "key", "Key" };

            foreach (string field in idFields)
            {
                JToken idToken = obj[field];
                if (idToken != null && idToken.Type == JTokenType.String)
                {
                    string idValue = idToken.ToString();
                    if (!string.IsNullOrWhiteSpace(idValue))
                    {
                        return idValue;
                    }
                }
            }

            return fallbackName;
        }

        private string ExtractEntityName(JObject obj, string fallbackName)
        {
            string[] nameFields = { "name", "Name", "displayName", "title", "Title", "label", "Label" };

            foreach (string field in nameFields)
            {
                JToken nameToken = obj[field];
                if (nameToken != null && nameToken.Type == JTokenType.String)
                {
                    string nameValue = nameToken.ToString();
                    if (!string.IsNullOrWhiteSpace(nameValue))
                    {
                        return nameValue;
                    }
                }
            }

            return fallbackName;
        }

        private string DetermineFileType(string fullPath)
        {
            string directory = Path.GetDirectoryName(fullPath);
            string folderName = Path.GetFileName(directory);
            if (string.IsNullOrEmpty(folderName) || folderName.Equals("StreamingAssets", StringComparison.OrdinalIgnoreCase))
            {
                return "root";
            }
            return folderName;
        }

        private string GetRelativePath(string fullPath, string basePath)
        {
            if (fullPath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
            {
                return fullPath.Substring(basePath.Length).TrimStart('\\', '/');
            }
            return Path.GetFileName(fullPath);
        }

        private void BuildEntityRelationships()
        {
            foreach (var entity in entities.Values)
            {
                FindReferencesInEntity(entity);
            }
        }

        private void FindReferencesInEntity(GameEntity entity)
        {
            FindReferencesInToken(entity.RawData, entity, "");
        }

        private void FindReferencesInToken(JToken token, GameEntity sourceEntity, string path)
        {
            switch (token.Type)
            {
                case JTokenType.Object:
                    foreach (var prop in ((JObject)token).Properties())
                    {
                        string newPath = string.IsNullOrEmpty(path) ? prop.Name : $"{path}.{prop.Name}";
                        FindReferencesInToken(prop.Value, sourceEntity, newPath);
                    }
                    break;

                case JTokenType.Array:
                    JArray array = (JArray)token;
                    for (int i = 0; i < array.Count; i++)
                    {
                        FindReferencesInToken(array[i], sourceEntity, $"{path}[{i}]");
                    }
                    break;

                case JTokenType.String:
                    string stringValue = token.ToString();
                    CheckForEntityReference(stringValue, sourceEntity, path);
                    break;
            }
        }

        private void CheckForEntityReference(string value, GameEntity sourceEntity, string path)
        {
            if (entities.ContainsKey(value))
            {
                GameEntity targetEntity = entities[value];

                EntityReference reference = new EntityReference
                {
                    TargetEntityId = targetEntity.Id,
                    TargetEntityType = targetEntity.Type,
                    PropertyPath = path,
                    ReferenceType = "direct"
                };

                sourceEntity.References.Add(reference);
                targetEntity.ReferencedBy.Add(new EntityReference
                {
                    TargetEntityId = sourceEntity.Id,
                    TargetEntityType = sourceEntity.Type,
                    PropertyPath = path,
                    ReferenceType = "direct"
                });
            }
        }

        private void AnalyzeMapTemplates(string mapTemplatesPath)
        {
            if (!Directory.Exists(mapTemplatesPath)) return;

            foreach (string mapFile in Directory.GetFiles(mapTemplatesPath, "*.json"))
            {
                try
                {
                    AnalyzeMapTemplate(mapFile);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error analyzing map template {mapFile}: {ex.Message}");
                }
            }
        }

        private void AnalyzeMapTemplate(string mapFilePath)
        {
            string json = File.ReadAllText(mapFilePath);
            JObject mapData = JObject.Parse(json);
            // hook for future specific analysis
        }

        // Public interface methods
        public int GetEntityCount() => entities.Count;

        public Dictionary<string, List<GameEntity>> GetEntitiesByType() => entitiesByType;

        public GameEntity GetEntity(string id)
        {
            entities.TryGetValue(id, out GameEntity entity);
            return entity;
        }

        public List<string> GetAllEntityIds()
        {
            return entities.Keys.ToList();
        }

        public List<GameEntity> GetEntitiesOfType(string type)
        {
            entitiesByType.TryGetValue(type, out List<GameEntity> typeEntities);
            return typeEntities ?? new List<GameEntity>();
        }

        public Dictionary<string, List<string>> GetFileTypeMapping() => fileTypeMapping;

        // Map helpers (single, correct implementation)
        public List<GameEntity> GetMapEntitiesWithDetails()
        {
            var maps = new List<GameEntity>();
            foreach (var kvp in entitiesByType)
            {
                foreach (var entity in kvp.Value)
                {
                    if (entity.FilePath.Contains("map_templates") &&
                        Path.GetFileName(entity.FilePath).EndsWith(".rmg.json", StringComparison.OrdinalIgnoreCase))
                    {
                        EnhanceMapEntity(entity);
                        maps.Add(entity);
                    }
                }
            }
            return maps;
        }

        private void EnhanceMapEntity(GameEntity mapEntity)
        {
            try
            {
                var mapData = mapEntity.RawData;
                var zones = mapData["variants"]?[0]?["zones"] as JArray;
                var connections = mapData["variants"]?[0]?["connections"] as JArray;

                int zoneCount = zones?.Count ?? 0;
                int connectionCount = connections?.Count ?? 0;

                var gameMode = mapData["gameMode"]?.ToString() ?? "Unknown";
                var sizeX = mapData["sizeX"]?.ToString() ?? "?";
                var sizeZ = mapData["sizeZ"]?.ToString() ?? "?";

                // Detailed zone analysis
                int spawnZones = 0, treasureZones = 0, otherZones = 0;
                if (zones != null)
                {
                    foreach (var zone in zones)
                    {
                        string zoneName = zone["name"]?.ToString() ?? "";
                        if (zoneName.StartsWith("Spawn-")) spawnZones++;
                        else if (zoneName.StartsWith("Treasure-")) treasureZones++;
                        else otherZones++;
                    }
                }

                // Road network analysis
                int roadConnections = 0, portalConnections = 0, directConnections = 0;
                if (connections != null)
                {
                    foreach (var connection in connections)
                    {
                        string connectionType = connection["connectionType"]?.ToString() ?? "";
                        bool hasRoad = connection["road"]?.ToString() == "True";

                        if (connectionType == "Portal") portalConnections++;
                        else if (connectionType == "Direct") directConnections++;

                        if (hasRoad) roadConnections++;
                    }
                }

                mapEntity.Name = $"{mapData["name"]} ({gameMode} {sizeX}x{sizeZ})";

                mapEntity.ToolTipText =
                    $"Map: {mapData["name"]}\n" +
                    $"Mode: {gameMode} | Size: {sizeX}x{sizeZ}\n" +
                    $"Zones: {zoneCount} ({spawnZones} spawns, {treasureZones} treasures, {otherZones} other)\n" +
                    $"Connections: {connectionCount} ({roadConnections} roads, {portalConnections} portals, {directConnections} direct)\n" +
                    $"Road Network: {(roadConnections > 0 ? "Yes" : "No")}\n" +
                    $"File: {Path.GetFileName(mapEntity.FilePath)}";
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error enhancing map entity: {ex.Message}");
            }
        }
    }

    public class TextSearchResult
    {
        public GameEntity Entity { get; set; }
        public TreeNode Node { get; set; }
        public string PropertyPath { get; set; }
        public string MatchedText { get; set; }
        public int CharacterPosition { get; set; }
        public int LineNumber { get; set; }
        
        public override string ToString()
        {
            return $"{Entity?.Name ?? "Unknown"} - {PropertyPath}: {MatchedText}";
        }
    }
}