using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
using Core;

namespace Editor
{
    /// <summary>
    /// Custom dockable log window with advanced filtering capabilities.
    /// Supports filtering by class, method, log level, time range, and text search.
    /// Multiple instances can be opened with independent filter states.
    /// 
    /// PERFORMANCE NOTE: For large log counts (10,000+), consider implementing virtualized scrolling.
    /// Only render visible entries within the scroll view to avoid GUI overhead.
    /// See DrawLogEntries() method for potential optimization location.
    /// </summary>
    public class CustomLogWindow : EditorWindow
    {
        #region Window State
        
        private Vector2 scrollPosition;
        private readonly List<LogEntry> allLogs = new List<LogEntry>();
        
        #endregion
        
        #region Filter State
        
        private HashSet<string> activeClassTags = new HashSet<string>();
        private HashSet<string> activeMethodTags = new HashSet<string>();
        private HashSet<string> selectedClassFilters = new HashSet<string>();
        private HashSet<string> selectedMethodFilters = new HashSet<string>();
        private HashSet<LogLevel> selectedLevelFilters = new HashSet<LogLevel> 
        { 
            LogLevel.Debug, LogLevel.Info, LogLevel.Warning, LogLevel.Error 
        };
        private string searchText = "";
        private bool autoScroll = true;
        
        // Time range filtering
        private bool enableTimeFilter = false;
        private float minTimestamp = 0;
        private float maxTimestamp = 0;
        private float currentMaxTimestamp = 0;
        
        #endregion
        
        #region UI State
        
        // Colors for log levels
        private readonly Color debugColor = Color.white;
        private readonly Color infoColor = Color.white;
        private readonly Color warningColor = Color.yellow;
        private readonly Color errorColor = new Color(1f, 0.3f, 0.3f);
        
        // Alternating row background colors
        private readonly Color evenRowColor = new Color(0.22f, 0.22f, 0.22f);
        private readonly Color oddRowColor = new Color(0.26f, 0.26f, 0.26f);
        
        #endregion
        
        #region Menu Items
        
        [MenuItem("AppleHills/Custom Log Console")]
        public static void ShowWindow()
        {
            var window = GetWindow<CustomLogWindow>("Custom Log");
            window.Show();
        }
        
        #endregion
        
        #region Unity Lifecycle
        
        private void OnEnable()
        {
            // Subscribe to new log events
            Logging.OnLogEntryAdded += OnLogAdded;
            
            // Load existing logs
            allLogs.AddRange(Logging.GetRecentLogs());
            
            // Build initial tag lists
            RebuildTagLists();
            
            // Initialize time range
            UpdateTimeRange();
        }
        
        private void OnDisable()
        {
            Logging.OnLogEntryAdded -= OnLogAdded;
        }
        
        private void OnLogAdded(LogEntry entry)
        {
            allLogs.Add(entry);
            
            // Update active tags
            activeClassTags.Add(entry.ClassName);
            activeMethodTags.Add(entry.MethodName);
            
            // Update time range
            UpdateTimeRange();
            
            if (autoScroll)
                scrollPosition.y = float.MaxValue;
            
            Repaint(); // Redraw window
        }
        
        #endregion
        
        #region GUI Drawing
        
        private void OnGUI()
        {
            DrawToolbar();
            DrawLogEntries();
        }
        
        private void DrawToolbar()
        {
            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
            
            // Clear button
            if (GUILayout.Button("Clear", EditorStyles.toolbarButton, GUILayout.Width(50)))
            {
                allLogs.Clear();
                activeClassTags.Clear();
                activeMethodTags.Clear();
                Logging.ClearLogs();
                Repaint();
            }
            
            // Auto-scroll toggle
            autoScroll = GUILayout.Toggle(autoScroll, "Auto-scroll", EditorStyles.toolbarButton, GUILayout.Width(80));
            
            GUILayout.Space(10);
            
            // Class Filter Button
            string classLabel = selectedClassFilters.Count == 0 ? "Classes: All" : 
                               selectedClassFilters.Count == activeClassTags.Count ? "Classes: All" :
                               $"Classes: {selectedClassFilters.Count}";
            if (GUILayout.Button(new GUIContent(classLabel, "Filter by class"), EditorStyles.toolbarDropDown, GUILayout.Width(100)))
            {
                ShowClassFilterMenu();
            }
            
            // Method Filter Button
            string methodLabel = selectedMethodFilters.Count == 0 ? "Methods: All" : 
                                selectedMethodFilters.Count == activeMethodTags.Count ? "Methods: All" :
                                $"Methods: {selectedMethodFilters.Count}";
            if (GUILayout.Button(new GUIContent(methodLabel, "Filter by method"), EditorStyles.toolbarDropDown, GUILayout.Width(110)))
            {
                ShowMethodFilterMenu();
            }
            
            // Log Level Filter Button
            string levelLabel = selectedLevelFilters.Count == 4 ? "Levels: All" :
                               selectedLevelFilters.Count == 0 ? "Levels: None" :
                               $"Levels: {selectedLevelFilters.Count}";
            if (GUILayout.Button(new GUIContent(levelLabel, "Filter by log level"), EditorStyles.toolbarDropDown, GUILayout.Width(90)))
            {
                ShowLevelFilterMenu();
            }
            
            // Time Range Filter Button
            if (GUILayout.Button(new GUIContent("⏱", "Time range filter"), EditorStyles.toolbarButton, GUILayout.Width(25)))
            {
                ShowTimeRangeWindow();
            }
            
            GUILayout.FlexibleSpace();
            
            // Search box
            GUILayout.Label("Search:", GUILayout.Width(50));
            searchText = GUILayout.TextField(searchText, EditorStyles.toolbarSearchField, GUILayout.Width(150));
            
            GUILayout.Space(10);
            
            // Export button
            if (GUILayout.Button("Export", EditorStyles.toolbarButton, GUILayout.Width(60)))
            {
                ExportLogs();
            }
            
            GUILayout.Space(5);
            
            // Log count
            var filteredCount = GetFilteredLogs().Count();
            GUILayout.Label($"{filteredCount}/{allLogs.Count}", GUILayout.Width(80));
            
            EditorGUILayout.EndHorizontal();
        }
        
        private void ShowClassFilterMenu()
        {
            ClassFilterWindow.ShowWindow(this, activeClassTags, selectedClassFilters, 
                (newSelection) =>
                {
                    selectedClassFilters = newSelection;
                    Repaint();
                });
        }
        
        private void ShowMethodFilterMenu()
        {
            MethodFilterWindow.ShowWindow(this, activeMethodTags, selectedMethodFilters,
                (newSelection) =>
                {
                    selectedMethodFilters = newSelection;
                    Repaint();
                });
        }
        
        private void ShowLevelFilterMenu()
        {
            LevelFilterWindow.ShowWindow(this, selectedLevelFilters,
                (newSelection) =>
                {
                    selectedLevelFilters = newSelection;
                    Repaint();
                });
        }
        
        private void ShowTimeRangeWindow()
        {
            TimeRangeFilterWindow.ShowWindow(this, enableTimeFilter, minTimestamp, maxTimestamp, currentMaxTimestamp,
                (enabled, min, max) =>
                {
                    enableTimeFilter = enabled;
                    minTimestamp = min;
                    maxTimestamp = max;
                    Repaint();
                });
        }
        
        private void DrawLogEntries()
        {
            // PERFORMANCE NOTE: For 10,000+ logs, consider virtualized scrolling here.
            // Only render entries visible within the scroll view rect.
            // Current implementation renders all filtered logs which may cause GUI slowdown.
            
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
            
            var filteredLogs = GetFilteredLogs().ToList();
            
            for (int i = 0; i < filteredLogs.Count; i++)
            {
                DrawLogEntry(filteredLogs[i], i);
            }
            
            EditorGUILayout.EndScrollView();
        }
        
        private void DrawLogEntry(LogEntry entry, int index)
        {
            // Draw alternating row background
            Color bgColor = (index % 2 == 0) ? evenRowColor : oddRowColor;
            Rect rowRect = EditorGUILayout.BeginHorizontal();
            EditorGUI.DrawRect(rowRect, bgColor);
            
            // Color-code by log level
            Color color = GetColorForLevel(entry.Level);
            var originalColor = GUI.contentColor;
            GUI.contentColor = color;
            
            // Timestamp
            GUILayout.Label($"[{entry.Timestamp:F2}s]", GUILayout.Width(80));
            
            // Level
            GUILayout.Label($"[{entry.Level}]", GUILayout.Width(70));
            
            // Class
            GUILayout.Label($"[{entry.ClassName}]", GUILayout.Width(150));
            
            // Method
            GUILayout.Label($"[{entry.MethodName}]", GUILayout.Width(150));
            
            // Message
            GUILayout.Label(entry.Message, GUILayout.ExpandWidth(true));
            
            EditorGUILayout.EndHorizontal();
            
            GUI.contentColor = originalColor;
            
            // Right-click context menu
            if (Event.current.type == EventType.ContextClick && rowRect.Contains(Event.current.mousePosition))
            {
                GenericMenu menu = new GenericMenu();
                
                menu.AddItem(new GUIContent("Copy Full Message"), false, () => 
                {
                    EditorGUIUtility.systemCopyBuffer = entry.FullFormattedMessage;
                });
                
                menu.AddItem(new GUIContent("Copy Message Only"), false, () =>
                {
                    EditorGUIUtility.systemCopyBuffer = entry.Message;
                });
                
                menu.AddSeparator("");
                
                menu.AddItem(new GUIContent("Filter to this Class"), false, () =>
                {
                    selectedClassFilters.Clear();
                    selectedClassFilters.Add(entry.ClassName);
                    Repaint();
                });
                
                menu.AddItem(new GUIContent("Filter to this Method"), false, () =>
                {
                    selectedMethodFilters.Clear();
                    selectedMethodFilters.Add(entry.MethodName);
                    Repaint();
                });
                
                menu.AddItem(new GUIContent("Filter to this Class + Method"), false, () =>
                {
                    selectedClassFilters.Clear();
                    selectedClassFilters.Add(entry.ClassName);
                    selectedMethodFilters.Clear();
                    selectedMethodFilters.Add(entry.MethodName);
                    Repaint();
                });
                
                menu.AddSeparator("");
                
                menu.AddItem(new GUIContent("Filter to this Log Level"), false, () =>
                {
                    selectedLevelFilters.Clear();
                    selectedLevelFilters.Add(entry.Level);
                    Repaint();
                });
                
                menu.ShowAsContext();
                Event.current.Use();
            }
        }
        
        #endregion
        
        #region Filtering Logic
        
        private IEnumerable<LogEntry> GetFilteredLogs()
        {
            return allLogs.Where(entry =>
            {
                // Filter by class (if any selected)
                if (selectedClassFilters.Count > 0 && !selectedClassFilters.Contains(entry.ClassName))
                    return false;
                
                // Filter by method (if any selected)
                if (selectedMethodFilters.Count > 0 && !selectedMethodFilters.Contains(entry.MethodName))
                    return false;
                
                // Filter by log level
                if (!selectedLevelFilters.Contains(entry.Level))
                    return false;
                
                // Filter by time range
                if (enableTimeFilter)
                {
                    if (entry.Timestamp < minTimestamp || entry.Timestamp > maxTimestamp)
                        return false;
                }
                
                // Filter by search text
                if (!string.IsNullOrEmpty(searchText))
                {
                    bool matchesSearch = 
                        entry.ClassName.Contains(searchText, StringComparison.OrdinalIgnoreCase) ||
                        entry.MethodName.Contains(searchText, StringComparison.OrdinalIgnoreCase) ||
                        entry.Message.Contains(searchText, StringComparison.OrdinalIgnoreCase);
                    
                    if (!matchesSearch)
                        return false;
                }
                
                return true;
            });
        }
        
        #endregion
        
        #region Helper Methods
        
        private Color GetColorForLevel(LogLevel level)
        {
            return level switch
            {
                LogLevel.Debug => debugColor,
                LogLevel.Info => infoColor,
                LogLevel.Warning => warningColor,
                LogLevel.Error => errorColor,
                _ => infoColor
            };
        }
        
        private void RebuildTagLists()
        {
            activeClassTags.Clear();
            activeMethodTags.Clear();
            
            foreach (var log in allLogs)
            {
                activeClassTags.Add(log.ClassName);
                activeMethodTags.Add(log.MethodName);
            }
        }
        
        private void UpdateTimeRange()
        {
            if (allLogs.Count > 0)
            {
                currentMaxTimestamp = allLogs.Max(l => l.Timestamp);
                
                // Initialize time range on first log
                if (maxTimestamp == 0)
                {
                    maxTimestamp = currentMaxTimestamp;
                }
                else
                {
                    // Auto-expand max range as new logs come in
                    maxTimestamp = currentMaxTimestamp;
                }
            }
        }
        
        private void ExportLogs()
        {
            string defaultFileName = $"logs_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.txt";
            string path = EditorUtility.SaveFilePanel("Export Logs", "", defaultFileName, "txt");
            
            if (!string.IsNullOrEmpty(path))
            {
                try
                {
                    var filteredLogs = GetFilteredLogs().ToList();
                    var lines = filteredLogs.Select(e => e.FullFormattedMessage);
                    File.WriteAllLines(path, lines);
                    
                    EditorUtility.DisplayDialog("Export Successful", 
                        $"Exported {filteredLogs.Count} log entries to:\n{path}", "OK");
                }
                catch (Exception ex)
                {
                    EditorUtility.DisplayDialog("Export Failed", 
                        $"Failed to export logs:\n{ex.Message}", "OK");
                }
            }
        }
        
        #endregion
    }
    
    /// <summary>
    /// Persistent popup window for class filtering with multi-selection support
    /// </summary>
    public class ClassFilterWindow : EditorWindow
    {
        private HashSet<string> availableTags;
        private HashSet<string> selectedTags;
        private System.Action<HashSet<string>> onApply;
        private Vector2 scrollPosition;
        private string searchFilter = "";
        
        public static void ShowWindow(CustomLogWindow parent, HashSet<string> available, HashSet<string> selected,
            System.Action<HashSet<string>> applyCallback)
        {
            var window = CreateInstance<ClassFilterWindow>();
            window.titleContent = new GUIContent("Class Filter");
            window.availableTags = available;
            window.selectedTags = new HashSet<string>(selected);
            window.onApply = applyCallback;
            
            var parentRect = parent.position;
            window.position = new Rect(parentRect.x + 50, parentRect.y + 50, 300, 400);
            window.ShowUtility();
        }
        
        private void OnGUI()
        {
            EditorGUILayout.Space(5);
            
            // Control buttons
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("All", GUILayout.Width(60)))
            {
                if (availableTags != null)
                    selectedTags = new HashSet<string>(availableTags);
            }
            if (GUILayout.Button("None", GUILayout.Width(60)))
            {
                selectedTags.Clear();
            }
            GUILayout.FlexibleSpace();
            searchFilter = EditorGUILayout.TextField(searchFilter, EditorStyles.toolbarSearchField, GUILayout.Width(150));
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
            
            // Scrollable list of toggles
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
            
            if (availableTags != null && availableTags.Count > 0)
            {
                var filteredTags = string.IsNullOrEmpty(searchFilter) 
                    ? availableTags.OrderBy(t => t)
                    : availableTags.Where(t => t.Contains(searchFilter, StringComparison.OrdinalIgnoreCase)).OrderBy(t => t);
                
                foreach (var tag in filteredTags)
                {
                    bool isSelected = selectedTags.Contains(tag);
                    bool newSelection = EditorGUILayout.ToggleLeft(tag, isSelected);
                    
                    if (newSelection != isSelected)
                    {
                        if (newSelection)
                            selectedTags.Add(tag);
                        else
                            selectedTags.Remove(tag);
                    }
                }
            }
            else
            {
                EditorGUILayout.HelpBox("No classes available", MessageType.Info);
            }
            
            EditorGUILayout.EndScrollView();
            
            EditorGUILayout.Space(5);
            
            // Apply/Close buttons
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            
            if (GUILayout.Button("Apply", GUILayout.Width(80)))
            {
                onApply?.Invoke(selectedTags);
                Close();
            }
            
            if (GUILayout.Button("Close", GUILayout.Width(80)))
            {
                Close();
            }
            
            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
        }
    }
    
    /// <summary>
    /// Persistent popup window for method filtering with multi-selection support
    /// </summary>
    public class MethodFilterWindow : EditorWindow
    {
        private HashSet<string> availableTags;
        private HashSet<string> selectedTags;
        private System.Action<HashSet<string>> onApply;
        private Vector2 scrollPosition;
        private string searchFilter = "";
        
        public static void ShowWindow(CustomLogWindow parent, HashSet<string> available, HashSet<string> selected,
            System.Action<HashSet<string>> applyCallback)
        {
            var window = CreateInstance<MethodFilterWindow>();
            window.titleContent = new GUIContent("Method Filter");
            window.availableTags = available;
            window.selectedTags = new HashSet<string>(selected);
            window.onApply = applyCallback;
            
            var parentRect = parent.position;
            window.position = new Rect(parentRect.x + 50, parentRect.y + 50, 300, 400);
            window.ShowUtility();
        }
        
        private void OnGUI()
        {
            EditorGUILayout.Space(5);
            
            // Control buttons
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("All", GUILayout.Width(60)))
            {
                if (availableTags != null)
                    selectedTags = new HashSet<string>(availableTags);
            }
            if (GUILayout.Button("None", GUILayout.Width(60)))
            {
                selectedTags.Clear();
            }
            GUILayout.FlexibleSpace();
            searchFilter = EditorGUILayout.TextField(searchFilter, EditorStyles.toolbarSearchField, GUILayout.Width(150));
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
            
            // Scrollable list of toggles
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
            
            if (availableTags != null && availableTags.Count > 0)
            {
                var filteredTags = string.IsNullOrEmpty(searchFilter) 
                    ? availableTags.OrderBy(t => t)
                    : availableTags.Where(t => t.Contains(searchFilter, StringComparison.OrdinalIgnoreCase)).OrderBy(t => t);
                
                foreach (var tag in filteredTags)
                {
                    bool isSelected = selectedTags.Contains(tag);
                    bool newSelection = EditorGUILayout.ToggleLeft(tag, isSelected);
                    
                    if (newSelection != isSelected)
                    {
                        if (newSelection)
                            selectedTags.Add(tag);
                        else
                            selectedTags.Remove(tag);
                    }
                }
            }
            else
            {
                EditorGUILayout.HelpBox("No methods available", MessageType.Info);
            }
            
            EditorGUILayout.EndScrollView();
            
            EditorGUILayout.Space(5);
            
            // Apply/Close buttons
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            
            if (GUILayout.Button("Apply", GUILayout.Width(80)))
            {
                onApply?.Invoke(selectedTags);
                Close();
            }
            
            if (GUILayout.Button("Close", GUILayout.Width(80)))
            {
                Close();
            }
            
            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
        }
    }
    
    /// <summary>
    /// Persistent popup window for log level filtering with multi-selection support
    /// </summary>
    public class LevelFilterWindow : EditorWindow
    {
        private HashSet<LogLevel> selectedLevels;
        private System.Action<HashSet<LogLevel>> onApply;
        
        public static void ShowWindow(CustomLogWindow parent, HashSet<LogLevel> selected,
            System.Action<HashSet<LogLevel>> applyCallback)
        {
            var window = CreateInstance<LevelFilterWindow>();
            window.titleContent = new GUIContent("Log Level Filter");
            window.selectedLevels = new HashSet<LogLevel>(selected);
            window.onApply = applyCallback;
            
            var parentRect = parent.position;
            window.position = new Rect(parentRect.x + 50, parentRect.y + 50, 250, 180);
            window.ShowUtility();
        }
        
        private void OnGUI()
        {
            EditorGUILayout.Space(5);
            
            // Control buttons
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("All", GUILayout.Width(60)))
            {
                selectedLevels = new HashSet<LogLevel> 
                { 
                    LogLevel.Debug, LogLevel.Info, LogLevel.Warning, LogLevel.Error 
                };
            }
            if (GUILayout.Button("None", GUILayout.Width(60)))
            {
                selectedLevels.Clear();
            }
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(10);
            
            // Log level toggles
            foreach (LogLevel level in Enum.GetValues(typeof(LogLevel)))
            {
                bool isSelected = selectedLevels.Contains(level);
                bool newSelection = EditorGUILayout.ToggleLeft(level.ToString(), isSelected);
                
                if (newSelection != isSelected)
                {
                    if (newSelection)
                        selectedLevels.Add(level);
                    else
                        selectedLevels.Remove(level);
                }
            }
            
            EditorGUILayout.Space(10);
            
            // Apply/Close buttons
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            
            if (GUILayout.Button("Apply", GUILayout.Width(80)))
            {
                onApply?.Invoke(selectedLevels);
                Close();
            }
            
            if (GUILayout.Button("Close", GUILayout.Width(80)))
            {
                Close();
            }
            
            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
        }
    }
    
    /// <summary>
    /// Popup window for configuring time range filters
    /// </summary>
    public class TimeRangeFilterWindow : EditorWindow
    {
        private bool enableTimeFilter;
        private float minTimestamp;
        private float maxTimestamp;
        private float currentMaxTimestamp;
        private System.Action<bool, float, float> onApply;
        
        public static void ShowWindow(CustomLogWindow parent, bool enabled, float min, float max, float currentMax,
            System.Action<bool, float, float> applyCallback)
        {
            var window = CreateInstance<TimeRangeFilterWindow>();
            window.titleContent = new GUIContent("Time Range Filter");
            window.enableTimeFilter = enabled;
            window.minTimestamp = min;
            window.maxTimestamp = max;
            window.currentMaxTimestamp = currentMax;
            window.onApply = applyCallback;
            
            // Position near the parent window
            var parentRect = parent.position;
            window.position = new Rect(parentRect.x + 100, parentRect.y + 100, 350, 120);
            
            window.ShowUtility();
        }
        
        private void OnGUI()
        {
            EditorGUILayout.Space(10);
            
            enableTimeFilter = EditorGUILayout.Toggle("Enable Time Filter", enableTimeFilter);
            
            EditorGUILayout.Space(5);
            
            if (enableTimeFilter && currentMaxTimestamp > 0)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.LabelField($"Min: {minTimestamp:F2}s", GUILayout.Width(100));
                EditorGUILayout.LabelField($"Max: {maxTimestamp:F2}s", GUILayout.Width(100));
                EditorGUILayout.EndHorizontal();
                
                EditorGUILayout.MinMaxSlider(
                    ref minTimestamp, 
                    ref maxTimestamp, 
                    0, 
                    currentMaxTimestamp);
                    
                EditorGUILayout.Space(5);
                
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("Reset Range"))
                {
                    minTimestamp = 0;
                    maxTimestamp = currentMaxTimestamp;
                }
                EditorGUILayout.EndHorizontal();
            }
            else if (enableTimeFilter)
            {
                EditorGUILayout.HelpBox("No logs available for time filtering", MessageType.Info);
            }
            
            EditorGUILayout.Space(10);
            
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            
            if (GUILayout.Button("Apply", GUILayout.Width(80)))
            {
                onApply?.Invoke(enableTimeFilter, minTimestamp, maxTimestamp);
                Close();
            }
            
            if (GUILayout.Button("Cancel", GUILayout.Width(80)))
            {
                Close();
            }
            
            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(10);
        }
    }
}