MainWindow.xaml.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media; // Added for VisualTreeHelper
using System.Threading.Tasks; // Added for Task.Delay and async/await
using System.Globalization; // Required for CultureInfo
using System.Windows.Data; // Required for IMultiValueConverter
using System.Threading; // For Timer (though DispatcherTimer is in System.Windows.Threading)
using System.Configuration; // Required for SettingsPropertyNotFoundException
using System.Collections.ObjectModel; // Required for ObservableCollection
using System.Text.Json; // For JSON serialization
using System.Text; // For StringBuilder and encoding

namespace TimeTask
{

    public static class HelperClass
    {

        public static List<ItemGrid> ReadCsv(string filepath)
        {
            if (!File.Exists(filepath))
            {
                return null;
            }
            int parseScore = 0;
            var allLines = File.ReadAllLines(filepath).Where(arg => !string.IsNullOrWhiteSpace(arg));
            var result =
                from line in allLines.Skip(1).Take(allLines.Count() - 1)
                let temparry = line.Split(',')
                let parse = int.TryParse(temparry[1], out parseScore)
                let isCompleted = temparry.Length > 3 && temparry[3] != null && temparry[3] == "True"
                let parsedLastModifiedDate = temparry.Length > 7 && DateTime.TryParse(temparry[7], out DateTime lmd) ? lmd : DateTime.Now
                select new ItemGrid {
                    Task = temparry[0],
                    Score = parseScore,
                    Result = temparry[2],
                    IsActive = !isCompleted, // IsActive is the opposite of is_completed
                    Importance = temparry.Length > 4 && !string.IsNullOrWhiteSpace(temparry[4]) ? temparry[4] : "Unknown",
                    Urgency = temparry.Length > 5 && !string.IsNullOrWhiteSpace(temparry[5]) ? temparry[5] : "Unknown",
                    CreatedDate = temparry.Length > 6 && DateTime.TryParse(temparry[6], out DateTime cd) ? cd : DateTime.Now,
                    LastModifiedDate = parsedLastModifiedDate,
                    ReminderTime = temparry.Length > 8 && DateTime.TryParse(temparry[8], out DateTime rt) ? rt : (DateTime?)null,
                    LongTermGoalId = temparry.Length > 9 && !string.IsNullOrWhiteSpace(temparry[9]) ? temparry[9] : null,
                    OriginalScheduledDay = temparry.Length > 10 && int.TryParse(temparry[10], out int osd) ? osd : 0,
                    IsActiveInQuadrant = temparry.Length > 11 && bool.TryParse(temparry[11], out bool iaiq) ? iaiq : true, // Default to true for backward compatibility
                    InactiveWarningCount = temparry.Length > 12 && int.TryParse(temparry[12], out int iwc) ? iwc : 0,
                    LastProgressDate = temparry.Length > 13 && DateTime.TryParse(temparry[13], out DateTime lpd) ? lpd : parsedLastModifiedDate,
                    LastInteractionDate = temparry.Length > 14 && DateTime.TryParse(temparry[14], out DateTime lid) ? lid : parsedLastModifiedDate,
                    ReminderSnoozeUntil = temparry.Length > 15 && DateTime.TryParse(temparry[15], out DateTime rsu) ? rsu : (DateTime?)null,
                    LastReminderDate = temparry.Length > 16 && DateTime.TryParse(temparry[16], out DateTime lrd) ? lrd : (DateTime?)null,
                    SourceTaskID = temparry.Length > 17 && !string.IsNullOrWhiteSpace(temparry[17]) ? temparry[17] : null
                };
            var result_list = new List<ItemGrid>();
            try
            {
                result_list = result.ToList();
            }
            catch (Exception ex) { // Catch specific exceptions if possible, or log general ones
                Console.WriteLine($"Error parsing CSV lines: {ex.Message}");
                // Add a default item or handle error as appropriate
                result_list.Add(new ItemGrid { Task = "csv文件错误", Score = 0, Result= "", IsActive = true, Importance = "Unknown", Urgency = "Unknown", CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now, IsActiveInQuadrant = true, InactiveWarningCount = 0 });
            }
            return result_list;
        }

        public static void WriteCsv(IEnumerable<ItemGrid> items, string filepath)
        {
            var temparray = items.Select(item =>
                $"{item.Task},{item.Score},{item.Result},{(item.IsActive ? "False" : "True")},{item.Importance ?? "Unknown"},{item.Urgency ?? "Unknown"},{item.CreatedDate:o},{item.LastModifiedDate:o},{item.ReminderTime?.ToString("o") ?? ""},{item.LongTermGoalId ?? ""},{item.OriginalScheduledDay},{item.IsActiveInQuadrant},{item.InactiveWarningCount},{item.LastProgressDate:o},{item.LastInteractionDate:o},{item.ReminderSnoozeUntil?.ToString("o") ?? ""},{item.LastReminderDate?.ToString("o") ?? ""},{item.SourceTaskID ?? ""}"
            ).ToArray();
            var contents = new string[temparray.Length + 2];
            Array.Copy(temparray, 0, contents, 1, temparray.Length);
            // Updated header
            contents[0] = "task,score,result,is_completed,importance,urgency,createdDate,lastModifiedDate,reminderTime,longTermGoalId,originalScheduledDay,isActiveInQuadrant,inactiveWarningCount,lastProgressDate,lastInteractionDate,reminderSnoozeUntil,lastReminderDate,sourceTaskId";
            File.WriteAllLines(filepath, contents);
        }

        public static List<LongTermGoal> ReadLongTermGoalsCsv(string filepath)
        {
            if (!File.Exists(filepath))
            {
                return new List<LongTermGoal>();
            }

            var allLines = File.ReadAllLines(filepath).Where(arg => !string.IsNullOrWhiteSpace(arg)).ToList();
            if (allLines.Count <= 1)
            {
                return new List<LongTermGoal>();
            }

            var goals = new List<LongTermGoal>();
            foreach (var line in allLines.Skip(1))
            {
                var fields = line.Split(',');
                if (fields.Length >= 5)
                {
                    try
                    {
                        var goal = new LongTermGoal
                        {
                            Id = fields[0],
                            Description = fields[1].Replace(";;;", ","),
                            TotalDuration = fields[2],
                            CreationDate = DateTime.TryParse(fields[3], out DateTime cd) ? cd : DateTime.MinValue,
                            IsActive = bool.TryParse(fields[4], out bool ia) && ia,
                            IsLearningPlan = fields.Length > 5 && bool.TryParse(fields[5], out bool ilp) && ilp,
                            Subject = fields.Length > 6 ? fields[6].Replace(";;;", ",") : null,
                            StartDate = fields.Length > 7 && DateTime.TryParse(fields[7], out DateTime sd) ? sd : (DateTime?)null,
                            TotalStages = fields.Length > 8 && int.TryParse(fields[8], out int ts) ? ts : 0,
                            CompletedStages = fields.Length > 9 && int.TryParse(fields[9], out int cs) ? cs : 0
                        };
                        goals.Add(goal);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error parsing LongTermGoal line: {line}. Error: {ex.Message}");
                    }
                }
            }
            return goals;
        }

        public static void WriteLongTermGoalsCsv(List<LongTermGoal> goals, string filepath)
        {
            var directory = Path.GetDirectoryName(filepath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var lines = new List<string> { "Id,Description,TotalDuration,CreationDate,IsActive,IsLearningPlan,Subject,StartDate,TotalStages,CompletedStages" };
            foreach (var goal in goals)
            {
                string safeDescription = goal.Description?.Replace(",", ";;;") ?? "";
                string safeSubject = goal.Subject?.Replace(",", ";;;") ?? "";
                lines.Add($"{goal.Id},{safeDescription},{goal.TotalDuration},{goal.CreationDate:o},{goal.IsActive},{goal.IsLearningPlan},{safeSubject},{goal.StartDate?.ToString("o") ?? ""},{goal.TotalStages},{goal.CompletedStages}");
            }
            File.WriteAllLines(filepath, lines);
        }

        public static List<LearningPlan> ReadLearningPlansCsv(string filepath)
        {
            if (!File.Exists(filepath))
            {
                return new List<LearningPlan>();
            }

            var allLines = File.ReadAllLines(filepath).Where(arg => !string.IsNullOrWhiteSpace(arg)).ToList();
            if (allLines.Count <= 1)
            {
                return new List<LearningPlan>();
            }

            var plans = new List<LearningPlan>();
            foreach (var line in allLines.Skip(1))
            {
                var fields = line.Split(',');
                if (fields.Length >= 10)
                {
                    try
                    {
                        var plan = new LearningPlan
                        {
                            Id = fields[0],
                            Subject = fields[1].Replace(";;;", ","),
                            Goal = fields[2].Replace(";;;", ","),
                            Duration = fields[3],
                            CreationDate = DateTime.TryParse(fields[4], out DateTime cd) ? cd : DateTime.MinValue,
                            StartDate = DateTime.TryParse(fields[5], out DateTime sd) ? sd : (DateTime?)null,
                            EndDate = DateTime.TryParse(fields[6], out DateTime ed) ? ed : (DateTime?)null,
                            IsActive = bool.TryParse(fields[7], out bool ia) && ia,
                            TotalStages = int.TryParse(fields[8], out int ts) ? ts : 0,
                            CompletedStages = int.TryParse(fields[9], out int cs) ? cs : 0
                        };
                        plans.Add(plan);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error parsing LearningPlan line: {line}. Error: {ex.Message}");
                    }
                }
            }
            return plans;
        }

        public static void WriteLearningPlansCsv(List<LearningPlan> plans, string filepath)
        {
            var directory = Path.GetDirectoryName(filepath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var lines = new List<string> { "Id,Subject,Goal,Duration,CreationDate,StartDate,EndDate,IsActive,TotalStages,CompletedStages" };
            foreach (var plan in plans)
            {
                string safeSubject = plan.Subject?.Replace(",", ";;;") ?? "";
                string safeGoal = plan.Goal?.Replace(",", ";;;") ?? "";
                lines.Add($"{plan.Id},{safeSubject},{safeGoal},{plan.Duration},{plan.CreationDate:o},{plan.StartDate?.ToString("o") ?? ""},{plan.EndDate?.ToString("o") ?? ""},{plan.IsActive},{plan.TotalStages},{plan.CompletedStages}");
            }
            File.WriteAllLines(filepath, lines);
        }

        public static List<LearningMilestone> ReadLearningMilestonesCsv(string filepath)
        {
            if (!File.Exists(filepath))
            {
                return new List<LearningMilestone>();
            }

            var allLines = File.ReadAllLines(filepath).Where(arg => !string.IsNullOrWhiteSpace(arg)).ToList();
            if (allLines.Count <= 1)
            {
                return new List<LearningMilestone>();
            }

            var milestones = new List<LearningMilestone>();
            foreach (var line in allLines.Skip(1))
            {
                var fields = line.Split(',');
                if (fields.Length >= 9)
                {
                    try
                    {
                        var milestone = new LearningMilestone
                        {
                            Id = fields[0],
                            LearningPlanId = fields[1],
                            StageName = fields[2].Replace(";;;", ","),
                            Description = fields[3].Replace(";;;", ","),
                            StageNumber = int.TryParse(fields[4], out int sn) ? sn : 0,
                            TargetDate = DateTime.TryParse(fields[5], out DateTime td) ? td : (DateTime?)null,
                            IsCompleted = bool.TryParse(fields[6], out bool ic) && ic,
                            CompletedDate = DateTime.TryParse(fields[7], out DateTime ccd) ? ccd : (DateTime?)null,
                            AssociatedTaskId = fields.Length > 8 ? fields[8] : null
                        };
                        milestones.Add(milestone);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error parsing LearningMilestone line: {line}. Error: {ex.Message}");
                    }
                }
            }
            return milestones;
        }

        public static void WriteLearningMilestonesCsv(List<LearningMilestone> milestones, string filepath)
        {
            var directory = Path.GetDirectoryName(filepath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var lines = new List<string> { "Id,LearningPlanId,StageName,Description,StageNumber,TargetDate,IsCompleted,CompletedDate,AssociatedTaskId" };
            foreach (var milestone in milestones)
            {
                string safeStageName = milestone.StageName?.Replace(",", ";;;") ?? "";
                string safeDescription = milestone.Description?.Replace(",", ";;;") ?? "";
                lines.Add($"{milestone.Id},{milestone.LearningPlanId},{safeStageName},{safeDescription},{milestone.StageNumber},{milestone.TargetDate?.ToString("o") ?? ""},{milestone.IsCompleted},{milestone.CompletedDate?.ToString("o") ?? ""},{milestone.AssociatedTaskId ?? ""}");
            }
            File.WriteAllLines(filepath, lines);
        }
    }

    public class ItemGrid
    {
        public string Task { set; get; }
        public int Score { set; get; }
        public string Result { set; get; }
        /// <summary>
        /// Gets or sets a value indicating whether the task is active.
        /// True if the task is pending, False if it's completed.
        /// </summary>
        public bool IsActive { set; get; }
        public string Importance { set; get; } = "Unknown";
        public string Urgency { set; get; } = "Unknown";
        public DateTime CreatedDate { set; get; } = DateTime.Now;
        public DateTime LastModifiedDate { set; get; } = DateTime.Now;
        public DateTime LastProgressDate { get; set; } = DateTime.Now;
        public DateTime LastInteractionDate { get; set; } = DateTime.Now;
        public DateTime? ReminderTime { get; set; } = null;
        public DateTime? ReminderSnoozeUntil { get; set; } = null;
        public DateTime? LastReminderDate { get; set; } = null;
        public string TaskType { get; set; }
        public DateTime? CompletionTime { get; set; }
        public string CompletionStatus { get; set; }
        public string AssignedRole { get; set; }
        public string SourceTaskID { get; set; } // To map to SourceTaskID from the database

        // New properties for Long-Term Goal association
        public string LongTermGoalId { get; set; } = null; // ID of the parent LongTermGoal
        public int OriginalScheduledDay { get; set; } = 0; // Day index for tasks from a long-term plan
        public bool IsActiveInQuadrant { get; set; } = true; // True if the task should be displayed in the main quadrants

        // New property for inactivity warning
        public int InactiveWarningCount { get; set; } = 0;

    }

    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
// using System.Threading.Tasks; // Moved to top

// Removed redundant nested namespace TimeTask
    public partial class MainWindow : Window
    {
        public sealed class FocusBoardSnapshot
        {
            public ItemGrid PrimaryTask { get; set; }
            public string PrimaryMeta { get; set; }
            public ItemGrid ReminderTask { get; set; }
            public string ReminderMeta { get; set; }
            public ItemGrid StuckTask { get; set; }
            public string StuckMeta { get; set; }
        }

        public sealed class SystemProgressSnapshot
        {
            public int Level { get; set; }
            public int Experience { get; set; }
            public int NextLevelExperience { get; set; }
            public string StageText { get; set; }
            public string NarrativeText { get; set; }
            public string ActiveQuestText { get; set; }
            public string RecommendedSkillText { get; set; }
            public List<SystemSkillNodeSnapshot> SkillNodes { get; set; } = new List<SystemSkillNodeSnapshot>();
        }

        public sealed class SystemSkillNodeSnapshot
        {
            public string SkillId { get; set; }
            public string Title { get; set; }
            public int Level { get; set; }
            public string MetaText { get; set; }
            public string ToolTipText { get; set; }
        }

        private LlmService _llmService;
        private bool _llmConfigErrorDetectedInLoad = false; // Flag for LLM config error during load
        // Configurable timeout settings with defaults
        private static TimeSpan StaleTaskThreshold => TimeSpan.FromDays(Properties.Settings.Default.StaleTaskThresholdDays);
        private static int MaxInactiveWarnings => Properties.Settings.Default.MaxInactiveWarnings;
        private static TimeSpan FirstWarningAfter => TimeSpan.FromDays(Properties.Settings.Default.FirstWarningAfterDays);
        private static TimeSpan SecondWarningAfter => TimeSpan.FromDays(Properties.Settings.Default.SecondWarningAfterDays);
        private System.Windows.Threading.DispatcherTimer _reminderTimer;
        private System.Windows.Threading.DispatcherTimer _draftBadgeTimer;
        private System.Windows.Threading.DispatcherTimer _voiceStatusAnimTimer;
        private VoiceListenerState _voiceListenerState = VoiceListenerState.Unknown;
        private TaskDraftManager _draftBadgeManager;
        private UserProfileManager _userProfileManager;
        private bool _proactiveAssistEnabled = true;
        private bool _behaviorLearningEnabled = true;
        private bool _stuckNudgesEnabled = true;
        private bool _llmSkillAssistEnabled = true;
        private bool _nonBlockingInteractionEnabled = true;
        private int _quietHoursStart = 22;
        private int _quietHoursEnd = 8;
        private const int DailyReminderLimit = 3;
        private static readonly TimeSpan ReminderCooldown = TimeSpan.FromMinutes(45);
        private int _remindersShownToday = 0;
        private DateTime _reminderCounterDate = DateTime.Today;
        private readonly Dictionary<string, TaskInteractionState> _taskInteractionStates = new Dictionary<string, TaskInteractionState>();
        private readonly Dictionary<string, List<string>> _pendingReminderSkillIds = new Dictionary<string, List<string>>();
        private const int DefaultDailyStuckNudgeLimit = 2;
        private static readonly TimeSpan StuckNudgeCooldown = TimeSpan.FromHours(2);
        private static readonly TimeSpan DefaultStuckNoProgressThreshold = TimeSpan.FromMinutes(90);
        private static readonly TimeSpan MinStuckNoProgressThreshold = TimeSpan.FromMinutes(60);
        private static readonly TimeSpan MaxStuckNoProgressThreshold = TimeSpan.FromMinutes(180);
        private const int MinDailyStuckNudgeLimit = 1;
        private const int MaxDailyStuckNudgeLimit = 3;
        private TimeSpan _adaptiveStuckNoProgressThreshold = DefaultStuckNoProgressThreshold;
        private int _adaptiveDailyStuckNudgeLimit = DefaultDailyStuckNudgeLimit;
        private DateTime _lastAdaptiveTuneAt = DateTime.MinValue;
        private int _stuckNudgesShownToday = 0;
        private DateTime _stuckNudgeCounterDate = DateTime.Today;
        private DateTime _lastStuckNudgeAt = DateTime.MinValue;
        private ItemGrid _primaryFocusTask;
        private ItemGrid _reminderFocusTask;
        private ItemGrid _stuckFocusTask;
        private readonly Dictionary<Border, SystemSkillNodeSnapshot> _skillTreeNodeMap = new Dictionary<Border, SystemSkillNodeSnapshot>();
        private readonly List<string> _systemTickerMessages = new List<string>();
        private System.Windows.Threading.DispatcherTimer _systemTickerTimer;
        private int _systemTickerIndex;
        private bool _isSystemPanelCompactMode = true;

        private DatabaseService _databaseService;
        private System.Windows.Threading.DispatcherTimer _syncTimer;
        private KnowledgeSyncService _knowledgeSyncService;
        private KnowledgeArtifactService _knowledgeArtifactService;
        private System.Windows.Threading.DispatcherTimer _knowledgeSyncTimer;
        private System.Windows.Threading.DispatcherTimer _knowledgeSyncDebounceTimer;
        private FileSystemWatcher _obsidianWatcher;
        private bool _knowledgeSyncRunning = false;
        private HashSet<string> _syncedTaskSourceIDs = new HashSet<string>();
        private bool _isFirstSyncAttempted = false; // To control initial sync message

        // 新增智能系统
        private SmartGuidanceManager _smartGuidanceManager;
        private ConversationRecorder _conversationRecorder;
        private UserBehaviorObserver _behaviorObserver;
        private AdaptiveGoalManager _adaptiveGoalManager;
        private LifeProfileEngine _lifeProfileEngine;
        private DecisionEngine _decisionEngine;
        private WeeklyReviewEngine _weeklyReviewEngine;
        private GoalHierarchyEngine _goalHierarchyEngine;
        private System.Windows.Threading.DispatcherTimer _smartSystemTimer;
        private System.Windows.Threading.DispatcherTimer _conversationIdleTimer;
        private DateTime _lastVoiceConversationSegmentAtUtc = DateTime.MinValue;
        private DateTime _lastStrategyCycleAt = DateTime.MinValue;
        private DateTime _lastWeeklyReviewNoticeDate = DateTime.MinValue;
        private static readonly TimeSpan ConversationIdleTimeout = TimeSpan.FromSeconds(75);
        private TimeSpan _strategyCycleInterval = TimeSpan.FromMinutes(30);
        private DayOfWeek _weeklyReviewPublishDay = DayOfWeek.Monday;
        private int _strategyTopFocusCount = 5;
        private DecisionEngineOptions _decisionOptions = new DecisionEngineOptions();

        private ItemGrid _draggedItem;
        private DataGrid _sourceDataGrid;
        private Point? _dragStartPoint; // To store the starting point of a potential drag

        [DllImport("user32.dll", SetLastError = true)]
        static extern int SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
        [DllImport("user32.dll", SetLastError = true)]
        static extern IntPtr FindWindow(string lpWindowClass, string lpWindowName);
        [DllImport("user32.dll", SetLastError = true)]
        static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string className, string windowTitle);
        const int GWL_HWNDPARENT = -8;
        [DllImport("user32.dll")]
        static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

        internal string currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); // Made internal for test access

        int task1_selected_indexs = -1;
        int task2_selected_indexs = -1;
        int task3_selected_indexs = -1;
        int task4_selected_indexs = -1;

        private LongTermGoal _activeLongTermGoal;

        private void LoadActiveLongTermGoalAndRefreshDisplay()
        {
            string longTermGoalsCsvPath = Path.Combine(currentPath, "data", "long_term_goals.csv");
            if (File.Exists(longTermGoalsCsvPath))
            {
                List<LongTermGoal> allLongTermGoals = HelperClass.ReadLongTermGoalsCsv(longTermGoalsCsvPath);
                _activeLongTermGoal = allLongTermGoals.FirstOrDefault(g => g.IsActive);
            }
            else
            {
                _activeLongTermGoal = null;
            }
            UpdateLongTermGoalBadge();
        }

        public void UpdateLongTermGoalBadge()
        {
            if (_activeLongTermGoal != null)
            {
                ActiveLongTermGoalDisplay.Visibility = Visibility.Visible;
                
                if (_activeLongTermGoal.IsLearningPlan)
                {
                    ActiveLongTermGoalName.Text = $"{TruncateText(_activeLongTermGoal.Subject, 15)}计划";
                    double progress = _activeLongTermGoal.ProgressPercentage;
                    LongTermGoalBadge.Text = $"{progress:F0}%";
                }
                else
                {
                    ActiveLongTermGoalName.Text = TruncateText(_activeLongTermGoal.Description, 20);

                    int pendingSubTasks = 0;
                    string[] csvFiles = { "1.csv", "2.csv", "3.csv", "4.csv" };
                    for (int i = 0; i < csvFiles.Length; i++)
                    {
                        string filePath = Path.Combine(currentPath, "data", csvFiles[i]);
                        if (File.Exists(filePath))
                        {
                            List<ItemGrid> items = HelperClass.ReadCsv(filePath);
                            if (items != null)
                            {
                                pendingSubTasks += items.Count(item => item.LongTermGoalId == _activeLongTermGoal.Id && item.IsActive);
                            }
                        }
                    }
                    LongTermGoalBadge.Text = pendingSubTasks.ToString();
                }
            }
            else
            {
                ActiveLongTermGoalDisplay.Visibility = Visibility.Collapsed;
            }
        }

        private string TruncateText(string text, int maxLength)
        {
            if (string.IsNullOrEmpty(text)) return string.Empty;
            return text.Length <= maxLength ? text : text.Substring(0, maxLength) + "...";
        }

        public void loadDataGridView()
        {
            LoadActiveLongTermGoalAndRefreshDisplay(); // Load active goal and update its display
            _llmConfigErrorDetectedInLoad = false;

            string[] csvFiles = { "1.csv", "2.csv", "3.csv", "4.csv" };
            DataGrid[] dataGrids = { task1, task2, task3, task4 };

            for (int i = 0; i < csvFiles.Length; i++)
            {
                string filePath = Path.Combine(currentPath, "data", csvFiles[i]);
                List<ItemGrid> allItemsInCsv = HelperClass.ReadCsv(filePath);
                List<ItemGrid> itemsToDisplayInQuadrant;

                if (allItemsInCsv == null)
                {
                    Console.WriteLine($"Error reading CSV file: {filePath}. Or file is empty/new.");
                    allItemsInCsv = new List<ItemGrid>();
                }
                else
                {
                    foreach (var item in allItemsInCsv)
                    {
                        if (!string.IsNullOrWhiteSpace(item.SourceTaskID) && !_syncedTaskSourceIDs.Contains(item.SourceTaskID))
                        {
                            _syncedTaskSourceIDs.Add(item.SourceTaskID);
                        }
                    }
                }

                // Filter tasks for display: only those marked IsActiveInQuadrant
                itemsToDisplayInQuadrant = allItemsInCsv.Where(item => item.IsActiveInQuadrant).ToList();

                dataGrids[i].ItemsSource = null;
                dataGrids[i].ItemsSource = itemsToDisplayInQuadrant;
                if (!dataGrids[i].Items.SortDescriptions.Contains(new SortDescription("Score", ListSortDirection.Descending)))
                {
                    dataGrids[i].Items.SortDescriptions.Add(new SortDescription("Score", ListSortDirection.Descending));
                }

                // After all files are processed, show a single notification if LLM config error was detected
                if (_llmConfigErrorDetectedInLoad)
                {
                    MessageBox.Show(this, "During task loading, some AI assistant features may have been limited due to a configuration issue (e.g., missing or placeholder API key). Please check the application's setup if you expect full AI functionality.",
                                    "LLM Configuration Issue", MessageBoxButton.OK, MessageBoxImage.Warning);
                    // As per requirement, not resetting _llmConfigErrorDetectedInLoad here.
                }
            }
        }

        public void DataGrid_MouseDoubleClick_AddTask(object sender, MouseButtonEventArgs e)
        {
            if (!(sender is DataGrid dataGrid)) return;

            var hitTestResult = VisualTreeHelper.HitTest(dataGrid, e.GetPosition(dataGrid));
            if (hitTestResult?.VisualHit == null)
            {
                return;
            }

            var visualHit = hitTestResult.VisualHit;
            while (visualHit != null && visualHit != dataGrid)
            {
                if (visualHit is DataGridRow || visualHit is System.Windows.Controls.Primitives.DataGridColumnHeader || visualHit is DataGridCell)
                {
                    return;
                }
                visualHit = VisualTreeHelper.GetParent(visualHit);
            }

            TryOpenAddTaskDialogForDataGrid(dataGrid);
        }

        private void TryOpenAddTaskDialogForDataGrid(DataGrid dataGrid)
        {
            int quadrantIndex = -1;
            switch (dataGrid.Name)
            {
                case "task1": quadrantIndex = 0; break;
                case "task2": quadrantIndex = 1; break;
                case "task3": quadrantIndex = 2; break;
                case "task4": quadrantIndex = 3; break;
            }

            if (quadrantIndex == -1)
            {
                Console.WriteLine($"Error: Could not determine quadrant index for DataGrid named {dataGrid.Name}");
                return;
            }

            if (_llmService == null)
            {
                MessageBox.Show("LLM Service is not available.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            AddTaskWindow addTaskWindow = new AddTaskWindow(_llmService, quadrantIndex);
            bool? dialogResult = addTaskWindow.ShowDialog();

            if (dialogResult == true && addTaskWindow.TaskAdded && addTaskWindow.NewTask != null)
            {
                ItemGrid newTask = addTaskWindow.NewTask;
                int finalQuadrantIndex = AddTaskWindow.GetIndexFromPriority(newTask.Importance, newTask.Urgency);
                DataGrid targetDataGrid = null;

                switch (finalQuadrantIndex)
                {
                    case 0: targetDataGrid = task1; break;
                    case 1: targetDataGrid = task2; break;
                    case 2: targetDataGrid = task3; break;
                    case 3: targetDataGrid = task4; break;
                    default:
                        MessageBox.Show("Invalid quadrant specified for the new task after dialog.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                }

                string csvFileNumber = GetQuadrantNumber(targetDataGrid.Name);
                List<ItemGrid> items = targetDataGrid.ItemsSource as List<ItemGrid>;
                if (items == null)
                {
                    items = new List<ItemGrid>();
                    targetDataGrid.ItemsSource = items;
                }

                items.Add(newTask);
                TrackTaskInteraction(newTask, "progress");
                RecordTaskProgressProfile(newTask, "manual_create");
                for (int i = 0; i < items.Count; i++)
                {
                    items[i].Score = items.Count - i;
                }

                RefreshDataGrid(targetDataGrid);
                if (!string.IsNullOrEmpty(csvFileNumber))
                {
                    update_csv(targetDataGrid, csvFileNumber);
                }
                else
                {
                    MessageBox.Show($"Could not determine CSV file for quadrant: {targetDataGrid.Name}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }




        public MainWindow()
        {
            InitializeComponent();
            I18n.LanguageChanged += I18n_LanguageChanged;
            InitializeVoiceStatusIndicator();
            this.Closed += MainWindow_Closed;
            
            // 初始化用户体验改进功能
            UXImprovements.Initialize(this);
            
            // 配置验证已移除
            
            _llmService = LlmService.Create();
            _userProfileManager = new UserProfileManager();
            LoadProactiveConfig();
            UpdateAdaptiveNudgeParameters(force: true);

            var normalizedPosition = NormalizeWindowPosition(
                (double)Properties.Settings.Default.Left,
                (double)Properties.Settings.Default.Top,
                this.Width,
                this.Height);
            this.Left = normalizedPosition.X;
            this.Top = normalizedPosition.Y;
            
            loadDataGridView();
            UpdateFocusBoard();
            InitializeSystemPanelBehavior();

            // Attach CellEditEnding event handler to all DataGrids
            task1.CellEditEnding += DataGrid_CellEditEnding;
            task2.CellEditEnding += DataGrid_CellEditEnding;
            task3.CellEditEnding += DataGrid_CellEditEnding;
            task4.CellEditEnding += DataGrid_CellEditEnding;

            // Initialize and start the reminder timer with configurable interval
            _reminderTimer = new System.Windows.Threading.DispatcherTimer();
            _reminderTimer.Interval = TimeSpan.FromSeconds(Properties.Settings.Default.ReminderCheckIntervalSeconds);
            _reminderTimer.Tick += ReminderTimer_Tick;
            _reminderTimer.Start();
            
            // Start periodic task reminder checks
            StartPeriodicTaskReminderChecks();

            InitializeSyncService();
            _knowledgeArtifactService = KnowledgeArtifactService.CreateFromAppSettings(currentPath);

            // 应用快速改进功能
            ApplyQuickImprovements();

            InitializeDraftBadgeMonitor();
            InitializeKnowledgeSyncService();

            // 初始化智能系统
            InitializeSmartSystems();
        }

        private void I18n_LanguageChanged(object sender, EventArgs e)
        {
            if (!Dispatcher.CheckAccess())
            {
                Dispatcher.BeginInvoke(new Action(() => I18n_LanguageChanged(sender, e)));
                return;
            }

            UpdateFocusBoard();
            ApplySystemPanelMode();
            UpdateVoiceStatusUi(VoiceListenerStatusCenter.Current);
        }

        private void InitializeSystemPanelBehavior()
        {
            try
            {
                _systemTickerTimer = new System.Windows.Threading.DispatcherTimer();
                _systemTickerTimer.Interval = TimeSpan.FromSeconds(7);
                _systemTickerTimer.Tick += SystemTickerTimer_Tick;
                _systemTickerTimer.Start();
                ApplySystemPanelMode();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"System panel behavior init failed: {ex.Message}");
            }
        }

        private void InitializeVoiceStatusIndicator()
        {
            try
            {
                _voiceStatusAnimTimer = new System.Windows.Threading.DispatcherTimer();
                _voiceStatusAnimTimer.Interval = TimeSpan.FromMilliseconds(280);
                _voiceStatusAnimTimer.Tick += VoiceStatusAnimTimer_Tick;

                VoiceListenerStatusCenter.StatusChanged += VoiceListenerStatusCenter_StatusChanged;
                UpdateVoiceStatusUi(VoiceListenerStatusCenter.Current);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Voice status indicator init failed: {ex.Message}");
            }
        }

        private void VoiceListenerStatusCenter_StatusChanged(object sender, VoiceListenerStatus status)
        {
            if (!Dispatcher.CheckAccess())
            {
                Dispatcher.BeginInvoke(new Action(() => UpdateVoiceStatusUi(status)));
                return;
            }

            UpdateVoiceStatusUi(status);
        }

        private void UpdateVoiceStatusUi(VoiceListenerStatus status)
        {
            if (status == null || VoiceStatusButton == null || VoiceStatusIcon == null || VoiceStatusDot == null || VoiceStatusText == null)
                return;

            _voiceListenerState = status.State;
            string statusLabel = GetVoiceStatusLabel(status.State);
            string tooltipMessage = string.IsNullOrWhiteSpace(status.Message) ? statusLabel : status.Message;
            string updatedLocal = status.UpdatedAtUtc.ToLocalTime().ToString("HH:mm:ss");
            VoiceStatusButton.ToolTip = $"{I18n.T("Voice_StatusTitle")}: {statusLabel}\n{tooltipMessage}\n{I18n.T("Voice_StatusUpdatedAt")}: {updatedLocal}";
            VoiceStatusText.Text = BuildVoiceStatusText(statusLabel, status.Message);

            switch (status.State)
            {
                case VoiceListenerState.Installing:
                case VoiceListenerState.Loading:
                    ApplyVoiceStatusBrush("#FFECEFF1", "#FFB0BEC5", "#FF90A4AE");
                    StopVoiceStatusAnimation();
                    break;
                case VoiceListenerState.Unavailable:
                    ApplyVoiceStatusBrush("#FFECEFF1", "#FFB0BEC5", "#FF90A4AE");
                    StopVoiceStatusAnimation();
                    break;
                case VoiceListenerState.Ready:
                    ApplyVoiceStatusBrush("#FFE8F5E9", "#FFA5D6A7", "#FF2E7D32");
                    StopVoiceStatusAnimation();
                    break;
                case VoiceListenerState.Recognizing:
                    ApplyVoiceStatusBrush("#FFE3F2FD", "#FF90CAF9", "#FF1E88E5");
                    StartVoiceStatusAnimation();
                    break;
                default:
                    ApplyVoiceStatusBrush("#FFECEFF1", "#FFCFD8DC", "#FF90A4AE");
                    StopVoiceStatusAnimation();
                    break;
            }
        }

        private static string GetVoiceStatusLabel(VoiceListenerState state)
        {
            switch (state)
            {
                case VoiceListenerState.Installing:
                case VoiceListenerState.Loading:
                    return I18n.T("Voice_StatusUnavailable");
                case VoiceListenerState.Unavailable:
                    return I18n.T("Voice_StatusUnavailable");
                case VoiceListenerState.Ready:
                    return I18n.T("Voice_StatusReady");
                case VoiceListenerState.Recognizing:
                    return I18n.T("Voice_StatusRecognizing");
                default:
                    return I18n.T("Voice_StatusUnknown");
            }
        }

        private static string BuildVoiceStatusText(string statusLabel, string statusMessage)
        {
            string msg = statusMessage ?? string.Empty;
            int retrySec = ParseRetryAfterSeconds(msg);
            if (retrySec > 0)
            {
                return I18n.Tf("Voice_StatusCooldownFormat", FormatDuration(retrySec));
            }

            if (!string.IsNullOrWhiteSpace(msg))
            {
                string compact = msg.Replace("：", " ").Trim();
                if (compact.Length > 28)
                {
                    compact = compact.Substring(0, 28) + "...";
                }
                return compact;
            }

            return I18n.Tf("Voice_StatusPrefixFormat", statusLabel);
        }

        private static int ParseRetryAfterSeconds(string message)
        {
            if (string.IsNullOrWhiteSpace(message))
                return 0;

            const string token = "retry-after-sec=";
            int idx = message.IndexOf(token, StringComparison.OrdinalIgnoreCase);
            if (idx < 0)
                return 0;

            int start = idx + token.Length;
            int end = start;
            while (end < message.Length && char.IsDigit(message[end]))
            {
                end++;
            }

            if (end <= start)
                return 0;

            string number = message.Substring(start, end - start);
            return int.TryParse(number, out int sec) ? sec : 0;
        }

        private static string FormatDuration(int totalSeconds)
        {
            if (totalSeconds <= 0)
                return I18n.Tf("Duration_Seconds", 0);

            int minutes = totalSeconds / 60;
            int seconds = totalSeconds % 60;
            if (minutes <= 0)
                return I18n.Tf("Duration_Seconds", seconds);
            if (seconds == 0)
                return I18n.Tf("Duration_Minutes", minutes);
            return I18n.Tf("Duration_MinutesSeconds", minutes, seconds);
        }

        private void ApplyVoiceStatusBrush(string bgHex, string borderHex, string fgHex)
        {
            var bg = (Brush)new BrushConverter().ConvertFromString(bgHex);
            var border = (Brush)new BrushConverter().ConvertFromString(borderHex);
            var fg = (Brush)new BrushConverter().ConvertFromString(fgHex);

            VoiceStatusButton.Background = bg;
            VoiceStatusButton.BorderBrush = border;
            VoiceStatusIcon.Foreground = fg;
            VoiceStatusText.Foreground = fg;
            VoiceStatusDot.Fill = fg;
        }

        private void StartVoiceStatusAnimation()
        {
            if (_voiceStatusAnimTimer != null && !_voiceStatusAnimTimer.IsEnabled)
            {
                _voiceStatusAnimTimer.Start();
            }
        }

        private void StopVoiceStatusAnimation()
        {
            if (_voiceStatusAnimTimer != null && _voiceStatusAnimTimer.IsEnabled)
            {
                _voiceStatusAnimTimer.Stop();
            }

            if (VoiceStatusScale != null)
            {
                VoiceStatusScale.ScaleX = 1.0;
                VoiceStatusScale.ScaleY = 1.0;
            }

            if (VoiceStatusIcon != null)
            {
                VoiceStatusIcon.Opacity = 1.0;
            }
        }

        private void VoiceStatusAnimTimer_Tick(object sender, EventArgs e)
        {
            if (VoiceStatusScale == null || VoiceStatusIcon == null)
                return;

            bool activePulse = _voiceListenerState == VoiceListenerState.Recognizing;

            if (!activePulse)
            {
                StopVoiceStatusAnimation();
                return;
            }

            bool enlarged = VoiceStatusScale.ScaleX > 1.05;
            VoiceStatusScale.ScaleX = enlarged ? 1.0 : 1.16;
            VoiceStatusScale.ScaleY = enlarged ? 1.0 : 1.16;
            VoiceStatusIcon.Opacity = enlarged ? 1.0 : 0.72;
        }

        private void MainWindow_Closed(object sender, EventArgs e)
        {
            try
            {
                VoiceListenerStatusCenter.StatusChanged -= VoiceListenerStatusCenter_StatusChanged;
                I18n.LanguageChanged -= I18n_LanguageChanged;
                VoiceListenerStatusCenter.RecognitionCaptured -= VoiceListenerStatusCenter_RecognitionCaptured;
                TaskDraftManager.DraftsChanged -= TaskDraftManager_DraftsChanged;
                if (_voiceStatusAnimTimer != null)
                {
                    _voiceStatusAnimTimer.Stop();
                    _voiceStatusAnimTimer.Tick -= VoiceStatusAnimTimer_Tick;
                    _voiceStatusAnimTimer = null;
                }

                if (_systemTickerTimer != null)
                {
                    _systemTickerTimer.Stop();
                    _systemTickerTimer.Tick -= SystemTickerTimer_Tick;
                    _systemTickerTimer = null;
                }

                if (_conversationIdleTimer != null)
                {
                    _conversationIdleTimer.Stop();
                    _conversationIdleTimer.Tick -= ConversationIdleTimer_Tick;
                    _conversationIdleTimer = null;
                }

                if (_knowledgeSyncTimer != null)
                {
                    _knowledgeSyncTimer.Stop();
                    _knowledgeSyncTimer = null;
                }

                if (_knowledgeSyncDebounceTimer != null)
                {
                    _knowledgeSyncDebounceTimer.Stop();
                    _knowledgeSyncDebounceTimer = null;
                }

                if (_obsidianWatcher != null)
                {
                    _obsidianWatcher.EnableRaisingEvents = false;
                    _obsidianWatcher.Dispose();
                    _obsidianWatcher = null;
                }

                _conversationRecorder?.EndSession();
                _draftBadgeManager?.Dispose();
            }
            catch { }
        }

        private void ApplyQuickImprovements()
        {
            try
            {
                // UX改进功能已集成到UXImprovements类中
                
                // 设置窗口为可聚焦，以便接收键盘事件
                this.Focusable = true;
                this.KeyDown += MainWindow_KeyDown;
                
                Console.WriteLine("快速改进功能已启用");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"启用快速改进功能时出错: {ex.Message}");
            }
        }

        private void LoadProactiveConfig()
        {
            _proactiveAssistEnabled = GetAppSettingBool("ProactiveAssistEnabled", true);
            _behaviorLearningEnabled = GetAppSettingBool("BehaviorLearningEnabled", true);
            _stuckNudgesEnabled = GetAppSettingBool("StuckNudgesEnabled", true);
            _llmSkillAssistEnabled = GetAppSettingBool("LlmSkillAssistEnabled", true);
            _nonBlockingInteractionEnabled = GetAppSettingBool("NonBlockingInteractionEnabled", true);
            _quietHoursStart = GetAppSettingInt("QuietHoursStart", 22, 0, 23);
            _quietHoursEnd = GetAppSettingInt("QuietHoursEnd", 8, 0, 23);
            _strategyCycleInterval = TimeSpan.FromMinutes(GetAppSettingInt("StrategyCycleIntervalMinutes", 30, 5, 180));
            int weeklyPublish = GetAppSettingInt("WeeklyReviewPublishDay", 1, 1, 7);
            _weeklyReviewPublishDay = weeklyPublish switch
            {
                1 => DayOfWeek.Monday,
                2 => DayOfWeek.Tuesday,
                3 => DayOfWeek.Wednesday,
                4 => DayOfWeek.Thursday,
                5 => DayOfWeek.Friday,
                6 => DayOfWeek.Saturday,
                _ => DayOfWeek.Sunday
            };
            _strategyTopFocusCount = GetAppSettingInt("StrategyTopFocusCount", 5, 1, 10);
            _decisionOptions = new DecisionEngineOptions
            {
                LongTermWeight = GetAppSettingDouble("DecisionWeightLongTerm", 0.45, 0.0, 1.5),
                UrgencyWeight = GetAppSettingDouble("DecisionWeightUrgency", 0.35, 0.0, 1.5),
                StrengthFitWeight = GetAppSettingDouble("DecisionWeightStrengthFit", 1.0, 0.0, 3.0),
                EnergyFitWeight = GetAppSettingDouble("DecisionWeightEnergyFit", 1.0, 0.0, 3.0),
                RiskPenaltyWeight = GetAppSettingDouble("DecisionWeightRiskPenalty", 1.0, 0.0, 3.0),
                SnapshotTopCount = _strategyTopFocusCount
            };
        }

        private static bool GetAppSettingBool(string key, bool defaultValue)
        {
            string value = ConfigurationManager.AppSettings[key];
            return bool.TryParse(value, out bool parsed) ? parsed : defaultValue;
        }

        private static int GetAppSettingInt(string key, int defaultValue, int min, int max)
        {
            string value = ConfigurationManager.AppSettings[key];
            if (int.TryParse(value, out int parsed))
            {
                return Math.Max(min, Math.Min(max, parsed));
            }
            return defaultValue;
        }

        private static double GetAppSettingDouble(string key, double defaultValue, double min, double max)
        {
            string value = ConfigurationManager.AppSettings[key];
            if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed) ||
                double.TryParse(value, out parsed))
            {
                return Math.Max(min, Math.Min(max, parsed));
            }
            return defaultValue;
        }

        private bool IsInQuietHours(DateTime now)
        {
            if (_quietHoursStart == _quietHoursEnd)
            {
                return false;
            }

            if (_quietHoursStart < _quietHoursEnd)
            {
                return now.Hour >= _quietHoursStart && now.Hour < _quietHoursEnd;
            }

            return now.Hour >= _quietHoursStart || now.Hour < _quietHoursEnd;
        }

        private bool CanRunProactiveAssist(DateTime now)
        {
            return _proactiveAssistEnabled && !IsInQuietHours(now);
        }

        private bool ShouldRecordBehavior()
        {
            return _behaviorLearningEnabled && _userProfileManager != null;
        }

        private void RecordTaskProgressProfile(ItemGrid task, string source)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordTaskProgress(task, source);
            }
        }

        private void RecordReminderShownProfile(ItemGrid task)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordReminderShown(task);
            }
        }

        private void RecordReminderResultProfile(ItemGrid task, TaskReminderResult result)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordReminderResult(task, result);
            }
        }

        private void RecordSuggestionShownProfile(string suggestionId)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordSuggestionShown(suggestionId);
            }
        }

        private void RecordSuggestionFeedbackProfile(string suggestionId, string feedbackType)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordSuggestionFeedback(suggestionId, feedbackType);
            }
        }

        private void RecordQuadrantMoveProfile(ItemGrid task, string sourceQuadrantNumber, string targetQuadrantNumber)
        {
            if (ShouldRecordBehavior())
            {
                _userProfileManager.RecordQuadrantMove(task, sourceQuadrantNumber, targetQuadrantNumber);
            }
        }

        private void InitializeDraftBadgeMonitor()
        {
            try
            {
                _draftBadgeManager = new TaskDraftManager();
                TaskDraftManager.DraftsChanged += TaskDraftManager_DraftsChanged;
                _draftBadgeTimer = new System.Windows.Threading.DispatcherTimer();
                _draftBadgeTimer.Interval = TimeSpan.FromSeconds(3);
                _draftBadgeTimer.Tick += (s, e) => UpdateDraftBadge();
                _draftBadgeTimer.Start();
                UpdateDraftBadge();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Draft badge init failed: {ex.Message}");
            }
        }

        private void InitializeSmartSystems()
        {
            try
            {
                string dataPath = Path.Combine(currentPath, "data");
                Directory.CreateDirectory(dataPath);

                _behaviorObserver = new UserBehaviorObserver(dataPath);
                _smartGuidanceManager = new SmartGuidanceManager(dataPath);
                _conversationRecorder = new ConversationRecorder(dataPath);
                _adaptiveGoalManager = new AdaptiveGoalManager(dataPath, _userProfileManager, _behaviorObserver);
                _lifeProfileEngine = new LifeProfileEngine(dataPath);
                _decisionEngine = new DecisionEngine(dataPath, _decisionOptions);
                _weeklyReviewEngine = new WeeklyReviewEngine(dataPath);
                _goalHierarchyEngine = new GoalHierarchyEngine(dataPath);

                _smartGuidanceManager.ScenarioTriggered += SmartGuidanceManager_ScenarioTriggered;
                _conversationRecorder.ConversationEnded += ConversationRecorder_ConversationEnded;
                _behaviorObserver.NewInsightGenerated += BehaviorObserver_NewInsightGenerated;
                _adaptiveGoalManager.AdjustmentSuggested += AdaptiveGoalManager_AdjustmentSuggested;
                _adaptiveGoalManager.GoalAtRisk += AdaptiveGoalManager_GoalAtRisk;

                _smartGuidanceManager.Initialize();

                _smartSystemTimer = new System.Windows.Threading.DispatcherTimer();
                _smartSystemTimer.Interval = TimeSpan.FromMinutes(5);
                _smartSystemTimer.Tick += SmartSystemTimer_Tick;
                _smartSystemTimer.Start();

                VoiceListenerStatusCenter.RecognitionCaptured -= VoiceListenerStatusCenter_RecognitionCaptured;
                VoiceListenerStatusCenter.RecognitionCaptured += VoiceListenerStatusCenter_RecognitionCaptured;
                _conversationIdleTimer = new System.Windows.Threading.DispatcherTimer();
                _conversationIdleTimer.Interval = TimeSpan.FromSeconds(15);
                _conversationIdleTimer.Tick += ConversationIdleTimer_Tick;
                _conversationIdleTimer.Start();

                RunStrategicNavigationCycle(force: true);
                Console.WriteLine("[SmartSystems] Initialized successfully");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[SmartSystems] Initialization failed: {ex.Message}");
            }
        }

        private void SmartSystemTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                _smartGuidanceManager.CheckAndTriggerScenarios();
                _adaptiveGoalManager.CheckAndAdjustGoals();
                RunStrategicNavigationCycle(force: false);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[SmartSystems] Timer tick failed: {ex.Message}");
            }
        }

        private void RunStrategicNavigationCycle(bool force)
        {
            try
            {
                DateTime now = DateTime.Now;
                if (!force && (now - _lastStrategyCycleAt) < _strategyCycleInterval)
                {
                    return;
                }

                var allTasks = GetAllQuadrantTasks();
                var activeGoals = LoadActiveLongTermGoals();
                UserProfileSnapshot behaviorSnapshot = ShouldRecordBehavior() ? _userProfileManager.GetSnapshotCopy() : new UserProfileSnapshot();
                var lifeProfile = _lifeProfileEngine?.BuildAndPersist(behaviorSnapshot, allTasks, now) ?? new LifeProfileSnapshot();
                _goalHierarchyEngine?.BuildAndPersist(activeGoals, allTasks, now);
                var ranked = _decisionEngine?.RankTasks(allTasks, lifeProfile, _activeLongTermGoal?.Id, now) ?? new List<TaskDecisionScore>();
                _decisionEngine?.PersistSnapshot(ranked, now);

                WeeklyReviewReport weeklyReport = null;
                bool shouldRunWeekly = force || now.DayOfWeek == _weeklyReviewPublishDay;
                if (shouldRunWeekly)
                {
                    weeklyReport = _weeklyReviewEngine?.GenerateAndPersist(
                        allTasks,
                        activeGoals,
                        lifeProfile,
                        ranked,
                        now,
                        force: now.DayOfWeek == _weeklyReviewPublishDay);
                }

                if (weeklyReport != null && _lastWeeklyReviewNoticeDate.Date != now.Date)
                {
                    _lastWeeklyReviewNoticeDate = now.Date;
                    string focusSummary = string.Join("、", weeklyReport.TopFocusTasks.Take(Math.Max(1, _strategyTopFocusCount)).Select(t => t.TaskName));
                    ShowPassiveNotification(
                        "已生成周复盘",
                        $"周期 {weeklyReport.WeekStart:MM-dd}~{weeklyReport.WeekEnd:MM-dd}，建议聚焦：{focusSummary}",
                        System.Windows.Forms.ToolTipIcon.Info);
                }

                _lastStrategyCycleAt = now;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[StrategyCycle] failed: {ex.Message}");
            }
        }

        private List<ItemGrid> GetAllQuadrantTasks()
        {
            var tasks = new List<ItemGrid>();
            AddQuadrantItems(tasks, task1?.ItemsSource);
            AddQuadrantItems(tasks, task2?.ItemsSource);
            AddQuadrantItems(tasks, task3?.ItemsSource);
            AddQuadrantItems(tasks, task4?.ItemsSource);
            return tasks;
        }

        private static void AddQuadrantItems(List<ItemGrid> target, IEnumerable source)
        {
            if (target == null || source == null)
            {
                return;
            }

            foreach (object item in source)
            {
                if (item is ItemGrid task && task != null)
                {
                    target.Add(task);
                }
            }
        }

        public static FocusBoardSnapshot BuildFocusBoardSnapshot(IEnumerable<ItemGrid> sourceTasks, DateTime now)
        {
            var tasks = (sourceTasks ?? Enumerable.Empty<ItemGrid>())
                .Where(t => t != null && t.IsActive && !string.IsNullOrWhiteSpace(t.Task))
                .ToList();

            var snapshot = new FocusBoardSnapshot();
            if (tasks.Count == 0)
            {
                return snapshot;
            }

            ItemGrid primary = tasks
                .OrderByDescending(t => string.Equals(t.Importance, "High", StringComparison.OrdinalIgnoreCase))
                .ThenByDescending(t => string.Equals(t.Urgency, "High", StringComparison.OrdinalIgnoreCase))
                .ThenByDescending(t => t.ReminderTime.HasValue && t.ReminderTime.Value <= now.AddHours(6))
                .ThenByDescending(t => t.InactiveWarningCount)
                .ThenByDescending(t => t.Score)
                .ThenBy(t => t.ReminderTime ?? DateTime.MaxValue)
                .FirstOrDefault();

            if (primary != null)
            {
                snapshot.PrimaryTask = primary;
                string quadrant = GetQuadrantDisplayName(primary.Importance, primary.Urgency);
                if (primary.ReminderTime.HasValue)
                {
                    snapshot.PrimaryMeta = I18n.Tf("FocusBoard_PrimaryMetaWithReminderFormat", quadrant, primary.ReminderTime.Value);
                }
                else
                {
                    snapshot.PrimaryMeta = I18n.Tf("FocusBoard_PrimaryMetaFormat", quadrant);
                }
            }

            ItemGrid reminder = tasks
                .Where(t => t.ReminderTime.HasValue && t.ReminderTime.Value >= now)
                .OrderBy(t => t.ReminderTime.Value)
                .FirstOrDefault();

            if (reminder != null)
            {
                snapshot.ReminderTask = reminder;
                TimeSpan remain = reminder.ReminderTime.Value - now;
                snapshot.ReminderMeta = I18n.Tf("FocusBoard_ReminderMetaFormat", reminder.ReminderTime.Value, FormatFocusDuration(remain));
            }

            ItemGrid stuck = tasks
                .OrderByDescending(t => now - t.LastProgressDate)
                .ThenByDescending(t => t.InactiveWarningCount)
                .FirstOrDefault();

            if (stuck != null)
            {
                snapshot.StuckTask = stuck;
                snapshot.StuckMeta = I18n.Tf("FocusBoard_StuckMetaFormat", FormatFocusDuration(now - stuck.LastProgressDate));
            }

            return snapshot;
        }

        public static SystemProgressSnapshot BuildSystemProgressSnapshot(
            IEnumerable<ItemGrid> sourceTasks,
            LongTermGoal activeGoal,
            UserProfileMetrics metrics,
            DateTime now)
        {
            var tasks = (sourceTasks ?? Enumerable.Empty<ItemGrid>()).Where(t => t != null).ToList();
            int activeCount = tasks.Count(t => t.IsActive && !string.IsNullOrWhiteSpace(t.Task));
            int completedCount = tasks.Count(t => !t.IsActive);
            int highPriorityCount = tasks.Count(t => t.IsActive &&
                string.Equals(t.Importance, "High", StringComparison.OrdinalIgnoreCase));
            int reminderCount = tasks.Count(t => t.IsActive && t.ReminderTime.HasValue);
            int stuckCount = tasks.Count(t => t.IsActive && (now - t.LastProgressDate) >= TimeSpan.FromDays(3));

            int accepted = metrics?.SuggestionsAccepted ?? 0;
            int experience = completedCount * 120 + highPriorityCount * 25 + reminderCount * 10 + accepted * 15 + activeCount * 5;
            int level = Math.Max(1, experience / 250 + 1);
            int nextLevelExperience = level * 250;

            string questName = activeGoal != null
                ? (activeGoal.IsLearningPlan ? activeGoal.Subject : activeGoal.Description)
                : null;
            if (string.IsNullOrWhiteSpace(questName))
            {
                questName = activeCount > 0
                    ? tasks.Where(t => t.IsActive && !string.IsNullOrWhiteSpace(t.Task))
                        .OrderByDescending(t => string.Equals(t.Importance, "High", StringComparison.OrdinalIgnoreCase))
                        .ThenByDescending(t => string.Equals(t.Urgency, "High", StringComparison.OrdinalIgnoreCase))
                        .Select(t => t.Task)
                        .FirstOrDefault()
                    : I18n.T("SystemPanel_QuestEmpty");
            }

            string recommendedSkillId = GetRecommendedSkillId(tasks, activeGoal, now);
            string recommendedSkillTitle = SkillManagementService.GetSkillDefinitions()
                .FirstOrDefault(s => string.Equals(s.SkillId, recommendedSkillId, StringComparison.OrdinalIgnoreCase))
                ?.Title ?? I18n.T("SystemPanel_SkillFallback");

            string stageText = activeGoal != null
                ? I18n.Tf("SystemPanel_StageGoalFormat", level, questName)
                : I18n.Tf("SystemPanel_StageDefaultFormat", level, activeCount);

            string narrativeText;
            if (stuckCount >= 3)
            {
                narrativeText = I18n.T("SystemPanel_NarrativeStuck");
            }
            else if (highPriorityCount >= 3)
            {
                narrativeText = I18n.T("SystemPanel_NarrativeBattle");
            }
            else if (activeGoal != null)
            {
                narrativeText = I18n.T("SystemPanel_NarrativeQuest");
            }
            else
            {
                narrativeText = I18n.T("SystemPanel_NarrativeDefault");
            }

            return new SystemProgressSnapshot
            {
                Level = level,
                Experience = experience,
                NextLevelExperience = nextLevelExperience,
                StageText = stageText,
                NarrativeText = narrativeText,
                ActiveQuestText = I18n.Tf("SystemPanel_QuestFormat", questName),
                RecommendedSkillText = I18n.Tf("SystemPanel_SkillFormat", recommendedSkillTitle),
                SkillNodes = BuildSystemSkillNodes(tasks, activeGoal, now, recommendedSkillId)
            };
        }

        private static List<SystemSkillNodeSnapshot> BuildSystemSkillNodes(
            List<ItemGrid> tasks,
            LongTermGoal activeGoal,
            DateTime now,
            string recommendedSkillId)
        {
            var performance = new UserProfileManager()
                .GetActionPerformance(30)
                .ToDictionary(x => x.ActionId, StringComparer.OrdinalIgnoreCase);
            var definitions = SkillManagementService.GetSkillDefinitions()
                .Where(d => d != null)
                .ToDictionary(d => d.SkillId, StringComparer.OrdinalIgnoreCase);

            var seedSkillIds = new List<string>
            {
                recommendedSkillId,
                "decompose",
                "focus_sprint",
                "risk_check",
                "clarify_goal"
            };

            var selectedIds = seedSkillIds
                .Where(id => !string.IsNullOrWhiteSpace(id))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .Take(4)
                .ToList();

            while (selectedIds.Count < 4)
            {
                string fallback = definitions.Keys.FirstOrDefault(k => !selectedIds.Contains(k, StringComparer.OrdinalIgnoreCase));
                if (fallback == null)
                {
                    break;
                }

                selectedIds.Add(fallback);
            }

            var nodes = new List<SystemSkillNodeSnapshot>();
            foreach (string skillId in selectedIds)
            {
                definitions.TryGetValue(skillId, out var definition);
                performance.TryGetValue(skillId, out var stat);

                int accepted = stat?.Accepted ?? 0;
                int shown = stat?.Shown ?? 0;
                int level = Math.Max(1, accepted / 2 + (shown > 0 ? 1 : 0));
                string meta;

                if (string.Equals(skillId, recommendedSkillId, StringComparison.OrdinalIgnoreCase))
                {
                    meta = I18n.T("SystemPanel_SkillNodeEquipped");
                }
                else if (accepted > 0)
                {
                    meta = I18n.Tf("SystemPanel_SkillNodeAcceptedFormat", accepted);
                }
                else if (shown > 0)
                {
                    meta = I18n.Tf("SystemPanel_SkillNodeSeenFormat", shown);
                }
                else if (activeGoal != null && string.Equals(skillId, "clarify_goal", StringComparison.OrdinalIgnoreCase))
                {
                    meta = I18n.T("SystemPanel_SkillNodeGoalLinked");
                }
                else if (tasks.Any(t => (now - t.LastProgressDate) >= TimeSpan.FromDays(3)) &&
                         string.Equals(skillId, "risk_check", StringComparison.OrdinalIgnoreCase))
                {
                    meta = I18n.T("SystemPanel_SkillNodeHot");
                }
                else
                {
                    meta = I18n.T("SystemPanel_SkillNodeLocked");
                }

                nodes.Add(new SystemSkillNodeSnapshot
                {
                    SkillId = skillId,
                    Title = definition?.Title ?? skillId,
                    Level = level,
                    MetaText = meta,
                    ToolTipText = $"{definition?.Description ?? skillId}\n{meta}"
                });
            }

            return nodes;
        }

        private static string GetRecommendedSkillId(IEnumerable<ItemGrid> sourceTasks, LongTermGoal activeGoal, DateTime now)
        {
            var tasks = (sourceTasks ?? Enumerable.Empty<ItemGrid>())
                .Where(t => t != null && t.IsActive && !string.IsNullOrWhiteSpace(t.Task))
                .ToList();

            if (activeGoal == null)
            {
                return "clarify_goal";
            }

            if (tasks.Any(t => (now - t.LastProgressDate) >= TimeSpan.FromDays(3)))
            {
                return "risk_check";
            }

            if (tasks.Any(t => string.Equals(t.Importance, "High", StringComparison.OrdinalIgnoreCase) &&
                               string.Equals(t.Urgency, "High", StringComparison.OrdinalIgnoreCase)))
            {
                return "focus_sprint";
            }

            if (tasks.Any(t => !string.IsNullOrWhiteSpace(t.Task) && t.Task.Length >= 18))
            {
                return "decompose";
            }

            return "priority_rebalance";
        }

        private static string GetQuadrantDisplayName(string importance, string urgency)
        {
            if (string.Equals(importance, "High", StringComparison.OrdinalIgnoreCase) &&
                string.Equals(urgency, "High", StringComparison.OrdinalIgnoreCase))
            {
                return I18n.T("Quadrant_ImportantUrgent");
            }

            if (string.Equals(importance, "High", StringComparison.OrdinalIgnoreCase))
            {
                return I18n.T("Quadrant_ImportantNotUrgent");
            }

            if (string.Equals(urgency, "High", StringComparison.OrdinalIgnoreCase))
            {
                return I18n.T("Quadrant_NotImportantUrgent");
            }

            return I18n.T("Quadrant_NotImportantNotUrgent");
        }

        private static string FormatFocusDuration(TimeSpan duration)
        {
            if (duration.TotalDays >= 1)
            {
                return I18n.Tf("FocusBoard_DurationDaysFormat", (int)Math.Round(duration.TotalDays));
            }

            if (duration.TotalHours >= 1)
            {
                return I18n.Tf("FocusBoard_DurationHoursFormat", (int)Math.Round(duration.TotalHours));
            }

            int minutes = Math.Max(1, (int)Math.Round(duration.TotalMinutes));
            return I18n.Tf("FocusBoard_DurationMinutesFormat", minutes);
        }

        private List<LongTermGoal> LoadActiveLongTermGoals()
        {
            try
            {
                string goalsPath = Path.Combine(currentPath, "data", "long_term_goals.csv");
                if (!File.Exists(goalsPath))
                {
                    return new List<LongTermGoal>();
                }

                var goals = HelperClass.ReadLongTermGoalsCsv(goalsPath) ?? new List<LongTermGoal>();
                return goals.Where(g => g != null && g.IsActive).ToList();
            }
            catch
            {
                return new List<LongTermGoal>();
            }
        }

        private void SmartGuidanceManager_ScenarioTriggered(OnboardingScenario scenario)
        {
            try
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    ShowGuidanceNotification(scenario);
                }));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[SmartGuidance] Failed to show scenario: {ex.Message}");
            }
        }

        private void ShowGuidanceNotification(OnboardingScenario scenario)
        {
            if (scenario != null && scenario.AutoActivate)
            {
                _ = HandleScenarioActionAsync(scenario, true);
                return;
            }

            if (_nonBlockingInteractionEnabled)
            {
                ShowPassiveNotification(
                    scenario?.Title ?? "功能引导",
                    $"{scenario?.Description}\n已记录本次引导，你可在合适的时候再操作。",
                    System.Windows.Forms.ToolTipIcon.Info);
                _smartGuidanceManager.CompleteScenario(scenario.ScenarioId);
                return;
            }

            var result = MessageBox.Show(
                $"{scenario.Description}\n\n是否现在操作？",
                scenario.Title,
                MessageBoxButton.YesNo,
                MessageBoxImage.Information);

            if (result == MessageBoxResult.Yes)
            {
                _ = HandleScenarioActionAsync(scenario, false);
            }
            else
            {
                _smartGuidanceManager.CompleteScenario(scenario.ScenarioId);
            }
        }

        private async Task HandleScenarioActionAsync(OnboardingScenario scenario, bool autoActivated)
        {
            switch (scenario.ScenarioId)
            {
                case "first_task":
                    AddQuickTask_Click(null, null);
                    break;
                case "long_term_goal_intro":
                    LongTermGoalButton_Click(null, null);
                    break;
                case "skill_decompose_intro":
                    AutoEnableSkill("decompose");
                    ShowSkillRecommendation("decompose");
                    break;
                case "skill_focus_sprint_intro":
                    AutoEnableSkill("focus_sprint");
                    if (!TryAutoActivateFocusSprintSkill())
                    {
                        ShowSkillRecommendation("focus_sprint");
                    }
                    break;
                case "voice_task_intro":
                    ShowVoiceSettings();
                    break;
                case "goal_progress_check":
                    OpenLongTermGoalManager();
                    break;
            }

            if (autoActivated)
            {
                if (_nonBlockingInteractionEnabled)
                {
                    ShowPassiveNotification(
                        scenario?.Title ?? "功能引导",
                        "已自动触发一次引导动作，你可随时继续调整。",
                        System.Windows.Forms.ToolTipIcon.Info);
                }
                else
                {
                    MessageBox.Show(
                        "已自动触发一次引导动作，帮助你快速开始使用该功能。你仍可在管理界面中继续调整。",
                        scenario.Title,
                        MessageBoxButton.OK,
                        MessageBoxImage.Information);
                }
            }

            _smartGuidanceManager.CompleteScenario(scenario.ScenarioId);
        }

        private void AutoEnableSkill(string skillId)
        {
            if (string.IsNullOrWhiteSpace(skillId))
            {
                return;
            }

            var enabled = SkillManagementService.LoadEnabledSkillIds();
            if (enabled.Contains(skillId))
            {
                return;
            }

            enabled.Add(skillId);
            SkillManagementService.SaveEnabledSkillIds(enabled);
        }

        private async Task<bool> TryAutoActivateDecomposeSkillAsync()
        {
            var target = GetActiveTasks()
                .Where(t => !string.IsNullOrWhiteSpace(t.Task))
                .OrderByDescending(t => t.Task.Length)
                .FirstOrDefault(t => t.Task.Length >= 12);

            if (target == null)
            {
                return false;
            }

            await HandleTaskDecomposition(target);
            return true;
        }

        private bool TryAutoActivateFocusSprintSkill()
        {
            DateTime now = DateTime.Now;
            var target = GetActiveTasks()
                .Where(t => (now - t.LastProgressDate) > TimeSpan.FromHours(2))
                .OrderByDescending(t => now - t.LastProgressDate)
                .FirstOrDefault();
            if (target == null)
            {
                return false;
            }

            ShowFriendlyReminder(target, "建议开启一次 25 分钟专注冲刺，只完成一个最小可交付动作。");
            return true;
        }

        private List<ItemGrid> GetActiveTasks()
        {
            var tasks = new List<ItemGrid>();
            var grids = new[] { task1, task2, task3, task4 };
            foreach (var grid in grids)
            {
                if (grid?.ItemsSource is List<ItemGrid> items)
                {
                    tasks.AddRange(items.Where(t => t.IsActive));
                }
            }

            return tasks;
        }

        private void VoiceListenerStatusCenter_RecognitionCaptured(object sender, VoiceRecognitionRecord record)
        {
            try
            {
                if (_conversationRecorder == null || record == null || string.IsNullOrWhiteSpace(record.Text))
                {
                    return;
                }

                _conversationRecorder.StartSession();
                _conversationRecorder.AddAudioSegment(record.AudioPcm16Mono, record.Text, record.Confidence, record.Source);
                _lastVoiceConversationSegmentAtUtc = DateTime.UtcNow;

                if (_behaviorObserver != null)
                {
                    _behaviorObserver.RecordVoiceInteraction(record.Text, record.Confidence, record.Source);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[VoiceBridge] Failed to ingest recognition: {ex.Message}");
            }
        }

        private void ConversationIdleTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                if (_conversationRecorder == null || _lastVoiceConversationSegmentAtUtc == DateTime.MinValue)
                {
                    return;
                }

                if ((DateTime.UtcNow - _lastVoiceConversationSegmentAtUtc) >= ConversationIdleTimeout)
                {
                    _conversationRecorder.EndSession();
                    _lastVoiceConversationSegmentAtUtc = DateTime.MinValue;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[VoiceBridge] Idle session finalize failed: {ex.Message}");
            }
        }

        private void ConversationRecorder_ConversationEnded(ConversationSession session)
        {
            try
            {
                _behaviorObserver.RecordSystemEvent("conversation_ended", 
                    $"Type: {session.Type}, Duration: {(session.EndTime - session.StartTime)?.TotalMinutes:F1}min, Tasks: {session.ExtractedTasks.Count}");

                if (session.ExtractedTasks.Any())
                {
                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        ShowConversationTasksNotification(session);
                    }));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ConversationRecorder] Failed to handle session end: {ex.Message}");
            }
        }

        private void ShowConversationTasksNotification(ConversationSession session)
        {
            var taskList = string.Join("\n", session.ExtractedTasks.Take(5).Select((t, i) => $"{i + 1}. {t}"));

            if (_nonBlockingInteractionEnabled)
            {
                var selectedTasks = session.ExtractedTasks
                    .Where(t => !string.IsNullOrWhiteSpace(t))
                    .Distinct(StringComparer.OrdinalIgnoreCase)
                    .Take(3)
                    .ToList();

                if (selectedTasks.Count > 0)
                {
                    AddConversationTasks(selectedTasks);
                    ShowPassiveNotification(
                        "对话任务识别",
                        $"已自动添加 {selectedTasks.Count} 条任务，你可在四象限中随时修改或删除。",
                        System.Windows.Forms.ToolTipIcon.Info);
                }
                _conversationRecorder.MarkSessionAsProcessed(session.SessionId);
                return;
            }

            var result = MessageBox.Show(
                $"从对话中识别到以下任务：\n\n{taskList}\n\n是否添加到任务列表？",
                "对话任务识别",
                MessageBoxButton.YesNo,
                MessageBoxImage.Question);

            if (result == MessageBoxResult.Yes)
            {
                AddConversationTasks(session.ExtractedTasks);
            }

            _conversationRecorder.MarkSessionAsProcessed(session.SessionId);
        }

        private void AddConversationTasks(List<string> tasks)
        {
            foreach (var taskText in tasks.Take(5))
            {
                var intentRecognizer = new IntentRecognizer();
                var (importance, urgency) = intentRecognizer.EstimatePriority(taskText);
                var quadrant = intentRecognizer.EstimateQuadrant(importance, urgency);

                var newTask = new ItemGrid
                {
                    Task = taskText,
                    Score = 1,
                    Result = "",
                    IsActive = true,
                    Importance = importance,
                    Urgency = urgency,
                    CreatedDate = DateTime.Now,
                    LastModifiedDate = DateTime.Now,
                    IsActiveInQuadrant = true
                };

                AddTaskToQuadrant(newTask, quadrant);
                _behaviorObserver?.RecordTaskOperation("conversation_extract_add", taskText, GetTaskTrackingKey(newTask));
            }
        }

        private void BehaviorObserver_NewInsightGenerated(WorkHabitInsight insight)
        {
            try
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    ShowInsightNotification(insight);
                }));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[BehaviorObserver] Failed to show insight: {ex.Message}");
            }
        }

        private void ShowInsightNotification(WorkHabitInsight insight)
        {
            if (_nonBlockingInteractionEnabled)
            {
                _behaviorObserver.AcknowledgeInsight(insight.InsightId);
                ShowPassiveNotification(
                    insight?.Title ?? "习惯洞察",
                    $"{insight?.Description}\n建议：{insight?.Recommendation}",
                    System.Windows.Forms.ToolTipIcon.Info);
                return;
            }

            var result = MessageBox.Show(
                $"{insight.Description}\n\n建议：{insight.Recommendation}\n\n是否标记为已读？",
                insight.Title,
                MessageBoxButton.YesNo,
                MessageBoxImage.Information);

            if (result == MessageBoxResult.Yes)
            {
                _behaviorObserver.AcknowledgeInsight(insight.InsightId);
            }
        }

        private void AdaptiveGoalManager_AdjustmentSuggested(GoalAdjustmentSuggestion suggestion)
        {
            try
            {
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    ShowAdjustmentSuggestionNotification(suggestion);
                }));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[AdaptiveGoalManager] Failed to show suggestion: {ex.Message}");
            }
        }

        private void ShowAdjustmentSuggestionNotification(GoalAdjustmentSuggestion suggestion)
        {
            if (_nonBlockingInteractionEnabled)
            {
                ShowPassiveNotification(
                    "目标调整建议",
                    $"目标：{suggestion?.GoalDescription}\n建议：{suggestion?.Suggestion}\n已保存建议，可稍后在目标管理中处理。",
                    System.Windows.Forms.ToolTipIcon.Warning);
                _behaviorObserver?.RecordSystemEvent("goal_adjustment_notified_passive", $"Goal: {suggestion?.GoalDescription}, Type: {suggestion?.AdjustmentType}");
                return;
            }

            var result = MessageBox.Show(
                $"目标：{suggestion.GoalDescription}\n\n原因：{suggestion.Reason}\n\n建议：{suggestion.Suggestion}\n\n是否接受此建议？",
                "目标调整建议",
                MessageBoxButton.YesNoCancel,
                MessageBoxImage.Warning);

            if (result == MessageBoxResult.Yes)
            {
                _adaptiveGoalManager.AcceptSuggestion(suggestion.SuggestionId);
            }
            else if (result == MessageBoxResult.No)
            {
                _adaptiveGoalManager.DismissSuggestion(suggestion.SuggestionId);
            }
        }

        private void AdaptiveGoalManager_GoalAtRisk(GoalProgressTracker tracker)
        {
            try
            {
                _behaviorObserver.RecordSystemEvent("goal_at_risk", 
                    $"GoalId: {tracker.GoalId}, Behind: {tracker.IsBehindSchedule}, Stuck: {tracker.StuckTasks}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[AdaptiveGoalManager] Failed to handle goal at risk: {ex.Message}");
            }
        }

        private void AddTaskToQuadrant(ItemGrid task, string quadrantName)
        {
            DataGrid targetDataGrid = null;
            string csvFileNumber = "";

            switch (quadrantName)
            {
                case "重要且紧急":
                    targetDataGrid = task1;
                    csvFileNumber = "1";
                    break;
                case "重要不紧急":
                    targetDataGrid = task2;
                    csvFileNumber = "2";
                    break;
                case "不重要紧急":
                    targetDataGrid = task3;
                    csvFileNumber = "3";
                    break;
                case "不重要不紧急":
                    targetDataGrid = task4;
                    csvFileNumber = "4";
                    break;
                default:
                    targetDataGrid = task1;
                    csvFileNumber = "1";
                    break;
            }

            if (targetDataGrid != null)
            {
                var items = targetDataGrid.ItemsSource as List<ItemGrid> ?? new List<ItemGrid>();
                items.Add(task);
                for (int i = 0; i < items.Count; i++)
                {
                    items[i].Score = items.Count - i;
                }
                targetDataGrid.ItemsSource = items;
                RefreshDataGrid(targetDataGrid);
                update_csv(targetDataGrid, csvFileNumber);
            }
        }

        private void ShowSkillRecommendation(string skillId)
        {
            var skillDefinitions = SkillManagementService.GetSkillDefinitions();
            var skill = skillDefinitions.FirstOrDefault(s => s.SkillId == skillId);
            
            if (skill != null)
            {
                MessageBox.Show(
                    $"{skill.Description}\n\n建议使用此功能来优化任务管理。",
                    skill.Title,
                    MessageBoxButton.OK,
                    MessageBoxImage.Information);
            }
        }

        private void ShowVoiceSettings()
        {
            MessageBox.Show(
                "语音功能可以帮助你快速记录任务。\n\n在设置中开启语音监听，然后通过说话来添加任务。",
                "语音功能介绍",
                MessageBoxButton.OK,
                MessageBoxImage.Information);
        }

        private void OpenLongTermGoalManager()
        {
            var goalsPath = Path.Combine(currentPath, "data", "long_term_goals.csv");
            var goals = File.Exists(goalsPath) ? HelperClass.ReadLongTermGoalsCsv(goalsPath) : new List<LongTermGoal>();
            var activeGoal = goals.FirstOrDefault(g => g.IsActive);
            
            if (activeGoal != null)
            {
                var managerWindow = new LongTermGoalManagerWindow(activeGoal, Path.Combine(currentPath, "data"));
                managerWindow.ShowDialog();
                _behaviorObserver?.RecordGoalOperation("review", activeGoal.Description, activeGoal.Id);
            }
            else
            {
                MessageBox.Show(I18n.T("SetGoal_NoActiveGoal"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private void UpdateDraftBadge()
        {
            try
            {
                if (_draftBadgeManager == null) return;
                _draftBadgeManager.Refresh();
                int count = _draftBadgeManager.UnprocessedCount;
                if (DraftBadge == null || DraftBadgeText == null) return;

                DraftBadge.Visibility = count > 0 ? Visibility.Visible : Visibility.Collapsed;
                DraftBadgeText.Text = count > 99 ? "99+" : count.ToString();
            }
            catch { }
        }

        private void TaskDraftManager_DraftsChanged()
        {
            try
            {
                if (!Dispatcher.CheckAccess())
                {
                    Dispatcher.BeginInvoke(new Action(UpdateDraftBadge));
                    return;
                }

                UpdateDraftBadge();
            }
            catch { }
        }

        private void MainWindow_KeyDown(object sender, KeyEventArgs e)
        {
            // 处理全局快捷键
            if (e.Key == Key.F1)
            {
                ShowHelpDialog();
                e.Handled = true;
            }
        }

        private void ShowHelpDialog()
        {
            var helpMessage = @"TimeTask 快捷键帮助

常用快捷键:
• Ctrl+N: 快速添加新任务
• Ctrl+F: 搜索任务
• Ctrl+S: 保存所有任务
• Del: 删除选中任务
• F2: 编辑选中任务
• Tab/Shift+Tab: 在象限间切换
• Escape: 清除选择
• F1: 显示此帮助

鼠标操作:
• 双击空白区域: 添加新任务
• 右键菜单: 批量操作
• 拖拽: 移动任务到其他象限

提示: 可以使用Ctrl+多选进行批量操作";

            MessageBox.Show(helpMessage, "快捷键帮助", MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private void ActiveLongTermGoalDisplay_Click(object sender, RoutedEventArgs e)
        {
            if (_activeLongTermGoal != null)
            {
                if (_activeLongTermGoal.IsLearningPlan)
                {
                    string dataFolderPath = Path.Combine(currentPath, "data");
                    LearningPlanManagerWindow managerWindow = new LearningPlanManagerWindow(_activeLongTermGoal, dataFolderPath)
                    {
                        Owner = this
                    };
                    managerWindow.ShowDialog();
                    LoadActiveLongTermGoalAndRefreshDisplay();
                }
                else
                {
                    string dataFolderPath = Path.Combine(currentPath, "data");
                    TimeTask.LongTermGoalManagerWindow managerWindow = new TimeTask.LongTermGoalManagerWindow(_activeLongTermGoal, dataFolderPath)
                    {
                        Owner = this
                    };
                    bool? result = managerWindow.ShowDialog();

                    if (result == true)
                    {
                        LoadActiveLongTermGoalAndRefreshDisplay();
                        loadDataGridView();
                    }
                }
            }
            else
            {
                MessageBox.Show("No active long-term goal to manage.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private async void ShowFriendlyReminder(ItemGrid task, string message)
        {
            try
            {
                // Generate AI-powered reminder and suggestions
                TimeSpan taskAge = DateTime.Now - task.CreatedDate;
                TimeSpan inactiveDuration = DateTime.Now - task.LastProgressDate;
                string reminderContext = ShouldRecordBehavior() ? _userProfileManager.BuildReminderContext(task, inactiveDuration) : null;
                var (reminder, suggestions) = await _llmService.GenerateTaskReminderAsync(task.Task, taskAge, reminderContext);
                var mergedSuggestions = new List<string>(suggestions ?? new List<string>());

                if (_llmSkillAssistEnabled)
                {
                    try
                    {
                        var skillRecs = await _llmService.RecommendTaskSkillsAsync(
                            task.Task,
                            task.Importance,
                            task.Urgency,
                            inactiveDuration,
                            reminderContext,
                            2);
                        skillRecs = SkillManagementService.FilterEnabled(skillRecs);
                        var shownSkillIds = new List<string>();
                        mergedSuggestions = MergeSkillSuggestions(mergedSuggestions, skillRecs, shownSkillIds);
                        RememberPendingReminderSkills(task, shownSkillIds);
                    }
                    catch (Exception skillEx)
                    {
                        Console.WriteLine($"Skill recommendation failed: {skillEx.Message}");
                    }
                }
                
                // Show modern reminder window
                var reminderWindow = new TaskReminderWindow(task, reminder ?? message, mergedSuggestions)
                {
                    Owner = this
                };
                
                var result = reminderWindow.ShowDialog();
                if (result == true)
                {
                    await HandleTaskReminderResult(task, reminderWindow.Result);
                }
                else
                {
                    await HandleTaskReminderResult(task, TaskReminderResult.Dismissed);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error showing friendly reminder: {ex.Message}");
                string friendlyError = GetFriendlyErrorMessage(ex.Message);
                MessageBox.Show(this, friendlyError, "提醒生成失败", MessageBoxButton.OK, MessageBoxImage.Warning);
                // Fallback to simple notification
                ShowSimpleNotification(task, message);
            }
        }
        
        private void ShowSimpleNotification(ItemGrid task, string message)
        {
            var notification = new System.Windows.Forms.NotifyIcon
            {
                Visible = true,
                Icon = System.Drawing.SystemIcons.Information,
                BalloonTipTitle = "Task Reminder",
                BalloonTipText = $"{task.Task}\n{message}",
                BalloonTipIcon = System.Windows.Forms.ToolTipIcon.Info
            };
            
            notification.ShowBalloonTip(5000);
            System.Threading.ThreadPool.QueueUserWorkItem(delegate {
                System.Threading.Thread.Sleep(5000);
                notification.Dispose();
            });
        }
        
        private async Task HandleTaskReminderResult(ItemGrid task, TaskReminderResult result)
        {
            DateTime now = DateTime.Now;

            switch (result)
            {
                case TaskReminderResult.Completed:
                    task.IsActive = false;
                    task.CompletionTime = now;
                    task.CompletionStatus = "Completed";
                    task.LastModifiedDate = now;
                    task.LastProgressDate = now;
                    task.LastInteractionDate = now;
                    task.InactiveWarningCount = 0;
                    task.ReminderSnoozeUntil = null;
                    TrackTaskInteraction(task, "progress");
                    PersistKnowledgeArtifact(task);
                    break;
                    
                case TaskReminderResult.Updated:
                    task.LastModifiedDate = now;
                    task.LastProgressDate = now;
                    task.LastInteractionDate = now;
                    task.InactiveWarningCount = 0; // Reset warning count
                    task.ReminderSnoozeUntil = null;
                    TrackTaskInteraction(task, "progress");
                    break;
                    
                case TaskReminderResult.Decompose:
                    await HandleTaskDecomposition(task);
                    break;
                    
                case TaskReminderResult.Snoozed:
                    task.LastInteractionDate = now;
                    task.ReminderSnoozeUntil = now.AddHours(8);
                    TrackTaskInteraction(task, "snooze");
                    break;
                    
                case TaskReminderResult.Dismissed:
                default:
                    task.LastInteractionDate = now;
                    TrackTaskInteraction(task, "dismiss");
                    break;
            }

            ResolveReminderSkillFeedback(task, result);
            RecordReminderResultProfile(task, result);
            
            // Save changes to CSV
            UpdateTaskInAllGrids(task);
        }
        
        private async Task HandleTaskDecomposition(ItemGrid task)
        {
            try
            {
                // Show decomposition UI first, then load decomposition results asynchronously inside.
                var quadrantSelector = new SmartQuadrantSelectorWindow(task.Task, _llmService, loadFromParentTask: true)
                {
                    Owner = this
                };

                if (quadrantSelector.ShowDialog() == true)
                {
                    await AddSubTasksToQuadrants(quadrantSelector.TaskQuadrantAssignments, task);

                    // Mark original task as decomposed
                    task.IsActive = false;
                    task.CompletionStatus = "Decomposed";
                    task.LastModifiedDate = DateTime.Now;
                    task.LastProgressDate = DateTime.Now;
                    task.LastInteractionDate = DateTime.Now;
                    task.InactiveWarningCount = 0;
                    task.ReminderSnoozeUntil = null;
                    TrackTaskInteraction(task, "progress");

                    MessageBox.Show(this, I18n.Tf("Message_DecomposeSuccessFormat", quadrantSelector.LoadedSubTaskCount),
                                  I18n.T("Title_DecomposeDone"), MessageBoxButton.OK, MessageBoxImage.Information);
                }
                else
                {
                    if (!quadrantSelector.LoadSucceeded && !string.IsNullOrWhiteSpace(quadrantSelector.LoadErrorMessage))
                    {
                        MessageBox.Show(this, quadrantSelector.LoadErrorMessage, I18n.T("Title_DecomposeResult"), MessageBoxButton.OK, MessageBoxImage.Warning);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error handling task decomposition: {ex.Message}");
                string friendlyError = GetFriendlyErrorMessage(ex.Message);
                MessageBox.Show(this, friendlyError, I18n.T("Title_DecomposeError"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        
        private Task AddSubTasksToQuadrants(Dictionary<string, int> taskQuadrantAssignments, ItemGrid originalTask)
        {
            DataGrid[] dataGrids = { task1, task2, task3, task4 };
            string[] csvNumbers = { "1", "2", "3", "4" };
            
            foreach (var assignment in taskQuadrantAssignments)
            {
                string taskDescription = assignment.Key;
                int quadrantIndex = assignment.Value;
                
                if (quadrantIndex >= 0 && quadrantIndex < dataGrids.Length)
                {
                    var targetGrid = dataGrids[quadrantIndex];
                    var currentGridItems = targetGrid.ItemsSource as List<ItemGrid> ?? new List<ItemGrid>();
                    
                    var newTask = new ItemGrid
                    {
                        Task = taskDescription,
                        Importance = GetImportanceFromQuadrant(quadrantIndex),
                        Urgency = GetUrgencyFromQuadrant(quadrantIndex),
                        IsActive = true,
                        CreatedDate = DateTime.Now,
                        LastModifiedDate = DateTime.Now,
                        LastProgressDate = DateTime.Now,
                        LastInteractionDate = DateTime.Now,
                        LongTermGoalId = originalTask.LongTermGoalId, // Inherit from parent
                        IsActiveInQuadrant = true,
                        InactiveWarningCount = 0
                    };
                    
                    currentGridItems.Add(newTask);
                    TrackTaskInteraction(newTask, "progress");
                    RecordTaskProgressProfile(newTask, "decompose_create");
                    targetGrid.ItemsSource = null;
                    targetGrid.ItemsSource = currentGridItems;
                    RefreshDataGrid(targetGrid);
                    update_csv(targetGrid, csvNumbers[quadrantIndex]);
                }
            }
            return Task.CompletedTask;
        }
        
        private string GetImportanceFromQuadrant(int quadrantIndex)
        {
            return quadrantIndex switch
            {
                0 => "High", // 重要且紧急
                1 => "High", // 重要不紧急
                2 => "Low",  // 不重要但紧急
                3 => "Low",  // 不重要不紧急
                _ => "Medium"
            };
        }
        
        private string GetUrgencyFromQuadrant(int quadrantIndex)
        {
            return quadrantIndex switch
            {
                0 => "High", // 重要且紧急
                1 => "Low",  // 重要不紧急
                2 => "High", // 不重要但紧急
                3 => "Low",  // 不重要不紧急
                _ => "Medium"
            };
        }
        
        private void UpdateTaskInAllGrids(ItemGrid task)
        {
            DataGrid[] dataGrids = { task1, task2, task3, task4 };
            string[] csvNumbers = { "1", "2", "3", "4" };
            
            for (int i = 0; i < dataGrids.Length; i++)
            {
                if (dataGrids[i].ItemsSource is List<ItemGrid> items && items.Contains(task))
                {
                    RefreshDataGrid(dataGrids[i]);
                    update_csv(dataGrids[i], csvNumbers[i]);
                    break;
                }
            }
        }
        
        private System.Windows.Threading.DispatcherTimer _taskReminderTimer;

        private class TaskInteractionState
        {
            public DateTime WindowStart { get; set; } = DateTime.Now;
            public DateTime LastInteractionAt { get; set; } = DateTime.Now;
            public int EditCount { get; set; } = 0;
            public int ReorderCount { get; set; } = 0;
            public int MoveCount { get; set; } = 0;
            public int SnoozeCount { get; set; } = 0;
            public int DismissCount { get; set; } = 0;
            public DateTime? LastNudgedAt { get; set; } = null;
            public string LastSuggestedActionId { get; set; } = null;
            public string PendingSuggestedActionId { get; set; } = null;
            public DateTime? PendingSuggestedAt { get; set; } = null;
        }
        
        private void StartPeriodicTaskReminderChecks()
        {
            _taskReminderTimer = new System.Windows.Threading.DispatcherTimer();
            _taskReminderTimer.Interval = TimeSpan.FromMinutes(5); // Check every 5 minutes
            _taskReminderTimer.Tick += TaskReminderTimer_Tick;
            _taskReminderTimer.Start();
        }
        
        private async void TaskReminderTimer_Tick(object sender, EventArgs e)
        {
            UpdateAdaptiveNudgeParameters();
            await CheckForStaleTasksAndRemind();
            CheckForPotentialStuckTasks();
        }

        private void UpdateAdaptiveNudgeParameters(bool force = false)
        {
            DateTime now = DateTime.Now;
            if (!force && (now - _lastAdaptiveTuneAt) < TimeSpan.FromHours(6))
            {
                return;
            }

            try
            {
                var recommendation = ShouldRecordBehavior() ? _userProfileManager.GetAdaptiveNudgeRecommendation(7) : null;
                if (recommendation == null)
                {
                    _adaptiveStuckNoProgressThreshold = DefaultStuckNoProgressThreshold;
                    _adaptiveDailyStuckNudgeLimit = DefaultDailyStuckNudgeLimit;
                    _lastAdaptiveTuneAt = now;
                    return;
                }

                double confidence = Math.Max(0.0, Math.Min(1.0, recommendation.RecommendationConfidence));
                int blendedThresholdMinutes = (int)Math.Round(DefaultStuckNoProgressThreshold.TotalMinutes +
                    (recommendation.RecommendedStuckThresholdMinutes - DefaultStuckNoProgressThreshold.TotalMinutes) * confidence);
                int blendedDailyLimit = (int)Math.Round(DefaultDailyStuckNudgeLimit +
                    (recommendation.RecommendedDailyNudgeLimit - DefaultDailyStuckNudgeLimit) * confidence);

                _adaptiveStuckNoProgressThreshold = ClampThreshold(TimeSpan.FromMinutes(blendedThresholdMinutes));
                _adaptiveDailyStuckNudgeLimit = Math.Max(MinDailyStuckNudgeLimit, Math.Min(MaxDailyStuckNudgeLimit, blendedDailyLimit));
                _lastAdaptiveTuneAt = now;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Adaptive tuning failed: {ex.Message}");
            }
        }

        private List<string> MergeSkillSuggestions(List<string> baseSuggestions, List<LlmSkillRecommendation> skills)
        {
            return MergeSkillSuggestions(baseSuggestions, skills, null);
        }

        private List<string> MergeSkillSuggestions(List<string> baseSuggestions, List<LlmSkillRecommendation> skills, List<string> shownSkillIds)
        {
            var result = baseSuggestions ?? new List<string>();
            if (skills == null || skills.Count == 0)
            {
                return result;
            }

            Dictionary<string, ActionPerformance> perfByAction = null;
            if (ShouldRecordBehavior() && _userProfileManager != null)
            {
                perfByAction = _userProfileManager
                    .GetActionPerformance(30)
                    .ToDictionary(x => x.ActionId, StringComparer.OrdinalIgnoreCase);
            }

            foreach (var skill in skills)
            {
                if (skill == null) continue;
                string hint = BuildSkillHintLabel(skill, perfByAction);
                string text = string.IsNullOrWhiteSpace(hint)
                    ? $"Skill[{skill.Title}]: {skill.NextStep}"
                    : $"Skill[{skill.Title}]: {skill.NextStep}（{hint}）";
                if (!result.Any(s => string.Equals(s, text, StringComparison.OrdinalIgnoreCase)))
                {
                    result.Insert(0, text);
                }
                if (shownSkillIds != null && !string.IsNullOrWhiteSpace(skill.SkillId))
                {
                    string id = skill.SkillId.Trim().ToLowerInvariant();
                    if (!shownSkillIds.Contains(id))
                    {
                        shownSkillIds.Add(id);
                        RecordSuggestionShownProfile(id);
                    }
                }
            }
            return result.Take(5).ToList();
        }

        private static string BuildSkillHintLabel(LlmSkillRecommendation skill, Dictionary<string, ActionPerformance> perfByAction)
        {
            if (skill == null)
            {
                return string.Empty;
            }

            string matchLevel = GetMatchLevel(skill.Confidence);
            string benefitLevel = GetBenefitLevel(skill.SkillId, skill.Confidence, perfByAction);
            if (string.IsNullOrWhiteSpace(matchLevel) || string.IsNullOrWhiteSpace(benefitLevel))
            {
                return string.Empty;
            }

            return $"匹配度:{matchLevel}，预计收益:{benefitLevel}";
        }

        private static string GetMatchLevel(double confidence)
        {
            if (confidence >= 0.70)
            {
                return "高";
            }
            if (confidence >= 0.45)
            {
                return "中";
            }
            return "低";
        }

        private static string GetBenefitLevel(string skillId, double fallbackConfidence, Dictionary<string, ActionPerformance> perfByAction)
        {
            if (string.IsNullOrWhiteSpace(skillId))
            {
                return GetMatchLevel(fallbackConfidence);
            }

            if (perfByAction == null || !perfByAction.TryGetValue(skillId, out var perf) || perf == null)
            {
                return GetMatchLevel(fallbackConfidence);
            }

            int shown = Math.Max(0, perf.Shown);
            int accepted = Math.Max(0, perf.Accepted);
            int deferred = Math.Max(0, perf.Deferred);
            if (shown < 3)
            {
                return GetMatchLevel(fallbackConfidence);
            }

            double expectedReward = (accepted + deferred * 0.35 + 1.0) / (shown + 2.0);
            if (expectedReward >= 0.60)
            {
                return "高";
            }
            if (expectedReward >= 0.40)
            {
                return "中";
            }
            return "低";
        }

        private void RememberPendingReminderSkills(ItemGrid task, List<string> shownSkillIds)
        {
            if (task == null) return;
            string key = GetTaskTrackingKey(task);
            if (shownSkillIds == null || shownSkillIds.Count == 0)
            {
                _pendingReminderSkillIds.Remove(key);
                return;
            }
            _pendingReminderSkillIds[key] = shownSkillIds;
        }

        private void ResolveReminderSkillFeedback(ItemGrid task, TaskReminderResult result)
        {
            if (task == null) return;
            string key = GetTaskTrackingKey(task);
            if (!_pendingReminderSkillIds.TryGetValue(key, out var ids) || ids == null || ids.Count == 0)
            {
                return;
            }

            string feedbackType = null;
            string targetSkillId = ids[0];

            switch (result)
            {
                case TaskReminderResult.Decompose:
                    feedbackType = "accepted";
                    targetSkillId = ids.FirstOrDefault(id => string.Equals(id, "decompose", StringComparison.OrdinalIgnoreCase)) ?? targetSkillId;
                    break;
                case TaskReminderResult.Completed:
                case TaskReminderResult.Updated:
                    feedbackType = "accepted";
                    break;
                case TaskReminderResult.Snoozed:
                    feedbackType = "deferred";
                    break;
                case TaskReminderResult.Dismissed:
                default:
                    feedbackType = "rejected";
                    break;
            }

            if (!string.IsNullOrWhiteSpace(feedbackType) && !string.IsNullOrWhiteSpace(targetSkillId))
            {
                RecordSuggestionFeedbackProfile(targetSkillId, feedbackType);
            }

            _pendingReminderSkillIds.Remove(key);
        }

        private static TimeSpan ClampThreshold(TimeSpan threshold)
        {
            if (threshold < MinStuckNoProgressThreshold)
            {
                return MinStuckNoProgressThreshold;
            }

            if (threshold > MaxStuckNoProgressThreshold)
            {
                return MaxStuckNoProgressThreshold;
            }

            return threshold;
        }

        private void CheckForPotentialStuckTasks()
        {
            DateTime now = DateTime.Now;
            if (!_stuckNudgesEnabled || !CanRunProactiveAssist(now))
            {
                return;
            }
            if (_stuckNudgeCounterDate != now.Date)
            {
                _stuckNudgeCounterDate = now.Date;
                _stuckNudgesShownToday = 0;
            }

            if (_stuckNudgesShownToday >= _adaptiveDailyStuckNudgeLimit || (now - _lastStuckNudgeAt) < StuckNudgeCooldown)
            {
                return;
            }

            DataGrid[] dataGrids = { task1, task2, task3, task4 };
            ItemGrid candidate = null;
            TaskInteractionState candidateState = null;
            TimeSpan candidateNoProgress = TimeSpan.Zero;

            foreach (var dataGrid in dataGrids)
            {
                if (!(dataGrid.ItemsSource is List<ItemGrid> tasks))
                {
                    continue;
                }

                foreach (var task in tasks.Where(t => t.IsActive && t.IsActiveInQuadrant))
                {
                    var key = GetTaskTrackingKey(task);
                    if (!_taskInteractionStates.TryGetValue(key, out var state))
                    {
                        continue;
                    }

                    ResetInteractionWindowIfNeeded(state, now);
                    TimeSpan noProgressDuration = now - task.LastProgressDate;

                    bool hasHighFriction = state.EditCount + state.ReorderCount + state.MoveCount >= 3;
                    bool hasAvoidancePattern = state.SnoozeCount + state.DismissCount >= 2;
                    bool nudgeCoolingDown = state.LastNudgedAt.HasValue && (now - state.LastNudgedAt.Value) < StuckNudgeCooldown;

                    if (nudgeCoolingDown)
                    {
                        continue;
                    }

                    if (noProgressDuration >= _adaptiveStuckNoProgressThreshold && (hasHighFriction || hasAvoidancePattern))
                    {
                        if (candidate == null || noProgressDuration > candidateNoProgress)
                        {
                            candidate = task;
                            candidateState = state;
                            candidateNoProgress = noProgressDuration;
                        }
                    }
                }
            }

            if (candidate == null || candidateState == null)
            {
                return;
            }

            ShowPassiveStuckSuggestion(candidate, candidateNoProgress, candidateState);
            candidateState.LastNudgedAt = now;
            _stuckNudgesShownToday++;
            _lastStuckNudgeAt = now;
        }

        private void ShowPassiveStuckSuggestion(ItemGrid task, TimeSpan noProgressDuration, TaskInteractionState state)
        {
            var suggestion = BuildStuckNextStep(task, noProgressDuration, state);
            string nextStep = suggestion.Text;
            state.LastSuggestedActionId = suggestion.Id;
            state.PendingSuggestedActionId = suggestion.Id;
            state.PendingSuggestedAt = DateTime.Now;
            RecordSuggestionShownProfile(suggestion.Id);

            var notification = new System.Windows.Forms.NotifyIcon
            {
                Visible = true,
                Icon = System.Drawing.SystemIcons.Information,
                BalloonTipTitle = "TimeTask - 轻提醒",
                BalloonTipText = $"{task.Task}\n{nextStep}",
                BalloonTipIcon = System.Windows.Forms.ToolTipIcon.Info
            };

            notification.ShowBalloonTip(5000);
            System.Threading.ThreadPool.QueueUserWorkItem(delegate {
                System.Threading.Thread.Sleep(5000);
                notification.Dispose();
            });
        }

        private UserProfileManager.StuckActionSuggestion BuildStuckNextStep(ItemGrid task, TimeSpan noProgressDuration, TaskInteractionState state)
        {
            var suggestions = ShouldRecordBehavior() ? _userProfileManager.GetRankedStuckSuggestions(task, noProgressDuration, state?.LastSuggestedActionId) : null;
            if (suggestions != null && suggestions.Count > 0)
            {
                return suggestions[0];
            }

            int hours = Math.Max(1, (int)Math.Round(noProgressDuration.TotalHours));
            return new UserProfileManager.StuckActionSuggestion
            {
                Id = "fallback_min_step",
                Text = $"已卡住约 {hours} 小时，先做一个最小下一步动作。",
                Score = 0
            };
        }

        private void TrackTaskInteraction(ItemGrid task, string interactionType)
        {
            if (task == null || string.IsNullOrWhiteSpace(interactionType))
            {
                return;
            }

            DateTime now = DateTime.Now;
            string key = GetTaskTrackingKey(task);
            if (!_taskInteractionStates.TryGetValue(key, out var state))
            {
                state = new TaskInteractionState
                {
                    WindowStart = now,
                    LastInteractionAt = now
                };
                _taskInteractionStates[key] = state;
            }

            ResetInteractionWindowIfNeeded(state, now);
            state.LastInteractionAt = now;

            switch (interactionType)
            {
                case "edit":
                    state.EditCount++;
                    break;
                case "reorder":
                    state.ReorderCount++;
                    break;
                case "move":
                    state.MoveCount++;
                    break;
                case "snooze":
                    state.SnoozeCount++;
                    TryResolvePendingSuggestionFeedback(state, now, "deferred");
                    break;
                case "dismiss":
                    state.DismissCount++;
                    TryResolvePendingSuggestionFeedback(state, now, "rejected");
                    break;
                case "progress":
                    TryResolvePendingSuggestionFeedback(state, now, "accepted");
                    state.EditCount = 0;
                    state.ReorderCount = 0;
                    state.MoveCount = 0;
                    state.SnoozeCount = 0;
                    state.DismissCount = 0;
                    state.WindowStart = now;
                    break;
            }

            _behaviorObserver?.RecordTaskOperation(interactionType, task.Task, GetTaskTrackingKey(task));
        }

        private void PersistKnowledgeArtifact(ItemGrid task)
        {
            try
            {
                _knowledgeArtifactService?.CaptureCompletion(task);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"PersistKnowledgeArtifact failed: {ex.Message}");
            }
        }

        private void TryResolvePendingSuggestionFeedback(TaskInteractionState state, DateTime now, string feedbackType)
        {
            if (state == null || string.IsNullOrWhiteSpace(state.PendingSuggestedActionId) || !state.PendingSuggestedAt.HasValue)
            {
                return;
            }

            if ((now - state.PendingSuggestedAt.Value) > TimeSpan.FromMinutes(30))
            {
                state.PendingSuggestedActionId = null;
                state.PendingSuggestedAt = null;
                return;
            }

            RecordSuggestionFeedbackProfile(state.PendingSuggestedActionId, feedbackType);
            state.PendingSuggestedActionId = null;
            state.PendingSuggestedAt = null;
        }

        private static void ResetInteractionWindowIfNeeded(TaskInteractionState state, DateTime now)
        {
            if ((now - state.WindowStart) <= TimeSpan.FromHours(2))
            {
                return;
            }

            state.WindowStart = now;
            state.EditCount = 0;
            state.ReorderCount = 0;
            state.MoveCount = 0;
            state.SnoozeCount = 0;
            state.DismissCount = 0;
        }

        private static string GetTaskTrackingKey(ItemGrid task)
        {
            string id = string.IsNullOrWhiteSpace(task.SourceTaskID) ? string.Empty : task.SourceTaskID.Trim();
            if (!string.IsNullOrWhiteSpace(id))
            {
                return $"sid:{id}";
            }

            return $"{task.CreatedDate:o}|{task.Task}";
        }
        
        private Task CheckForStaleTasksAndRemind()
        {
            DateTime now = DateTime.Now;
            if (!CanRunProactiveAssist(now))
            {
                return Task.CompletedTask;
            }

            if (_reminderCounterDate != now.Date)
            {
                _reminderCounterDate = now.Date;
                _remindersShownToday = 0;
            }

            if (_remindersShownToday >= DailyReminderLimit)
            {
                return Task.CompletedTask;
            }

            DataGrid[] dataGrids = { task1, task2, task3, task4 };
            ItemGrid candidate = null;
            TimeSpan candidateInactive = TimeSpan.Zero;
            double candidateScore = double.MinValue;
            
            foreach (var dataGrid in dataGrids)
            {
                if (dataGrid.ItemsSource is List<ItemGrid> tasks)
                {
                    foreach (var task in tasks.Where(t => t.IsActive && t.IsActiveInQuadrant))
                    {
                        TimeSpan inactiveDuration = now - task.LastProgressDate;
                        
                        if (ShouldShowReminder(task, inactiveDuration, now))
                        {
                            double score = GetReminderPriorityScore(task, inactiveDuration);
                            if (candidate == null || score > candidateScore)
                            {
                                candidate = task;
                                candidateInactive = inactiveDuration;
                                candidateScore = score;
                            }
                        }
                    }
                }
            }

            if (candidate != null)
            {
                ShowFriendlyReminder(candidate, GetReminderMessage(candidate, candidateInactive));
                candidate.InactiveWarningCount++;
                candidate.LastInteractionDate = now;
                candidate.LastReminderDate = now;
                _remindersShownToday++;
                RecordReminderShownProfile(candidate);
                UpdateTaskInAllGrids(candidate);
            }
            return Task.CompletedTask;
        }
        
        private bool ShouldShowReminder(ItemGrid task, TimeSpan inactiveDuration, DateTime now)
        {
            if (task.ReminderSnoozeUntil.HasValue && task.ReminderSnoozeUntil.Value > now)
                return false;

            if (task.LastReminderDate.HasValue && (now - task.LastReminderDate.Value) < ReminderCooldown)
                return false;

            // First warning after configured days
            if (inactiveDuration > FirstWarningAfter && task.InactiveWarningCount == 0)
                return true;
                
            // Second warning after configured days
            if (inactiveDuration > SecondWarningAfter && task.InactiveWarningCount == 1)
                return true;
                
            // Subsequent warnings for very stale tasks
            if (inactiveDuration > StaleTaskThreshold && task.InactiveWarningCount >= 2 && task.InactiveWarningCount < MaxInactiveWarnings)
            {
                // Show reminder every few days for very stale tasks
                var daysSinceLastWarning = task.LastReminderDate.HasValue
                    ? (now - task.LastReminderDate.Value).TotalDays
                    : (now - task.LastInteractionDate).TotalDays;
                return daysSinceLastWarning >= 3; // Remind every 3 days for very stale tasks
            }
            
            return false;
        }

        private static double GetReminderPriorityScore(ItemGrid task, TimeSpan inactiveDuration)
        {
            double score = inactiveDuration.TotalHours;
            bool highImportance = string.Equals(task.Importance, "High", StringComparison.OrdinalIgnoreCase);
            bool highUrgency = string.Equals(task.Urgency, "High", StringComparison.OrdinalIgnoreCase);

            if (highImportance && highUrgency) score += 24;
            else if (highImportance && !highUrgency) score += 16;
            else if (!highImportance && highUrgency) score += 10;
            else score += 4;

            if (task.InactiveWarningCount == 0) score += 2;
            if (task.InactiveWarningCount >= 2) score += 1;

            return score;
        }
        
        private string GetReminderMessage(ItemGrid task, TimeSpan inactiveDuration)
        {
            if (inactiveDuration <= FirstWarningAfter)
                return "这个任务有一段时间没有更新了，需要关注一下吗？";
            else if (inactiveDuration <= SecondWarningAfter)
                return "这个任务变得有些陈旧了，请考虑尽快更新或完成它。";
            else
                return "这个任务已经很久没有进展了，建议重新评估其优先级或进行分解。";
        }

        private void InitializeSyncService()
        {
            try
            {
                string connectionString = null;
                try
                {
                    connectionString = (string)Properties.Settings.Default["TeamTasksDbConnectionString"];
                }
                catch (System.Configuration.SettingsPropertyNotFoundException ex)
                {
                    Console.WriteLine($"INFO: Settings property 'TeamTasksDbConnectionString' not found during initial load. This is expected if settings haven't been saved yet. Defaulting to empty. Error: {ex.Message}");
                    connectionString = string.Empty;
                }
                catch (Exception ex) // Catch other potential issues during access
                {
                    Console.WriteLine($"ERROR: Error accessing setting 'TeamTasksDbConnectionString'. Defaulting to empty. Error: {ex.Message}");
                    connectionString = string.Empty;
                }

                bool enableSync = false;
                try
                {
                    enableSync = (bool)Properties.Settings.Default["EnableTeamSync"];
                }
                catch (System.Configuration.SettingsPropertyNotFoundException ex)
                {
                    Console.WriteLine($"INFO: Settings property 'EnableTeamSync' not found. Defaulting to false. Error: {ex.Message}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"ERROR: Error accessing setting 'EnableTeamSync'. Defaulting to false. Error: {ex.Message}");
                }

                if (enableSync)
                {
                    if (!string.IsNullOrWhiteSpace(connectionString))
                    {
                        _databaseService = new DatabaseService(connectionString);
                        Console.WriteLine("DatabaseService initialized with connection string.");

                        if (_syncTimer == null)
                        {
                            _syncTimer = new System.Windows.Threading.DispatcherTimer();
                            _syncTimer.Tick += SyncTimer_Tick;
                        }

                        int syncInterval = 30; // Default interval
                        try
                        {
                            syncInterval = (int)Properties.Settings.Default["SyncIntervalMinutes"];
                            if (syncInterval <= 0) syncInterval = 30; // Ensure positive interval
                        }
                        catch (System.Configuration.SettingsPropertyNotFoundException ex)
                        {
                            Console.WriteLine($"INFO: Settings property 'SyncIntervalMinutes' not found. Defaulting to 30. Error: {ex.Message}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"ERROR: Error accessing setting 'SyncIntervalMinutes'. Defaulting to 30. Error: {ex.Message}");
                        }
                        _syncTimer.Interval = TimeSpan.FromMinutes(syncInterval);
                        _syncTimer.Start();
                        Console.WriteLine($"Sync timer started. Interval: {syncInterval} minutes.");

                        // Perform an initial sync immediately if enabled
                        Task.Run(() => SyncTimer_Tick(this, EventArgs.Empty));
                    }
                    else
                    {
                        Console.WriteLine("Team Sync is enabled but connection string is missing. Sync service not started.");
                        if (!_isFirstSyncAttempted)
                        {
                             // MessageBox.Show(this, "Team Task Synchronization is enabled, but the database connection string is not configured. Please configure it in Settings.", "Sync Configuration Needed", MessageBoxButton.OK, MessageBoxImage.Warning);
                            _isFirstSyncAttempted = true; // Show message only once per app load initially
                        }
                    }
                }
                else
                {
                    Console.WriteLine("Team Sync is disabled. Sync service not started.");
                    if (_syncTimer != null)
                    {
                        _syncTimer.Stop();
                        Console.WriteLine("Sync timer stopped.");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error initializing sync service: {ex.Message}");
                MessageBox.Show(this, $"Error initializing synchronization service: {ex.Message}", "Sync Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void InitializeKnowledgeSyncService()
        {
            try
            {
                _knowledgeSyncService = KnowledgeSyncService.CreateFromAppSettings(currentPath);
                if (_knowledgeSyncService == null || !_knowledgeSyncService.IsEnabled)
                {
                    Console.WriteLine("Knowledge sync is disabled.");
                    return;
                }

                if (!_knowledgeSyncService.IsConnectorReady)
                {
                    Console.WriteLine("Knowledge sync is enabled but Obsidian vault path is invalid or not discovered.");
                    return;
                }

                if (_knowledgeSyncTimer == null)
                {
                    _knowledgeSyncTimer = new System.Windows.Threading.DispatcherTimer();
                    _knowledgeSyncTimer.Tick += async (s, e) => await RunKnowledgeSyncAsync(false);
                }

                _knowledgeSyncTimer.Interval = TimeSpan.FromMinutes(_knowledgeSyncService.Options.SyncIntervalMinutes);
                _knowledgeSyncTimer.Start();
                Console.WriteLine($"Knowledge sync timer started. Interval: {_knowledgeSyncService.Options.SyncIntervalMinutes} minutes.");
                if (_knowledgeSyncService.Options.ObsidianVaultAutoDiscovered &&
                    _knowledgeSyncService.Options.SmartNotifyEnabled &&
                    _nonBlockingInteractionEnabled)
                {
                    ShowPassiveNotification("已自动连接 Obsidian", _knowledgeSyncService.Options.ObsidianVaultPath, System.Windows.Forms.ToolTipIcon.Info, 4000);
                }

                if (_knowledgeSyncDebounceTimer == null)
                {
                    _knowledgeSyncDebounceTimer = new System.Windows.Threading.DispatcherTimer();
                    _knowledgeSyncDebounceTimer.Tick += async (s, e) =>
                    {
                        _knowledgeSyncDebounceTimer.Stop();
                        await RunKnowledgeSyncAsync(false);
                    };
                }
                _knowledgeSyncDebounceTimer.Interval = TimeSpan.FromSeconds(_knowledgeSyncService.Options.SyncDebounceSeconds);

                SetupObsidianRealtimeWatcher();
                Dispatcher.BeginInvoke(new Action(async () => await RunKnowledgeSyncAsync(false)));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"InitializeKnowledgeSyncService failed: {ex.Message}");
            }
        }

        private void SetupObsidianRealtimeWatcher()
        {
            try
            {
                if (_knowledgeSyncService == null || !_knowledgeSyncService.Options.RealtimeWatchEnabled)
                {
                    return;
                }

                string vaultPath = _knowledgeSyncService.Options.ObsidianVaultPath;
                if (string.IsNullOrWhiteSpace(vaultPath) || !Directory.Exists(vaultPath))
                {
                    return;
                }

                if (_obsidianWatcher != null)
                {
                    _obsidianWatcher.EnableRaisingEvents = false;
                    _obsidianWatcher.Dispose();
                    _obsidianWatcher = null;
                }

                _obsidianWatcher = new FileSystemWatcher(vaultPath, "*.md");
                _obsidianWatcher.IncludeSubdirectories = _knowledgeSyncService.Options.ObsidianIncludeSubfolders;
                _obsidianWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size | NotifyFilters.CreationTime;
                _obsidianWatcher.Changed += ObsidianWatcher_OnChanged;
                _obsidianWatcher.Created += ObsidianWatcher_OnChanged;
                _obsidianWatcher.Renamed += ObsidianWatcher_OnChanged;
                _obsidianWatcher.Deleted += ObsidianWatcher_OnChanged;
                _obsidianWatcher.EnableRaisingEvents = true;
                Console.WriteLine("Obsidian realtime watcher started.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"SetupObsidianRealtimeWatcher failed: {ex.Message}");
            }
        }

        private void ObsidianWatcher_OnChanged(object sender, FileSystemEventArgs e)
        {
            try
            {
                if (_knowledgeSyncDebounceTimer == null)
                {
                    return;
                }

                Dispatcher.BeginInvoke(new Action(() =>
                {
                    _knowledgeSyncDebounceTimer.Stop();
                    _knowledgeSyncDebounceTimer.Start();
                }));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"ObsidianWatcher_OnChanged failed: {ex.Message}");
            }
        }

        private async Task RunKnowledgeSyncAsync(bool showSummary)
        {
            if (!Dispatcher.CheckAccess())
            {
                Dispatcher.BeginInvoke(new Action(async () => await RunKnowledgeSyncAsync(showSummary)));
                return;
            }

            if (_knowledgeSyncService == null)
            {
                if (showSummary)
                {
                    MessageBox.Show(I18n.T("KnowledgeSync_NotInitialized"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Information);
                }
                return;
            }

            if (_knowledgeSyncRunning)
            {
                return;
            }

            _knowledgeSyncRunning = true;
            try
            {
                TaskDraftManager draftManager = _draftBadgeManager;
                bool ownsDraftManager = false;
                if (draftManager == null)
                {
                    draftManager = new TaskDraftManager();
                    ownsDraftManager = true;
                }

                KnowledgeSyncResult result = await Task.Run(() => _knowledgeSyncService.RunOnce(draftManager));
                result.AutoImported = AutoImportHighConfidenceDrafts(result, draftManager);
                if (ownsDraftManager)
                {
                    draftManager.Dispose();
                }

                if (showSummary)
                {
                    string summary = result.BuildSummaryText();
                    if (result.Errors.Count > 0)
                    {
                        summary += Environment.NewLine + string.Join(Environment.NewLine, result.Errors.Take(3));
                    }
                    MessageBox.Show(summary, I18n.T("KnowledgeSync_ResultTitle"), MessageBoxButton.OK, MessageBoxImage.Information);
                }
                else if (_knowledgeSyncService.Options.SmartNotifyEnabled &&
                    result.AutoImported > 0 &&
                    _nonBlockingInteractionEnabled &&
                    CanRunProactiveAssist(DateTime.Now))
                {
                    ShowPassiveNotification(
                        I18n.T("KnowledgeSync_PassiveTitle"),
                        I18n.Tf("KnowledgeSync_PassiveMessageFormat", result.AutoImported, Math.Max(0, result.DraftsAdded - result.AutoImported)),
                        System.Windows.Forms.ToolTipIcon.Info);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Knowledge sync run failed: {ex.Message}");
                if (showSummary)
                {
                    MessageBox.Show(I18n.Tf("KnowledgeSync_FailedFormat", ex.Message), I18n.T("Title_Error"), MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
            finally
            {
                _knowledgeSyncRunning = false;
            }
        }

        private int AutoImportHighConfidenceDrafts(KnowledgeSyncResult result, TaskDraftManager draftManager)
        {
            if (_knowledgeSyncService == null ||
                !_knowledgeSyncService.Options.AutoImportEnabled ||
                result == null ||
                draftManager == null ||
                result.NewDrafts == null ||
                result.NewDrafts.Count == 0)
            {
                return 0;
            }

            int imported = 0;
            var minConfidence = _knowledgeSyncService.Options.AutoImportMinConfidence;
            var maxPerRun = _knowledgeSyncService.Options.AutoImportMaxPerRun;

            foreach (var draft in result.NewDrafts
                .Where(d => d != null && !d.IsProcessed)
                .OrderByDescending(d => d.Confidence)
                .ThenByDescending(d => d.ReminderTime.HasValue ? 1 : 0))
            {
                if (imported >= maxPerRun)
                {
                    break;
                }

                if (draft.Confidence < minConfidence)
                {
                    continue;
                }

                if (TaskAlreadyExists(draft))
                {
                    draftManager.MarkAsProcessed(draft.Id);
                    continue;
                }

                var task = CreateTaskFromDraft(draft);
                AddTaskToQuadrant(task, ResolveQuadrantName(draft));
                draftManager.MarkAsProcessed(draft.Id);
                imported++;
            }

            if (imported > 0)
            {
                UpdateDraftBadge();
            }

            return imported;
        }

        private bool TaskAlreadyExists(TaskDraft draft)
        {
            if (draft == null)
            {
                return false;
            }

            string key = string.IsNullOrWhiteSpace(draft.SourceNotePath) ? null : $"obsidian:{draft.SourceNotePath.Replace('\\', '/')}";
            var tasks = GetAllQuadrantTasks();
            return tasks.Any(t =>
                t != null &&
                string.Equals(t.Task, draft.CleanedText, StringComparison.OrdinalIgnoreCase) &&
                (string.IsNullOrWhiteSpace(key) || string.Equals(t.SourceTaskID, key, StringComparison.OrdinalIgnoreCase)));
        }

        private static ItemGrid CreateTaskFromDraft(TaskDraft draft)
        {
            return new ItemGrid
            {
                Task = draft.CleanedText,
                Score = 1,
                Result = string.Empty,
                IsActive = true,
                Importance = string.IsNullOrWhiteSpace(draft.Importance) ? "High" : draft.Importance,
                Urgency = string.IsNullOrWhiteSpace(draft.Urgency) ? "Low" : draft.Urgency,
                CreatedDate = DateTime.Now,
                LastModifiedDate = DateTime.Now,
                LastProgressDate = DateTime.Now,
                LastInteractionDate = DateTime.Now,
                ReminderTime = draft.ReminderTime,
                IsActiveInQuadrant = true,
                InactiveWarningCount = 0,
                SourceTaskID = string.IsNullOrWhiteSpace(draft.SourceNotePath)
                    ? $"draft:{draft.Id}"
                    : $"obsidian:{draft.SourceNotePath.Replace('\\', '/')}"
            };
        }

        private static string ResolveQuadrantName(TaskDraft draft)
        {
            if (draft == null)
            {
                return "重要不紧急";
            }

            string normalized = (draft.EstimatedQuadrant ?? string.Empty).Trim();
            if (string.Equals(normalized, "important_urgent", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(normalized, "重要且紧急", StringComparison.OrdinalIgnoreCase))
            {
                return "重要且紧急";
            }
            if (string.Equals(normalized, "important_not_urgent", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(normalized, "重要不紧急", StringComparison.OrdinalIgnoreCase))
            {
                return "重要不紧急";
            }
            if (string.Equals(normalized, "not_important_urgent", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(normalized, "不重要紧急", StringComparison.OrdinalIgnoreCase))
            {
                return "不重要紧急";
            }
            if (string.Equals(normalized, "not_important_not_urgent", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(normalized, "不重要不紧急", StringComparison.OrdinalIgnoreCase))
            {
                return "不重要不紧急";
            }

            if (string.Equals(draft.Importance, "High", StringComparison.OrdinalIgnoreCase) &&
                string.Equals(draft.Urgency, "High", StringComparison.OrdinalIgnoreCase))
            {
                return "重要且紧急";
            }
            if (string.Equals(draft.Importance, "High", StringComparison.OrdinalIgnoreCase))
            {
                return "重要不紧急";
            }
            if (string.Equals(draft.Urgency, "High", StringComparison.OrdinalIgnoreCase))
            {
                return "不重要紧急";
            }
            return "不重要不紧急";
        }

        private async void SyncTimer_Tick(object sender, EventArgs e)
        {
            bool enableSync = false;
            try
            {
                enableSync = (bool)Properties.Settings.Default["EnableTeamSync"];
            }
            catch (Exception ex) // Simplified catch for brevity in this specific check
            {
                Console.WriteLine($"ERROR: Error accessing 'EnableTeamSync' in SyncTimer_Tick. Defaulting to false. Error: {ex.Message}");
            }

            if (!enableSync || _databaseService == null)
            {
                if (_syncTimer != null) _syncTimer.Stop(); // Stop if disabled or service not available
                Console.WriteLine("SyncTimer_Tick: Sync disabled or DatabaseService not available. Timer stopped.");
                return;
            }

            Console.WriteLine("SyncTimer_Tick: Attempting to sync team tasks...");
            try
            {
                string userRole = string.Empty;
                try
                {
                    userRole = (string)Properties.Settings.Default["TeamRole"];
                }
                catch (Exception ex) // Simplified catch
                {
                     Console.WriteLine($"ERROR: Error accessing 'TeamRole' in SyncTimer_Tick. Defaulting to empty. Error: {ex.Message}");
                }
                List<ItemGrid> newTasks = await Task.Run(() => _databaseService.GetTeamTasks(userRole)); // Run DB call on background thread

                if (newTasks == null)
                {
                    Console.WriteLine("SyncTimer_Tick: GetTeamTasks returned null. Skipping update.");
                    if (!_isFirstSyncAttempted)
                    {
                        // MessageBox.Show(this, "Could not connect to the team task database. Please check settings and network.", "Sync Failed", MessageBoxButton.OK, MessageBoxImage.Warning);
                        _isFirstSyncAttempted = true;
                    }
                    return;
                }
                 _isFirstSyncAttempted = true; // Mark that an attempt was made

                int addedCount = 0;
                var task1List = task1.ItemsSource as List<ItemGrid>;
                if (task1List == null)
                {
                    // This needs to be on UI thread if we assign it back
                    await Dispatcher.InvokeAsync(() => {
                        task1List = new List<ItemGrid>();
                        task1.ItemsSource = task1List;
                    });
                }

                foreach (var dbTask in newTasks)
                {
                    if (!string.IsNullOrWhiteSpace(dbTask.SourceTaskID) && _syncedTaskSourceIDs.Contains(dbTask.SourceTaskID))
                    {
                        continue; // Skip already synced task
                    }

                    // Ensure properties are set for the quadrant
                    dbTask.Importance = "High"; // Default for "Important & Urgent"
                    dbTask.Urgency = "High";   // Default for "Important & Urgent"
                    // Score will be set on refresh/add

                    // Operations on task1List must be on UI thread
                    await Dispatcher.InvokeAsync(() =>
                    {
                        // Double check task1List is not null if it was created within Dispatcher.InvokeAsync
                        if (task1.ItemsSource is List<ItemGrid> currentList) {
                           currentList.Add(dbTask);
                            if (!string.IsNullOrWhiteSpace(dbTask.SourceTaskID))
                            {
                                _syncedTaskSourceIDs.Add(dbTask.SourceTaskID);
                            }
                            addedCount++;
                        } else {
                             // Fallback or error if task1List is unexpectedly null
                            task1List = new List<ItemGrid>();
                            task1.ItemsSource = task1List;
                            task1List.Add(dbTask);
                            if (!string.IsNullOrWhiteSpace(dbTask.SourceTaskID))
                            {
                                _syncedTaskSourceIDs.Add(dbTask.SourceTaskID);
                            }
                            addedCount++;
                            Console.WriteLine("SyncTimer_Tick: task1.ItemsSource was null and re-initialized on UI thread.");
                        }
                    });
                }

                if (addedCount > 0)
                {
                    Console.WriteLine($"SyncTimer_Tick: Added {addedCount} new tasks to 'Important & Urgent'.");
                    await Dispatcher.InvokeAsync(() =>
                    {
                        RefreshDataGrid(task1);
                        update_csv(task1, "1"); // Persist to CSV
                    });
                }
                else
                {
                    Console.WriteLine("SyncTimer_Tick: No new tasks to add.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error during scheduled sync: {ex.Message}");
                // Avoid showing MessageBox repeatedly from timer tick. Log is better.
            }
        }

        private void ReminderTimer_Tick(object sender, EventArgs e)
        {
            DateTime now = DateTime.Now;

            DataGrid[] dataGrids = { task1, task2, task3, task4 };
            string[] csvFiles = { "1.csv", "2.csv", "3.csv", "4.csv" }; // To identify which CSV to update

            for (int i = 0; i < dataGrids.Length; i++)
            {
                DataGrid currentGrid = dataGrids[i];
                bool changesMadeInCurrentGrid = false; // Track changes for the current grid/CSV

                if (currentGrid.ItemsSource is List<ItemGrid> tasks)
                {
                    foreach (ItemGrid task in tasks)
                    {
                        if (task.IsActive && task.ReminderTime.HasValue && task.ReminderTime.Value <= now)
                        {
                            var dueTime = task.ReminderTime.Value;
                            var dueReminderWindow = new TaskReminderWindow(task, dueTime)
                            {
                                Owner = this
                            };
                            dueReminderWindow.ShowDialog();
                            changesMadeInCurrentGrid = HandleDueReminderDecision(task, dueReminderWindow.Result, now) || changesMadeInCurrentGrid;
                        }
                    }

                    if (changesMadeInCurrentGrid)
                    {
                        update_csv(currentGrid, csvFiles[i].Replace(".csv", ""));
                        RefreshDataGrid(currentGrid);
                    }
                }
            }
        }

        public void EditReminderTime_Click(object sender, RoutedEventArgs e)
        {
            if (!(sender is Button btn) || !(btn.DataContext is ItemGrid task))
            {
                return;
            }

            var sourceGrid = FindSourceGridForTask(task);
            if (sourceGrid == null)
            {
                MessageBox.Show(I18n.T("Message_TaskQuadrantNotFound"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            if (TryEditReminderTime(task))
            {
                update_csv(sourceGrid, GetQuadrantNumber(sourceGrid.Name));
                RefreshDataGrid(sourceGrid);
            }
        }

        public async void QuickDecomposeTask_Click(object sender, RoutedEventArgs e)
        {
            if (!(sender is Button btn) || !(btn.DataContext is ItemGrid task))
            {
                return;
            }

            await HandleTaskDecomposition(task);
            var sourceGrid = FindSourceGridForTask(task);
            if (sourceGrid != null)
            {
                update_csv(sourceGrid, GetQuadrantNumber(sourceGrid.Name));
                RefreshDataGrid(sourceGrid);
            }
        }

        public void ToolQuickAction_Click(object sender, RoutedEventArgs e)
        {
            if (!(sender is Button btn) || !(btn.DataContext is ItemGrid task))
            {
                return;
            }

            var sourceGrid = FindSourceGridForTask(task);
            if (sourceGrid == null)
            {
                MessageBox.Show(I18n.T("Message_TaskQuadrantNotFound"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            TimeSpan inactiveDuration = DateTime.Now - task.LastProgressDate;
            var enabled = SkillManagementService.LoadEnabledSkillIds();
            var recommendations = ThinkingToolAdvisor.RecommendForTask(task.Task, task.Importance, task.Urgency, inactiveDuration, 6)
                .Where(r => enabled.Contains(r.SkillId))
                .Take(5)
                .ToList();
            if (recommendations == null || recommendations.Count == 0)
            {
                MessageBox.Show(I18n.T("Message_NoThinkingToolSuggestion"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            var menu = new ContextMenu();
            foreach (var recommendation in recommendations)
            {
                var item = new MenuItem
                {
                    Header = recommendation.Title,
                    ToolTip = $"{recommendation.Why}\n{I18n.T("ThinkingTool_NextStepLabel")} {recommendation.NextStep}"
                };
                item.Click += async (_, __) => await ExecuteThinkingToolForTaskAsync(task, sourceGrid, recommendation);
                menu.Items.Add(item);
            }

            menu.PlacementTarget = btn;
            menu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;
            menu.IsOpen = true;
        }

        private async Task ExecuteThinkingToolForTaskAsync(ItemGrid task, DataGrid sourceGrid, ThinkingToolRecommendation recommendation)
        {
            if (task == null || sourceGrid == null || recommendation == null)
            {
                return;
            }

            string skillId = recommendation.SkillId?.Trim().ToLowerInvariant() ?? string.Empty;
            TimeSpan inactiveDuration = DateTime.Now - task.LastProgressDate;
            var report = ThinkingToolAdvisor.AnalyzeTask(task.Task, task.Importance, task.Urgency, inactiveDuration, skillId);
            var analysisWindow = new ThinkingToolAnalysisWindow(report)
            {
                Owner = this
            };
            bool? confirmed = analysisWindow.ShowDialog();
            if (confirmed != true)
            {
                return;
            }

            var selectedActions = analysisWindow.SelectedActions ?? new List<ThinkingToolActionItem>();
            RecordSuggestionShownProfile(skillId);

            switch (skillId)
            {
                case "decompose":
                    await HandleTaskDecomposition(task);
                    AddThinkingActionTasks(task, sourceGrid, recommendation.Title, selectedActions);
                    RecordSuggestionFeedbackProfile(skillId, "accepted");
                    break;
                case "focus_sprint":
                    string sprintText = selectedActions.FirstOrDefault()?.Text ?? recommendation.NextStep;
                    ShowFriendlyReminder(task, sprintText);
                    AddThinkingActionTasks(task, sourceGrid, recommendation.Title, selectedActions.Skip(1).ToList());
                    RecordSuggestionFeedbackProfile(skillId, "accepted");
                    break;
                default:
                    AddThinkingActionTasks(task, sourceGrid, recommendation.Title, selectedActions);
                    RecordSuggestionFeedbackProfile(skillId, "accepted");
                    break;
            }
        }

        private void AddThinkingActionTasks(ItemGrid parentTask, DataGrid sourceGrid, string toolTitle, List<ThinkingToolActionItem> actions)
        {
            if (!(sourceGrid.ItemsSource is List<ItemGrid> items) || parentTask == null || actions == null || actions.Count == 0)
            {
                return;
            }

            var now = DateTime.Now;
            int created = 0;
            foreach (var action in actions.Where(a => a != null && !string.IsNullOrWhiteSpace(a.Text)))
            {
                string description = $"[{toolTitle}] {action.Text}";
                bool exists = items.Any(t => string.Equals(t.Task, description, StringComparison.OrdinalIgnoreCase) && t.IsActive);
                if (exists)
                {
                    continue;
                }

                var newTask = new ItemGrid
                {
                    Task = description,
                    Importance = parentTask.Importance,
                    Urgency = parentTask.Urgency,
                    IsActive = true,
                    CreatedDate = now,
                    LastModifiedDate = now,
                    LastProgressDate = now,
                    LastInteractionDate = now,
                    LongTermGoalId = parentTask.LongTermGoalId,
                    IsActiveInQuadrant = true,
                    InactiveWarningCount = 0
                };

                items.Add(newTask);
                TrackTaskInteraction(newTask, "progress");
                created++;
            }

            if (created == 0)
            {
                ShowPassiveNotification(I18n.T("ThinkingTool_ActionExistsTitle"), I18n.T("ThinkingTool_ActionExistsText"), System.Windows.Forms.ToolTipIcon.Info);
                return;
            }

            for (int i = 0; i < items.Count; i++)
            {
                items[i].Score = items.Count - i;
            }

            update_csv(sourceGrid, GetQuadrantNumber(sourceGrid.Name));
            RefreshDataGrid(sourceGrid);
            ShowPassiveNotification(I18n.T("ThinkingTool_ActionCreatedTitle"), I18n.Tf("ThinkingTool_ActionCreatedFormat", toolTitle, created), System.Windows.Forms.ToolTipIcon.Info);
        }

        private bool HandleDueReminderDecision(ItemGrid task, TaskReminderResult result, DateTime now)
        {
            if (task == null)
            {
                return false;
            }

            bool changed = false;
            switch (result)
            {
                case TaskReminderResult.ReminderConfirmed:
                    task.ReminderTime = null;
                    task.LastReminderDate = now;
                    changed = true;
                    break;
                case TaskReminderResult.ReminderPostponed:
                    task.ReminderTime = now.AddMinutes(30);
                    task.LastReminderDate = now;
                    changed = true;
                    break;
                case TaskReminderResult.ReminderEditTime:
                    changed = TryEditReminderTime(task);
                    if (!changed)
                    {
                        // 用户取消编辑时给一个小缓冲，避免重复打扰。
                        task.ReminderTime = now.AddMinutes(10);
                        changed = true;
                    }
                    task.LastReminderDate = now;
                    break;
                case TaskReminderResult.Dismissed:
                default:
                    task.ReminderTime = now.AddMinutes(10);
                    changed = true;
                    break;
            }

            if (changed)
            {
                task.LastModifiedDate = now;
                task.LastInteractionDate = now;
                TrackTaskInteraction(task, "edit");
                _behaviorObserver?.RecordTaskOperation("reminder_time_confirm", task.Task, GetTaskTrackingKey(task));
            }

            return changed;
        }

        private bool TryEditReminderTime(ItemGrid task)
        {
            if (task == null)
            {
                return false;
            }

            var editor = new ReminderTimeEditorWindow(task.ReminderTime)
            {
                Owner = this
            };
            bool? dialog = editor.ShowDialog();
            if (dialog != true)
            {
                return false;
            }

            DateTime? selected = editor.SelectedReminderTime;
            if (!_nonBlockingInteractionEnabled)
            {
                string confirmText = selected.HasValue
                    ? I18n.Tf("Reminder_EditConfirmSetFormat", task.Task, selected.Value.ToString("yyyy-MM-dd HH:mm"))
                    : I18n.Tf("Reminder_EditConfirmClearFormat", task.Task);
                if (MessageBox.Show(confirmText, I18n.T("Reminder_EditConfirmTitle"), MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
                {
                    return false;
                }
            }

            task.ReminderTime = selected;
            task.ReminderSnoozeUntil = null;
            task.LastModifiedDate = DateTime.Now;
            task.LastInteractionDate = DateTime.Now;
            TrackTaskInteraction(task, "edit");
            _behaviorObserver?.RecordTaskOperation("update_reminder_time", task.Task, GetTaskTrackingKey(task));
            if (_nonBlockingInteractionEnabled)
            {
                string msg = selected.HasValue
                    ? I18n.Tf("Reminder_EditUpdatedSetFormat", selected.Value.ToString("yyyy-MM-dd HH:mm"))
                    : I18n.T("Reminder_EditUpdatedCleared");
                ShowPassiveNotification(I18n.T("Reminder_EditUpdatedTitle"), msg, System.Windows.Forms.ToolTipIcon.Info);
            }
            return true;
        }

        private static void ShowPassiveNotification(string title, string message, System.Windows.Forms.ToolTipIcon icon = System.Windows.Forms.ToolTipIcon.Info, int durationMs = 5000)
        {
            var notification = new System.Windows.Forms.NotifyIcon
            {
                Visible = true,
                Icon = System.Drawing.SystemIcons.Information,
                BalloonTipTitle = string.IsNullOrWhiteSpace(title) ? "TimeTask" : title,
                BalloonTipText = string.IsNullOrWhiteSpace(message) ? "已完成操作" : message,
                BalloonTipIcon = icon
            };

            notification.ShowBalloonTip(durationMs);
            System.Threading.ThreadPool.QueueUserWorkItem(delegate
            {
                System.Threading.Thread.Sleep(durationMs);
                notification.Dispose();
            });
        }

        private DataGrid FindSourceGridForTask(ItemGrid task)
        {
            if (task == null)
            {
                return null;
            }

            if (task1.ItemsSource is List<ItemGrid> q1 && q1.Contains(task)) return task1;
            if (task2.ItemsSource is List<ItemGrid> q2 && q2.Contains(task)) return task2;
            if (task3.ItemsSource is List<ItemGrid> q3 && q3.Contains(task)) return task3;
            if (task4.ItemsSource is List<ItemGrid> q4 && q4.Contains(task)) return task4;
            return null;
        }

        private void DataGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
        {
            if (e.EditAction == DataGridEditAction.Commit)
            {
                // Check if the edited column is the "Task" column.
                // Using HeaderText assumes the XAML <DataGridTemplateColumn Header="Task" ... />
                // For DataGridTemplateColumn, e.Column.Header is correct.
                string headerText = e.Column.Header?.ToString();
                bool isTaskColumn = string.Equals(headerText, "Task", StringComparison.OrdinalIgnoreCase)
                    || string.Equals(headerText, I18n.T("Task_Header"), StringComparison.OrdinalIgnoreCase);
                if (isTaskColumn)
                {
                    var item = e.Row.Item as ItemGrid;
                    if (item != null && e.EditingElement is TextBox textBox)
                    {
                        string newDescription = textBox.Text;
                        // The newDescription is what the user entered.
                        // item.Task will be updated by the binding mechanism after this event if not handled.
                        // We will update it manually here.

                        item.Task = newDescription; // Update the task description
                        item.LastModifiedDate = DateTime.Now; // Update the last modified date
                        item.LastProgressDate = DateTime.Now;
                        item.LastInteractionDate = DateTime.Now;
                        item.InactiveWarningCount = 0;
                        item.ReminderSnoozeUntil = null;
                        TrackTaskInteraction(item, "edit");
                        RecordTaskProgressProfile(item, "manual_edit");

                        Console.WriteLine($"Task edited in grid. Task ID (if available): [{item.SourceTaskID}], New Description: [{newDescription}]");

                        DataGrid sourceGrid = sender as DataGrid;
                        if (sourceGrid != null)
                        {
                            string quadrantNumber = GetQuadrantNumber(sourceGrid.Name);
                            if (!string.IsNullOrEmpty(quadrantNumber))
                            {
                                update_csv(sourceGrid, quadrantNumber);
                                // RefreshDataGrid(sourceGrid); // Optional: Usually binding handles UI update.
                                                            // If not, or if sorting/filtering needs re-evaluation based on new text, uncomment.
                            }
                        }
                    }
                }
            }
        }

        private void DataGrid_PreviewMouseLeftButtonDown_BeginEdit(object sender, MouseButtonEventArgs e)
        {
            if (!(sender is DataGrid dataGrid) || !(e.OriginalSource is DependencyObject source))
            {
                return;
            }

            if (FindParent<Button>(source) != null)
            {
                return;
            }

            var row = FindParent<DataGridRow>(source);
            if (row == null)
            {
                return;
            }


            if (row.Item == CollectionView.NewItemPlaceholder)
            {
                return;
            }

            var cell = FindParent<DataGridCell>(source);
            if (cell == null || cell.IsEditing || cell.IsReadOnly)
            {
                return;
            }

            dataGrid.SelectedItem = row.Item;
            dataGrid.CurrentCell = new DataGridCellInfo(cell);
            dataGrid.BeginEdit(e);
        }


        internal void update_csv(DataGrid dgv, string number, string basePath = null) { // Added basePath for testing flexibility
            if (dgv == null) return; // Simplified for testing if dgv is null

            var itemsToSave = new List<ItemGrid>();
            if (dgv.ItemsSource is IEnumerable<ItemGrid> items)
            {
                itemsToSave.AddRange(items);
            }
            // In a test scenario, dgv.ItemsSource might be directly set to List<ItemGrid>
            // and dgv.Items might not be populated if the DataGrid is not rendered.
            // Iterating dgv.ItemsSource is generally more reliable for data access.

            string dirPath = basePath ?? Path.Combine(currentPath, "data");
            if (!Directory.Exists(dirPath) && basePath != null) // Create test data directory if specified and not exists
            {
                Directory.CreateDirectory(dirPath);
            }
            HelperClass.WriteCsv(itemsToSave, Path.Combine(dirPath, number + ".csv"));
        }

        private void task1_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            task1_selected_indexs = task1.SelectedIndex;
            update_csv(task1, "1");
        }

        private void task2_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            task2_selected_indexs = task2.SelectedIndex;
            update_csv(task2, "2");
        }

        private void task3_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            task3_selected_indexs = task3.SelectedIndex;
            update_csv(task3, "3");
        }

        private void task4_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            task4_selected_indexs = task4.SelectedIndex;
            update_csv(task4, "4");
        }

        private void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            //base.OnMouseLeftButtonDown(e);
            //this.DragMove();
            if (e.ButtonState == MouseButtonState.Pressed)
            {
                this.DragMove();
            }
        }

        // 定义常量用于SetWindowLong
        private const int GWL_EXSTYLE = -20;
        private const int WS_EX_TOPMOST = 0x00000008;
        private const int WS_EX_NOACTIVATE = 0x08000000;
        private const int WS_EX_TOOLWINDOW = 0x00000080;
        private const int WS_EX_TRANSPARENT = 0x00000020;

        [DllImport("user32.dll")]
        static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
        private const uint SWP_NOMOVE = 0x0002;
        private const uint SWP_NOSIZE = 0x0001;
        private static readonly IntPtr HWND_BOTTOM = new IntPtr(1);

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            IntPtr tWnd = new WindowInteropHelper(this).Handle;
            
            // 设置窗口为最底层（桌面之上，其他窗口之下）
            // 不再将窗口设置为桌面子窗口，避免桌面刷新时消失
            SetWindowPos(tWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
        }

        private void location_Save(object sender, EventArgs e)
        {
            var normalizedPosition = NormalizeWindowPosition(this.Left, this.Top, this.ActualWidth, this.ActualHeight);
            Properties.Settings.Default.Top = normalizedPosition.Y;
            Properties.Settings.Default.Left = normalizedPosition.X;
            Properties.Settings.Default.Save();
        }

        private static Point NormalizeWindowPosition(double left, double top, double width, double height)
        {
            const int minVisiblePixels = 80;
            const double fallbackWidth = 810;
            const double fallbackHeight = 630;

            if (double.IsNaN(width) || width <= 0)
            {
                width = fallbackWidth;
            }

            if (double.IsNaN(height) || height <= 0)
            {
                height = fallbackHeight;
            }

            var windowRect = new System.Drawing.Rectangle(
                (int)Math.Round(left),
                (int)Math.Round(top),
                (int)Math.Round(width),
                (int)Math.Round(height));

            var screens = System.Windows.Forms.Screen.AllScreens;
            foreach (var screen in screens)
            {
                var intersection = System.Drawing.Rectangle.Intersect(windowRect, screen.WorkingArea);
                if (intersection.Width >= minVisiblePixels && intersection.Height >= minVisiblePixels)
                {
                    return new Point(left, top);
                }
            }

            var targetWorkingArea = (screens.Length > 0 ? screens[0] : System.Windows.Forms.Screen.PrimaryScreen)?.WorkingArea
                ?? new System.Drawing.Rectangle(0, 0, (int)fallbackWidth, (int)fallbackHeight);
            var windowCenterX = left + width / 2;
            var windowCenterY = top + height / 2;
            var minDistance = double.MaxValue;

            foreach (var screen in screens)
            {
                var area = screen.WorkingArea;
                var clampedX = Math.Max(area.Left, Math.Min(windowCenterX, area.Right));
                var clampedY = Math.Max(area.Top, Math.Min(windowCenterY, area.Bottom));
                var distance = Math.Pow(windowCenterX - clampedX, 2) + Math.Pow(windowCenterY - clampedY, 2);

                if (distance < minDistance)
                {
                    minDistance = distance;
                    targetWorkingArea = area;
                }
            }

            double normalizedLeft;
            double normalizedTop;

            if (width >= targetWorkingArea.Width)
            {
                normalizedLeft = targetWorkingArea.Left;
            }
            else
            {
                normalizedLeft = Math.Max(
                    targetWorkingArea.Left,
                    Math.Min(left, targetWorkingArea.Right - width));
            }

            if (height >= targetWorkingArea.Height)
            {
                normalizedTop = targetWorkingArea.Top;
            }
            else
            {
                normalizedTop = Math.Max(
                    targetWorkingArea.Top,
                    Math.Min(top, targetWorkingArea.Bottom - height));
            }

            return new Point(normalizedLeft, normalizedTop);
        }

        public void DeleteTaskRow_Click(object sender, RoutedEventArgs e)
        {
            Button deleteButton = sender as Button;
            if (deleteButton == null) return;

            ItemGrid taskToDelete = deleteButton.DataContext as ItemGrid;
            if (taskToDelete == null) return;

            DataGrid sourceGrid = null;

            if (task1.ItemsSource is List<ItemGrid> tasks1List && tasks1List.Remove(taskToDelete)) sourceGrid = task1;
            else if (task2.ItemsSource is List<ItemGrid> tasks2List && tasks2List.Remove(taskToDelete)) sourceGrid = task2;
            else if (task3.ItemsSource is List<ItemGrid> tasks3List && tasks3List.Remove(taskToDelete)) sourceGrid = task3;
            else if (task4.ItemsSource is List<ItemGrid> tasks4List && tasks4List.Remove(taskToDelete)) sourceGrid = task4;

            if (sourceGrid != null)
            {
                RefreshDataGrid(sourceGrid); // Refresh the specific grid
                update_csv(sourceGrid, GetQuadrantNumber(sourceGrid.Name));
                _behaviorObserver?.RecordTaskOperation("delete", taskToDelete.Task, GetTaskTrackingKey(taskToDelete));
                if (taskToDelete.LongTermGoalId == _activeLongTermGoal?.Id) // Check if deleted task was part of the active goal
                {
                    UpdateLongTermGoalBadge();
                }
            }
        }

        public static T FindParent<T>(DependencyObject child) where T : DependencyObject
        {
            DependencyObject parentObject = VisualTreeHelper.GetParent(child);
            if (parentObject == null) return null;
            T parent = parentObject as T;
            if (parent != null)
                return parent;
            else
                return FindParent<T>(parentObject);
        }

        private sealed class ReminderTimeEditorWindow : Window
        {
            private readonly CheckBox _enableCheckBox;
            private readonly DatePicker _datePicker;
            private readonly ComboBox _hourCombo;
            private readonly ComboBox _minuteCombo;

            public DateTime? SelectedReminderTime { get; private set; }

            public ReminderTimeEditorWindow(DateTime? currentReminder)
            {
                Title = I18n.T("Reminder_EditorWindowTitle");
                Width = 320;
                Height = 240;
                WindowStartupLocation = WindowStartupLocation.CenterOwner;
                ResizeMode = ResizeMode.NoResize;
                WindowStyle = WindowStyle.SingleBorderWindow;

                var panel = new StackPanel { Margin = new Thickness(16) };
                panel.Children.Add(new TextBlock
                {
                    Text = I18n.T("Reminder_EditorInstruction"),
                    Margin = new Thickness(0, 0, 0, 10),
                    FontWeight = FontWeights.SemiBold
                });

                _enableCheckBox = new CheckBox
                {
                    Content = I18n.T("Reminder_EditorEnable"),
                    IsChecked = currentReminder.HasValue,
                    Margin = new Thickness(0, 0, 0, 8)
                };
                panel.Children.Add(_enableCheckBox);

                _datePicker = new DatePicker
                {
                    SelectedDate = currentReminder?.Date ?? DateTime.Today,
                    Margin = new Thickness(0, 0, 0, 8)
                };
                panel.Children.Add(_datePicker);

                var timePanel = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 0, 0, 12) };
                _hourCombo = new ComboBox { Width = 70 };
                _minuteCombo = new ComboBox { Width = 70, Margin = new Thickness(8, 0, 0, 0) };
                for (int i = 0; i < 24; i++) _hourCombo.Items.Add(i.ToString("D2"));
                for (int i = 0; i < 60; i++) _minuteCombo.Items.Add(i.ToString("D2"));
                _hourCombo.SelectedItem = (currentReminder?.Hour ?? 9).ToString("D2");
                _minuteCombo.SelectedItem = (currentReminder?.Minute ?? 0).ToString("D2");
                timePanel.Children.Add(_hourCombo);
                timePanel.Children.Add(new TextBlock { Text = ":", VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 0, 0) });
                timePanel.Children.Add(_minuteCombo);
                panel.Children.Add(timePanel);

                var buttonPanel = new StackPanel { Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Right };
                var ok = new Button { Content = I18n.T("Reminder_EditorSave"), Width = 70, Margin = new Thickness(0, 0, 8, 0) };
                var cancel = new Button { Content = I18n.T("Reminder_EditorCancel"), Width = 70 };
                ok.Click += Ok_Click;
                cancel.Click += (s, e) => { DialogResult = false; Close(); };
                buttonPanel.Children.Add(ok);
                buttonPanel.Children.Add(cancel);
                panel.Children.Add(buttonPanel);

                _enableCheckBox.Checked += (s, e) => ToggleInputs(true);
                _enableCheckBox.Unchecked += (s, e) => ToggleInputs(false);
                ToggleInputs(_enableCheckBox.IsChecked == true);

                Content = panel;
            }

            private void ToggleInputs(bool enabled)
            {
                _datePicker.IsEnabled = enabled;
                _hourCombo.IsEnabled = enabled;
                _minuteCombo.IsEnabled = enabled;
            }

            private void Ok_Click(object sender, RoutedEventArgs e)
            {
                if (_enableCheckBox.IsChecked != true)
                {
                    SelectedReminderTime = null;
                    DialogResult = true;
                    Close();
                    return;
                }

                if (!_datePicker.SelectedDate.HasValue)
                {
                    MessageBox.Show(I18n.T("Reminder_EditorSelectDate"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                if (!int.TryParse(_hourCombo.SelectedItem?.ToString(), out int hour) ||
                    !int.TryParse(_minuteCombo.SelectedItem?.ToString(), out int minute))
                {
                    MessageBox.Show(I18n.T("Reminder_EditorSelectValidTime"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                DateTime date = _datePicker.SelectedDate.Value;
                SelectedReminderTime = new DateTime(date.Year, date.Month, date.Day, hour, minute, 0);
                DialogResult = true;
                Close();
            }
        }

        internal static string GetQuadrantNumber(string dataGridName) // Made internal static for testing. Returns "1", "2", "3", "4"
        {
            switch (dataGridName)
            {
                case "task1": return "1"; // Corresponds to index 0
                case "task2": return "2"; // Corresponds to index 1
                case "task3": return "3"; // Corresponds to index 2
                case "task4": return "4"; // Corresponds to index 3
                default: return null;
            }
        }

        // Helper to get a user-friendly quadrant name from index
        internal static string GetQuadrantName(int index)
        {
            switch (index)
            {
                case 0: return "Important & Urgent";
                case 1: return "Important & Not Urgent";
                case 2: return "Not Important & Urgent";
                case 3: return "Not Important & Not Urgent";
                default: return "Unknown Quadrant";
            }
        }

        private void RefreshDataGrid(DataGrid dataGrid)
        {
            if (dataGrid == null) return;
            
            try
            {
                // 取消任何正在进行的编辑操作
                dataGrid.CancelEdit();
                dataGrid.CommitEdit();
                
                var itemsSource = dataGrid.ItemsSource as List<ItemGrid>;
                if (itemsSource == null) return;
                
                // 安全地刷新数据源
                dataGrid.ItemsSource = null;
                dataGrid.ItemsSource = itemsSource;
                
                // 重新应用排序
                if (!dataGrid.Items.SortDescriptions.Contains(new SortDescription("Score", ListSortDirection.Descending)))
                {
                    dataGrid.Items.SortDescriptions.Add(new SortDescription("Score", ListSortDirection.Descending));
                }

                UpdateFocusBoard();
            }
            catch (Exception ex)
            {
                // 如果刷新失败，尝试简单的Items.Refresh()
                try
                {
                    dataGrid.Items.Refresh();
                    UpdateFocusBoard();
                }
                catch
                {
                    // 记录错误但不中断程序
                    System.Diagnostics.Debug.WriteLine($"RefreshDataGrid failed: {ex.Message}");
                }
            }
        }

        private void UpdateFocusBoard()
        {
            DateTime now = DateTime.Now;
            var allTasks = GetAllQuadrantTasks();
            var snapshot = BuildFocusBoardSnapshot(allTasks, now);
            var metrics = ShouldRecordBehavior() ? _userProfileManager?.GetDashboardMetrics(7) : null;
            var progress = BuildSystemProgressSnapshot(allTasks, _activeLongTermGoal, metrics, now);

            _primaryFocusTask = snapshot.PrimaryTask;
            _reminderFocusTask = snapshot.ReminderTask;
            _stuckFocusTask = snapshot.StuckTask;
            UpdateQuadrantCounts();
            UpdateSystemPanel(progress);

            ApplyFocusCard(
                snapshot.PrimaryTask,
                snapshot.PrimaryMeta,
                PrimaryFocusTaskText,
                PrimaryFocusMetaText,
                PrimaryFocusButton,
                I18n.T("FocusBoard_PrimaryEmpty"));

            ApplyFocusCard(
                snapshot.ReminderTask,
                snapshot.ReminderMeta,
                ReminderFocusTaskText,
                ReminderFocusMetaText,
                ReminderFocusButton,
                I18n.T("FocusBoard_ReminderEmpty"));

            ApplyFocusCard(
                snapshot.StuckTask,
                snapshot.StuckMeta,
                StuckFocusTaskText,
                StuckFocusMetaText,
                StuckFocusButton,
                I18n.T("FocusBoard_StuckEmpty"));
        }

        private void UpdateSystemPanel(SystemProgressSnapshot snapshot)
        {
            if (snapshot == null)
            {
                return;
            }

            if (SystemLevelText != null)
            {
                SystemLevelText.Text = I18n.Tf("SystemPanel_LevelFormat", snapshot.Level);
            }

            if (SystemXpText != null)
            {
                SystemXpText.Text = I18n.Tf("SystemPanel_XpFormat", snapshot.Experience, snapshot.NextLevelExperience);
            }

            if (SystemStageText != null)
            {
                SystemStageText.Text = snapshot.StageText;
            }

            if (SystemNarrativeText != null)
            {
                SystemNarrativeText.Text = snapshot.NarrativeText;
            }

            if (SystemQuestText != null)
            {
                SystemQuestText.Text = snapshot.ActiveQuestText;
            }

            if (SystemSkillText != null)
            {
                SystemSkillText.Text = snapshot.RecommendedSkillText;
            }

            _skillTreeNodeMap.Clear();
            if (SkillTreeCard1 != null && snapshot.SkillNodes.ElementAtOrDefault(0) != null) _skillTreeNodeMap[SkillTreeCard1] = snapshot.SkillNodes[0];
            if (SkillTreeCard2 != null && snapshot.SkillNodes.ElementAtOrDefault(1) != null) _skillTreeNodeMap[SkillTreeCard2] = snapshot.SkillNodes[1];
            if (SkillTreeCard3 != null && snapshot.SkillNodes.ElementAtOrDefault(2) != null) _skillTreeNodeMap[SkillTreeCard3] = snapshot.SkillNodes[2];
            if (SkillTreeCard4 != null && snapshot.SkillNodes.ElementAtOrDefault(3) != null) _skillTreeNodeMap[SkillTreeCard4] = snapshot.SkillNodes[3];

            ApplySkillTreeNode(snapshot.SkillNodes.ElementAtOrDefault(0), SkillTreeCard1, SkillTreeName1, SkillTreeLevel1, SkillTreeMeta1);
            ApplySkillTreeNode(snapshot.SkillNodes.ElementAtOrDefault(1), SkillTreeCard2, SkillTreeName2, SkillTreeLevel2, SkillTreeMeta2);
            ApplySkillTreeNode(snapshot.SkillNodes.ElementAtOrDefault(2), SkillTreeCard3, SkillTreeName3, SkillTreeLevel3, SkillTreeMeta3);
            ApplySkillTreeNode(snapshot.SkillNodes.ElementAtOrDefault(3), SkillTreeCard4, SkillTreeName4, SkillTreeLevel4, SkillTreeMeta4);

            RefreshSystemTicker(snapshot);
            ApplySystemPanelMode();
        }

        private void RefreshSystemTicker(SystemProgressSnapshot snapshot)
        {
            _systemTickerMessages.Clear();

            if (snapshot != null)
            {
                if (!string.IsNullOrWhiteSpace(snapshot.StageText))
                {
                    _systemTickerMessages.Add(snapshot.StageText);
                }

                if (!string.IsNullOrWhiteSpace(snapshot.ActiveQuestText))
                {
                    _systemTickerMessages.Add(snapshot.ActiveQuestText);
                }

                if (!string.IsNullOrWhiteSpace(snapshot.RecommendedSkillText))
                {
                    _systemTickerMessages.Add(snapshot.RecommendedSkillText);
                }
            }

            if (!string.IsNullOrWhiteSpace(PrimaryFocusTaskText?.Text) &&
                PrimaryFocusTaskText.Text != I18n.T("FocusBoard_PrimaryEmpty"))
            {
                _systemTickerMessages.Add(I18n.Tf("SystemPanel_TickerPrimaryFormat", PrimaryFocusTaskText.Text));
            }

            if (!string.IsNullOrWhiteSpace(ReminderFocusTaskText?.Text) &&
                ReminderFocusTaskText.Text != I18n.T("FocusBoard_ReminderEmpty"))
            {
                _systemTickerMessages.Add(I18n.Tf("SystemPanel_TickerReminderFormat", ReminderFocusTaskText.Text));
            }

            if (!string.IsNullOrWhiteSpace(StuckFocusTaskText?.Text) &&
                StuckFocusTaskText.Text != I18n.T("FocusBoard_StuckEmpty"))
            {
                _systemTickerMessages.Add(I18n.Tf("SystemPanel_TickerStuckFormat", StuckFocusTaskText.Text));
            }

            _systemTickerMessages.RemoveAll(string.IsNullOrWhiteSpace);
            if (_systemTickerMessages.Count == 0)
            {
                _systemTickerMessages.Add(I18n.T("SystemPanel_TickerDefault"));
            }

            if (_systemTickerIndex >= _systemTickerMessages.Count)
            {
                _systemTickerIndex = 0;
            }

            UpdateSystemTickerText();
        }

        private void UpdateSystemTickerText()
        {
            if (SystemTickerText == null)
            {
                return;
            }

            if (_systemTickerMessages.Count == 0)
            {
                SystemTickerText.Text = I18n.T("SystemPanel_TickerDefault");
                return;
            }

            SystemTickerText.Text = _systemTickerMessages[_systemTickerIndex];
        }

        private void SystemTickerTimer_Tick(object sender, EventArgs e)
        {
            if (_systemTickerMessages.Count <= 1)
            {
                UpdateSystemTickerText();
                return;
            }

            _systemTickerIndex = (_systemTickerIndex + 1) % _systemTickerMessages.Count;
            UpdateSystemTickerText();
        }

        private void ApplySystemPanelMode()
        {
            if (SystemPanelRoot != null)
            {
                SystemPanelRoot.Padding = _isSystemPanelCompactMode
                    ? new Thickness(10, 10, 10, 8)
                    : new Thickness(12);
            }

            if (SystemSkillColumn != null)
            {
                SystemSkillColumn.Width = _isSystemPanelCompactMode
                    ? new GridLength(0)
                    : new GridLength(1.4, GridUnitType.Star);
            }

            if (SystemSkillTreeSection != null)
            {
                SystemSkillTreeSection.Visibility = _isSystemPanelCompactMode ? Visibility.Collapsed : Visibility.Visible;
            }

            if (SystemSummarySection != null)
            {
                Grid.SetColumnSpan(SystemSummarySection, _isSystemPanelCompactMode ? 2 : 1);
                SystemSummarySection.Margin = _isSystemPanelCompactMode
                    ? new Thickness(0)
                    : new Thickness(0, 0, 10, 0);
            }

            if (FocusBoardDetailSection != null)
            {
                FocusBoardDetailSection.Visibility = _isSystemPanelCompactMode ? Visibility.Collapsed : Visibility.Visible;
            }

            if (SystemNarrativeText != null)
            {
                SystemNarrativeText.Visibility = _isSystemPanelCompactMode ? Visibility.Collapsed : Visibility.Visible;
                SystemNarrativeText.MaxHeight = _isSystemPanelCompactMode ? 0 : 36;
                SystemNarrativeText.TextTrimming = _isSystemPanelCompactMode ? TextTrimming.CharacterEllipsis : TextTrimming.None;
            }

            if (SystemTickerBanner != null)
            {
                SystemTickerBanner.Margin = _isSystemPanelCompactMode
                    ? new Thickness(0, 0, 0, 0)
                    : new Thickness(0, 0, 0, 8);
            }

            if (SystemPanelToggleButton != null)
            {
                SystemPanelToggleButton.Content = _isSystemPanelCompactMode
                    ? I18n.T("SystemPanel_ButtonExpand")
                    : I18n.T("SystemPanel_ButtonCompact");
            }
        }

        private static void ApplySkillTreeNode(
            SystemSkillNodeSnapshot node,
            Border card,
            TextBlock nameBlock,
            TextBlock levelBlock,
            TextBlock metaBlock)
        {
            if (card == null || nameBlock == null || levelBlock == null || metaBlock == null)
            {
                return;
            }

            if (node == null)
            {
                nameBlock.Text = I18n.T("SystemPanel_SkillFallback");
                levelBlock.Text = I18n.Tf("SystemPanel_SkillNodeLevelFormat", 1);
                metaBlock.Text = I18n.T("SystemPanel_SkillNodeLocked");
                card.ToolTip = null;
                return;
            }

            nameBlock.Text = node.Title;
            levelBlock.Text = I18n.Tf("SystemPanel_SkillNodeLevelFormat", node.Level);
            metaBlock.Text = node.MetaText;
            card.ToolTip = node.ToolTipText;
        }

        private async void SkillTreeCard_Click(object sender, MouseButtonEventArgs e)
        {
            if (!(sender is Border card) || !_skillTreeNodeMap.TryGetValue(card, out var node) || node == null)
            {
                return;
            }

            await ExecuteSystemSkillNodeAsync(node);
        }

        private async Task ExecuteSystemSkillNodeAsync(SystemSkillNodeSnapshot node)
        {
            if (node == null || string.IsNullOrWhiteSpace(node.SkillId))
            {
                return;
            }

            var task = FindBestTaskForSkill(node.SkillId);
            if (task == null)
            {
                MessageBox.Show(I18n.T("SystemPanel_NoSkillContext"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            var sourceGrid = FindContainingGrid(task);
            if (sourceGrid == null)
            {
                MessageBox.Show(I18n.T("Message_TaskQuadrantNotFound"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            FocusTaskInBoard(task);

            TimeSpan inactiveDuration = DateTime.Now - task.LastProgressDate;
            var recommendation = ThinkingToolAdvisor.RecommendForTask(task.Task, task.Importance, task.Urgency, inactiveDuration, 8)
                .FirstOrDefault(r => string.Equals(r.SkillId, node.SkillId, StringComparison.OrdinalIgnoreCase));

            if (recommendation == null)
            {
                recommendation = new ThinkingToolRecommendation
                {
                    SkillId = node.SkillId,
                    Title = node.Title,
                    Why = node.MetaText,
                    NextStep = I18n.T("SystemPanel_SkillNodeNextStepFallback"),
                    Confidence = 0.6
                };
            }

            await ExecuteThinkingToolForTaskAsync(task, sourceGrid, recommendation);
        }

        private void SystemPanelToggleButton_Click(object sender, RoutedEventArgs e)
        {
            _isSystemPanelCompactMode = !_isSystemPanelCompactMode;
            ApplySystemPanelMode();
        }

        private ItemGrid FindBestTaskForSkill(string skillId)
        {
            var tasks = GetAllQuadrantTasks()
                .Where(t => t != null && t.IsActive && !string.IsNullOrWhiteSpace(t.Task))
                .ToList();

            if (tasks.Count == 0)
            {
                return null;
            }

            return tasks
                .Select(task => new
                {
                    Task = task,
                    Recommendation = ThinkingToolAdvisor.RecommendForTask(
                        task.Task,
                        task.Importance,
                        task.Urgency,
                        DateTime.Now - task.LastProgressDate,
                        8).FirstOrDefault(r => string.Equals(r.SkillId, skillId, StringComparison.OrdinalIgnoreCase))
                })
                .Where(x => x.Recommendation != null)
                .OrderByDescending(x => x.Recommendation.Confidence)
                .ThenByDescending(x => string.Equals(x.Task.Importance, "High", StringComparison.OrdinalIgnoreCase))
                .ThenByDescending(x => string.Equals(x.Task.Urgency, "High", StringComparison.OrdinalIgnoreCase))
                .ThenByDescending(x => x.Task.Score)
                .Select(x => x.Task)
                .FirstOrDefault()
                ?? _primaryFocusTask
                ?? _stuckFocusTask
                ?? tasks.FirstOrDefault();
        }

        private void UpdateQuadrantCounts()
        {
            UpdateQuadrantCountText(Quadrant1CountText, task1?.ItemsSource as IEnumerable<ItemGrid>);
            UpdateQuadrantCountText(Quadrant2CountText, task2?.ItemsSource as IEnumerable<ItemGrid>);
            UpdateQuadrantCountText(Quadrant3CountText, task3?.ItemsSource as IEnumerable<ItemGrid>);
            UpdateQuadrantCountText(Quadrant4CountText, task4?.ItemsSource as IEnumerable<ItemGrid>);
        }

        private static void UpdateQuadrantCountText(TextBlock target, IEnumerable<ItemGrid> tasks)
        {
            if (target == null)
            {
                return;
            }

            int count = tasks?.Count(t => t != null && t.IsActive && !string.IsNullOrWhiteSpace(t.Task)) ?? 0;
            target.Text = count.ToString(CultureInfo.InvariantCulture);
        }

        private static void ApplyFocusCard(
            ItemGrid task,
            string meta,
            TextBlock titleBlock,
            TextBlock metaBlock,
            Button actionButton,
            string emptyText)
        {
            if (titleBlock == null || metaBlock == null || actionButton == null)
            {
                return;
            }

            if (task == null)
            {
                titleBlock.Text = emptyText;
                metaBlock.Text = I18n.T("FocusBoard_EmptyMeta");
                actionButton.IsEnabled = false;
                return;
            }

            titleBlock.Text = task.Task;
            metaBlock.Text = string.IsNullOrWhiteSpace(meta) ? I18n.T("FocusBoard_EmptyMeta") : meta;
            actionButton.IsEnabled = true;
        }


        private void DataGridRow_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            // Check if the click originated from utility buttons first.
            Button sourceButton = e.OriginalSource as Button ?? FindParent<Button>(e.OriginalSource as DependencyObject);
            if (sourceButton != null &&
                (sourceButton.Name == "PART_DeleteButton"
                 || sourceButton.Name == "PART_ReminderButton"
                 || sourceButton.Name == "PART_DecomposeButton"
                 || sourceButton.Name == "PART_ThinkingButton"))
            {
                // Let utility button handle its click, don't start drag.
                _dragStartPoint = null; // Ensure no drag starts
                _draggedItem = null;
                _sourceDataGrid = null;
                return;
            }

            // Also, ensure that we are dealing with the primary mouse button for drag
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                DataGridRow row = sender as DataGridRow; // The sender is the DataGridRow
                if (row == null || !row.IsSelected)
                {
                    // If row is null, or you want to be more specific,
                    // you can try to find the parent row from e.OriginalSource as before.
                    // row = FindParent<DataGridRow>((DependencyObject)e.OriginalSource);
                }


                if (row != null && row.Item is ItemGrid item)
                {
                    _dragStartPoint = e.GetPosition(null); // Get position relative to the screen or a top-level window
                    _draggedItem = item;
                    _sourceDataGrid = FindParent<DataGrid>(row);
                    // Do NOT call DragDrop.DoDragDrop here.
                    // Do NOT set e.Handled = true here, to allow the DataGrid to process the click for focus/selection.
                }
                else
                {
                    // Click was not on a valid item or row, clear drag state
                    _dragStartPoint = null;
                    _draggedItem = null;
                    _sourceDataGrid = null;
                }
            }
            else // Not a left-button press, clear drag state
            {
                 _dragStartPoint = null;
                 _draggedItem = null;
                 _sourceDataGrid = null;
            }
        }

        private void DataGridRow_PreviewMouseMove(object sender, MouseEventArgs e)
        {
            if (_dragStartPoint.HasValue && e.LeftButton == MouseButtonState.Pressed && _draggedItem != null && _sourceDataGrid != null)
            {
                Point currentPosition = e.GetPosition(null);
                Vector diff = _dragStartPoint.Value - currentPosition;

                if (Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance ||
                    Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance)
                {
                    // Start the drag operation
                    // The 'sender' here is the DataGridRow. We pass it as the drag source.
                    DataGridRow row = sender as DataGridRow;
                    if (row != null)
                    {
                        DragDrop.DoDragDrop(row, _draggedItem, DragDropEffects.Move);
                    }

                    // Reset stored drag data after DragDrop completes
                    _dragStartPoint = null;
                    _draggedItem = null;
                    _sourceDataGrid = null;
                    // e.Handled can optionally be set to true here if needed,
                    // but DoDragDrop usually takes over input sufficiently.
                }
            }
        }

        private void DataGridRow_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            // If the mouse button is released and a drag hasn't started, clear drag state.
            if (_dragStartPoint.HasValue)
            {
                _dragStartPoint = null;
                _draggedItem = null;
                _sourceDataGrid = null;
            }
        }

        private void Task_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(ItemGrid)))
            {
                e.Effects = DragDropEffects.Move;
            }
            else
            {
                e.Effects = DragDropEffects.None;
            }
            e.Handled = true;
        }

        private void Task_DragOver(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(ItemGrid)))
            {
                e.Effects = DragDropEffects.Move;
            }
            else
            {
                e.Effects = DragDropEffects.None;
            }
            e.Handled = true;
        }

        // Extracted core logic for testability
        internal static bool ProcessTaskDrop(ItemGrid draggedItem, List<ItemGrid> sourceList, List<ItemGrid> targetList, string targetDataGridName)
        {
            if (draggedItem == null || sourceList == null || targetList == null)
            {
                return false;
            }

            if (!sourceList.Contains(draggedItem))
            {
                return false;
            }

            sourceList.Remove(draggedItem);
            targetList.Add(draggedItem);
            draggedItem.LastModifiedDate = DateTime.Now;
            draggedItem.LastInteractionDate = DateTime.Now;
            draggedItem.InactiveWarningCount = 0;
            draggedItem.ReminderSnoozeUntil = null;

            string newImportance = "Unknown";
            string newUrgency = "Unknown";

            switch (targetDataGridName)
            {
                case "task1": newImportance = "High"; newUrgency = "High"; break;
                case "task2": newImportance = "High"; newUrgency = "Low"; break;
                case "task3": newImportance = "Low"; newUrgency = "High"; break;
                case "task4": newImportance = "Low"; newUrgency = "Low"; break;
            }

            draggedItem.Importance = newImportance;
            draggedItem.Urgency = newUrgency;

            return true;
        }

        internal static bool ProcessTaskReorder(ItemGrid draggedItem, List<ItemGrid> list, int originalIndex, int visualTargetIndex)
        {
            if (list == null || draggedItem == null || !list.Contains(draggedItem))
            {
                return false; // Should not happen if called correctly
            }

            // If visualTargetIndex is where the item already is or would be inserted right after itself, effectively not changing order.
            // An item at 'originalIndex' is proposed to be inserted *before* 'visualTargetIndex'.
            // No change if:
            // 1. visualTargetIndex == originalIndex (drop onto self, insert before self - no change)
            // 2. visualTargetIndex == originalIndex + 1 (drop onto item after self, insert before item after self - no change)
            if (visualTargetIndex == originalIndex || visualTargetIndex == originalIndex + 1)
            {
                return false; // No actual move
            }

            list.RemoveAt(originalIndex); // Remove from old position first

            // Adjust targetIndex for insertion based on original position
            int actualInsertionIndex = visualTargetIndex;
            if (originalIndex < visualTargetIndex)
            {
                actualInsertionIndex--; // The list shifted, so the visual target index is now one less
            }

            // Ensure actualInsertionIndex is within bounds
            if (actualInsertionIndex < 0) actualInsertionIndex = 0;
            if (actualInsertionIndex > list.Count) actualInsertionIndex = list.Count;


            list.Insert(actualInsertionIndex, draggedItem);
            draggedItem.LastModifiedDate = DateTime.Now;
            draggedItem.LastInteractionDate = DateTime.Now;
            draggedItem.InactiveWarningCount = 0;
            draggedItem.ReminderSnoozeUntil = null;

            // Update scores
            for (int i = 0; i < list.Count; i++)
            {
                list[i].Score = list.Count - i;
            }
            return true;
        }

        private void Quadrant_Drop(object sender, DragEventArgs e)
        {
            if (_draggedItem == null || _sourceDataGrid == null)
            {
                e.Effects = DragDropEffects.None;
                e.Handled = true;
                return;
            }

            DataGrid targetDataGrid = sender as DataGrid;
    if (targetDataGrid == null)
            {
                _draggedItem = null;
                _sourceDataGrid = null;
                e.Handled = true;
                return;
            }

            if (e.Data.GetDataPresent(typeof(ItemGrid)))
            {
        ItemGrid draggedItem = _draggedItem; // Renamed for clarity
        var sourceList = _sourceDataGrid.ItemsSource as List<ItemGrid>; // This is also the targetList if quadrants are the same

        if (targetDataGrid == _sourceDataGrid) // Reordering within the same quadrant
                {
            if (sourceList != null && draggedItem != null && sourceList.Contains(draggedItem))
            {
                // Determine visual drop position (index in the list as currently displayed)
                Point mousePosition = e.GetPosition(targetDataGrid);
                int visualDropIndex = -1;
                for (int i = 0; i < targetDataGrid.Items.Count; i++)
                {
                    var row = (DataGridRow)targetDataGrid.ItemContainerGenerator.ContainerFromIndex(i);
                    if (row != null)
                    {
                        // Using Point(0,0) relative to the row for its top-left corner
                        Point rowTopLeftInGrid = row.TransformToAncestor(targetDataGrid).Transform(new Point(0, 0));
                        if (mousePosition.Y < rowTopLeftInGrid.Y + row.ActualHeight / 2)
                        {
                            visualDropIndex = i; // Drop will be before this item
                            break;
                        }
                    }
                }

                if (visualDropIndex == -1) // Dropped below all items or on empty grid
                {
                    visualDropIndex = targetDataGrid.Items.Count; // Target is to append (insert before conceptual item at Count)
                }

                int originalIndex = sourceList.IndexOf(draggedItem);

                // Call the testable helper method
                // The visualDropIndex is the index in the list *before* removal, where the item should be inserted.
                if (ProcessTaskReorder(draggedItem, sourceList, originalIndex, visualDropIndex))
                {
                    TrackTaskInteraction(draggedItem, "reorder");
                    RecordTaskProgressProfile(draggedItem, "reorder");
                    RefreshDataGrid(targetDataGrid);
                    string quadrantNumber = GetQuadrantNumber(targetDataGrid.Name);
                    if (quadrantNumber != null) update_csv(targetDataGrid, quadrantNumber);
                }
                // If ProcessTaskReorder returns false (no actual move), we do nothing here,
                // _draggedItem and _sourceDataGrid are cleared at the end of Quadrant_Drop.
            }
        }
        else // Moving to a different quadrant
                {
            var targetList = targetDataGrid.ItemsSource as List<ItemGrid>;
            if (targetList == null)
            {
                targetList = new List<ItemGrid>();
                targetDataGrid.ItemsSource = targetList;
            }

            if (ProcessTaskDrop(draggedItem, sourceList, targetList, targetDataGrid.Name))
            {
                TrackTaskInteraction(draggedItem, "move");
                string sourceQuadrantNumber = GetQuadrantNumber(_sourceDataGrid.Name);
                string targetQuadrantNumber = GetQuadrantNumber(targetDataGrid.Name);
                RecordQuadrantMoveProfile(draggedItem, sourceQuadrantNumber, targetQuadrantNumber);

                // Update scores for the source list (optional, but good for consistency if scores mean global order)
                // For now, let's assume scores are quadrant-local unless specified otherwise
                // Update scores for the target list (ProcessTaskDrop doesn't do this, but should it?)
                // The requirement implies scores are relative to the list they are in.
                // Let's add score recalculation for the target list here as well.
                for (int i = 0; i < targetList.Count; i++)
                {
                    targetList[i].Score = targetList.Count - i;
                }
                 // And for source list
                for (int i = 0; i < sourceList.Count; i++)
                {
                    sourceList[i].Score = sourceList.Count - i;
                }


                if (sourceQuadrantNumber != null) update_csv(_sourceDataGrid, sourceQuadrantNumber);
                if (targetQuadrantNumber != null) update_csv(targetDataGrid, targetQuadrantNumber);

                RefreshDataGrid(_sourceDataGrid);
                RefreshDataGrid(targetDataGrid);
            }
                }
            }
            _draggedItem = null;
            _sourceDataGrid = null;
            e.Handled = true;
        }

        private void AddQuickTask_Click(object sender, RoutedEventArgs e)
        {
            if (sender is Button clickedButton && clickedButton.Tag is string tagString)
            {
                if (int.TryParse(tagString, out int quadrantIndex))
                {
                    // Ensure _llmService is available (it's initialized in MainWindow's constructor)
                    if (_llmService == null)
                    {
                        MessageBox.Show("LLM Service is not available.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }

                    // This constructor signature will be updated in the next subtask.
                    // For now, this code assumes AddTaskWindow can take quadrantIndex.
                    AddTaskWindow addTaskWindow = new AddTaskWindow(_llmService, quadrantIndex);
                    bool? dialogResult = addTaskWindow.ShowDialog();

                    if (dialogResult == true && addTaskWindow.TaskAdded && addTaskWindow.NewTask != null)
                    {
                        ItemGrid newTask = addTaskWindow.NewTask;

                        int finalQuadrantIndex = AddTaskWindow.GetIndexFromPriority(newTask.Importance, newTask.Urgency);
                        DataGrid targetDataGrid = null;

                        switch (finalQuadrantIndex)
                        {
                            case 0: targetDataGrid = task1; break;
                            case 1: targetDataGrid = task2; break;
                            case 2: targetDataGrid = task3; break;
                            case 3: targetDataGrid = task4; break;
                            default:
                                MessageBox.Show("Invalid quadrant specified for the new task after dialog.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                                return;
                        }

                        string csvFileNumber = GetQuadrantNumber(targetDataGrid.Name);

                        List<ItemGrid> items = targetDataGrid.ItemsSource as List<ItemGrid>;
                        if (items == null)
                        {
                            items = new List<ItemGrid>();
                            targetDataGrid.ItemsSource = items;
                        }

                        items.Add(newTask);
                        TrackTaskInteraction(newTask, "progress");
                        RecordTaskProgressProfile(newTask, "manual_create");
                        // Re-score all items in the list for consistent ordering
                        for (int i = 0; i < items.Count; i++)
                        {
                            items[i].Score = items.Count - i;
                        }

                        RefreshDataGrid(targetDataGrid);
                        if (!string.IsNullOrEmpty(csvFileNumber))
                        {
                            update_csv(targetDataGrid, csvFileNumber);
                        }
                        else
                        {
                             MessageBox.Show($"Could not determine CSV file for quadrant: {targetDataGrid.Name}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                        }
                    }
                }
            }
        }

        private void SettingsButton_Click(object sender, RoutedEventArgs e)
        {
            ShowSettingsMenu();
        }

        private void DraftsButton_Click(object sender, RoutedEventArgs e)
        {
            // 创建草稿管理器实例
            TaskDraftManager draftManager;
            try
            {
                draftManager = new TaskDraftManager();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"无法加载草稿管理器: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            var draftWindow = new DraftViewerWindow(draftManager);
            draftWindow.Owner = this;
            draftWindow.ShowDialog();

            // 释放资源
            draftManager.Dispose();
            UpdateDraftBadge();
        }

        private void ShowSettingsMenu()
        {
            var contextMenu = new ContextMenu();
            
            // LLM设置
            var llmSettingsItem = new MenuItem
            {
                Header = I18n.T("Menu_AISettings_Header"),
                ToolTip = I18n.T("Menu_AISettings_Tooltip")
            };
            llmSettingsItem.Click += (s, e) => OpenLlmSettings();
            contextMenu.Items.Add(llmSettingsItem);
            
            // 提醒设置
            var reminderSettingsItem = new MenuItem
            {
                Header = I18n.T("Menu_ReminderSettings_Header"),
                ToolTip = I18n.T("Menu_ReminderSettings_Tooltip")
            };
            reminderSettingsItem.Click += (s, e) => OpenReminderSettings();
            contextMenu.Items.Add(reminderSettingsItem);

            var longTermGoalItem = new MenuItem
            {
                Header = I18n.T("Button_SetLongTermGoal"),
                ToolTip = I18n.T("Tooltip_SetLongTermGoal")
            };
            longTermGoalItem.Click += (s, e) => LongTermGoalButton_Click(s, e);
            contextMenu.Items.Add(longTermGoalItem);

            var skillManagementItem = new MenuItem
            {
                Header = I18n.T("Menu_Skill_Header"),
                ToolTip = I18n.T("Menu_Skill_Tooltip")
            };
            skillManagementItem.Click += (s, e) => OpenSkillManagement();
            contextMenu.Items.Add(skillManagementItem);

            var strategyDashboardItem = new MenuItem
            {
                Header = I18n.T("Menu_Strategy_Header"),
                ToolTip = I18n.T("Menu_Strategy_Tooltip")
            };
            strategyDashboardItem.Click += (s, e) => OpenStrategyDashboard();
            contextMenu.Items.Add(strategyDashboardItem);

            var knowledgeSyncItem = new MenuItem
            {
                Header = I18n.T("Menu_KnowledgeSync_Header"),
                ToolTip = I18n.T("Menu_KnowledgeSync_Tooltip")
            };
            knowledgeSyncItem.Click += async (s, e) => await RunKnowledgeSyncAsync(true);
            contextMenu.Items.Add(knowledgeSyncItem);

            var captureKnowledgeItem = new MenuItem
            {
                Header = I18n.T("Menu_CaptureKnowledge_Header"),
                ToolTip = I18n.T("Menu_CaptureKnowledge_Tooltip")
            };
            captureKnowledgeItem.Click += (s, e) => CaptureSelectedTaskKnowledge();
            contextMenu.Items.Add(captureKnowledgeItem);

            var languageItem = new MenuItem
            {
                Header = I18n.T("Menu_Language_Header")
            };

            var zhItem = new MenuItem
            {
                Header = I18n.T("Menu_Language_ZhCN"),
                IsCheckable = true,
                IsChecked = I18n.CurrentCulture.Name.Equals("zh-CN", StringComparison.OrdinalIgnoreCase)
            };
            zhItem.Click += (s, e) => I18n.SetLanguage("zh-CN");

            var enItem = new MenuItem
            {
                Header = I18n.T("Menu_Language_EnUS"),
                IsCheckable = true,
                IsChecked = I18n.CurrentCulture.Name.Equals("en-US", StringComparison.OrdinalIgnoreCase)
            };
            enItem.Click += (s, e) => I18n.SetLanguage("en-US");

            languageItem.Items.Add(zhItem);
            languageItem.Items.Add(enItem);
            contextMenu.Items.Add(languageItem);
            
            contextMenu.Items.Add(new Separator());
            
            // 数据导入
            var importItem = new MenuItem
            {
                Header = I18n.T("Menu_Import_Header"),
                ToolTip = I18n.T("Menu_Import_Tooltip")
            };
            importItem.Click += (s, e) => ImportAllData();
            contextMenu.Items.Add(importItem);
            
            // 数据导出
            var exportItem = new MenuItem
            {
                Header = I18n.T("Menu_Export_Header"),
                ToolTip = I18n.T("Menu_Export_Tooltip")
            };
            exportItem.Click += (s, e) => ExportAllData();
            contextMenu.Items.Add(exportItem);
            
            contextMenu.Items.Add(new Separator());
            
            // 关于
            var aboutItem = new MenuItem
            {
                Header = I18n.T("Menu_About_Header"),
                ToolTip = I18n.T("Menu_About_Tooltip")
            };
            aboutItem.Click += (s, e) => ShowAbout();
            contextMenu.Items.Add(aboutItem);
            
            // 显示菜单
            contextMenu.PlacementTarget = SettingsButton;
            contextMenu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;
            contextMenu.IsOpen = true;
        }

        private void CaptureSelectedTaskKnowledge()
        {
            var task = GetSelectedTaskFromAnyQuadrant();
            if (task == null)
            {
                MessageBox.Show(I18n.T("Message_SelectTaskFirst"), I18n.T("Title_Prompt"), MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            if (!task.CompletionTime.HasValue)
            {
                task.CompletionTime = DateTime.Now;
            }

            PersistKnowledgeArtifact(task);
            MessageBox.Show(I18n.T("Message_KnowledgeCaptured"), I18n.T("Title_Done"), MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private ItemGrid GetSelectedTaskFromAnyQuadrant()
        {
            if (task1?.SelectedItem is ItemGrid a) return a;
            if (task2?.SelectedItem is ItemGrid b) return b;
            if (task3?.SelectedItem is ItemGrid c) return c;
            if (task4?.SelectedItem is ItemGrid d) return d;
            return null;
        }

        private void PrimaryFocusButton_Click(object sender, RoutedEventArgs e)
        {
            FocusTaskInBoard(_primaryFocusTask);
        }

        private void ReminderFocusButton_Click(object sender, RoutedEventArgs e)
        {
            FocusTaskInBoard(_reminderFocusTask);
        }

        private void StuckFocusButton_Click(object sender, RoutedEventArgs e)
        {
            FocusTaskInBoard(_stuckFocusTask);
        }

        private void FocusTaskInBoard(ItemGrid task)
        {
            if (task == null)
            {
                return;
            }

            var grid = FindContainingGrid(task);
            if (grid == null)
            {
                return;
            }

            ClearQuadrantSelections();
            grid.SelectedItem = task;
            grid.ScrollIntoView(task);
            grid.Focus();
        }

        private void ClearQuadrantSelections()
        {
            if (task1 != null) task1.SelectedItem = null;
            if (task2 != null) task2.SelectedItem = null;
            if (task3 != null) task3.SelectedItem = null;
            if (task4 != null) task4.SelectedItem = null;
        }

        private DataGrid FindContainingGrid(ItemGrid task)
        {
            if (task == null)
            {
                return null;
            }

            if (task1?.ItemsSource is List<ItemGrid> q1 && q1.Contains(task)) return task1;
            if (task2?.ItemsSource is List<ItemGrid> q2 && q2.Contains(task)) return task2;
            if (task3?.ItemsSource is List<ItemGrid> q3 && q3.Contains(task)) return task3;
            if (task4?.ItemsSource is List<ItemGrid> q4 && q4.Contains(task)) return task4;
            return null;
        }

        private void ImportAllData()
        {
            try
            {
                var openDialog = new Microsoft.Win32.OpenFileDialog
                {
                    Filter = I18n.T("Import_Filter"),
                    DefaultExt = "json"
                };

                if (openDialog.ShowDialog() != true)
                {
                    return;
                }

                string json = File.ReadAllText(openDialog.FileName, Encoding.UTF8);
                var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
                var package = JsonSerializer.Deserialize<DataExportPackage>(json, options);
                if (package == null)
                {
                    MessageBox.Show(I18n.T("Message_ImportParseFailed"), I18n.T("Title_Error"), MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                var confirm = MessageBox.Show(
                    I18n.T("Message_ImportOverwriteConfirm"),
                    I18n.T("Title_ConfirmImport"),
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Warning);
                if (confirm != MessageBoxResult.Yes)
                {
                    return;
                }

                string dataDir = Path.Combine(currentPath, "data");
                Directory.CreateDirectory(dataDir);

                if (package.Tasks != null)
                {
                    WriteTasksFromPackage(package.Tasks, dataDir);
                }

                if (package.LongTermGoals != null)
                {
                    string goalsPath = Path.Combine(dataDir, "long_term_goals.csv");
                    HelperClass.WriteLongTermGoalsCsv(package.LongTermGoals, goalsPath);
                }

                if (package.LearningMilestones != null)
                {
                    ImportLearningMilestones(package.LearningMilestones, dataDir);
                }

                loadDataGridView();
                LoadActiveLongTermGoalAndRefreshDisplay();
                MessageBox.Show(I18n.T("Message_ImportCompleted"), I18n.T("Title_ImportSuccess"), MessageBoxButton.OK, MessageBoxImage.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show(I18n.Tf("Message_OperationFailedFormat", ex.Message), I18n.T("Title_Error"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void ExportAllData()
        {
            try
            {
                var saveDialog = new Microsoft.Win32.SaveFileDialog
                {
                    Filter = I18n.T("Export_Filter"),
                    DefaultExt = "json",
                    FileName = $"TimeTask_Export_{DateTime.Now:yyyyMMdd_HHmmss}.json"
                };

                if (saveDialog.ShowDialog() == true)
                {
                    var package = BuildExportPackage();
                    var options = new JsonSerializerOptions { WriteIndented = true };
                    string json = JsonSerializer.Serialize(package, options);
                    File.WriteAllText(saveDialog.FileName, json, Encoding.UTF8);
                    MessageBox.Show(I18n.T("Message_ExportCompleted"), I18n.T("Title_ExportSuccess"), MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(I18n.Tf("Message_ExportFailedFormat", ex.Message), I18n.T("Title_Error"), MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private DataExportPackage BuildExportPackage()
        {
            string dataDir = Path.Combine(currentPath, "data");
            var package = new DataExportPackage
            {
                ExportedAt = DateTime.Now,
                Tasks = new Dictionary<string, List<ItemGrid>>(),
                LongTermGoals = new List<LongTermGoal>(),
                LearningMilestones = new List<LearningMilestone>()
            };

            package.Tasks["1"] = HelperClass.ReadCsv(Path.Combine(dataDir, "1.csv")) ?? new List<ItemGrid>();
            package.Tasks["2"] = HelperClass.ReadCsv(Path.Combine(dataDir, "2.csv")) ?? new List<ItemGrid>();
            package.Tasks["3"] = HelperClass.ReadCsv(Path.Combine(dataDir, "3.csv")) ?? new List<ItemGrid>();
            package.Tasks["4"] = HelperClass.ReadCsv(Path.Combine(dataDir, "4.csv")) ?? new List<ItemGrid>();

            string goalsPath = Path.Combine(dataDir, "long_term_goals.csv");
            package.LongTermGoals = HelperClass.ReadLongTermGoalsCsv(goalsPath) ?? new List<LongTermGoal>();

            package.LearningMilestones = ReadAllLearningMilestones(dataDir);

            return package;
        }

        private static void WriteTasksFromPackage(Dictionary<string, List<ItemGrid>> tasks, string dataDir)
        {
            List<ItemGrid> GetTasks(string key)
            {
                if (tasks != null && tasks.TryGetValue(key, out var list) && list != null)
                {
                    return list;
                }
                return new List<ItemGrid>();
            }

            HelperClass.WriteCsv(GetTasks("1"), Path.Combine(dataDir, "1.csv"));
            HelperClass.WriteCsv(GetTasks("2"), Path.Combine(dataDir, "2.csv"));
            HelperClass.WriteCsv(GetTasks("3"), Path.Combine(dataDir, "3.csv"));
            HelperClass.WriteCsv(GetTasks("4"), Path.Combine(dataDir, "4.csv"));
        }

        private static List<LearningMilestone> ReadAllLearningMilestones(string dataDir)
        {
            var results = new List<LearningMilestone>();
            if (!Directory.Exists(dataDir))
            {
                return results;
            }

            foreach (var file in Directory.GetFiles(dataDir, "learning_milestones_*.csv"))
            {
                var milestones = HelperClass.ReadLearningMilestonesCsv(file);
                if (milestones != null && milestones.Count > 0)
                {
                    results.AddRange(milestones);
                }
            }

            return results;
        }

        private static void ImportLearningMilestones(List<LearningMilestone> milestones, string dataDir)
        {
            if (!Directory.Exists(dataDir))
            {
                Directory.CreateDirectory(dataDir);
            }

            foreach (var file in Directory.GetFiles(dataDir, "learning_milestones_*.csv"))
            {
                try
                {
                    File.Delete(file);
                }
                catch
                {
                    // Ignore cleanup failures; will overwrite when possible.
                }
            }

            if (milestones == null || milestones.Count == 0)
            {
                return;
            }

            foreach (var group in milestones.GroupBy(m => m.LearningPlanId))
            {
                string filePath = Path.Combine(dataDir, $"learning_milestones_{group.Key}.csv");
                HelperClass.WriteLearningMilestonesCsv(group.ToList(), filePath);
            }
        }
        
        private void TrySetDialogOwner(Window dialog)
        {
            if (dialog == null)
            {
                return;
            }

            try
            {
                if (this.IsLoaded && this.IsVisible)
                {
                    dialog.Owner = this;
                }
            }
            catch (InvalidOperationException ex)
            {
                System.Diagnostics.Debug.WriteLine($"Skip setting dialog owner: {ex.Message}");
            }
        }

        private void OpenLlmSettings()
        {
            LlmSettingsWindow settingsWindow = new LlmSettingsWindow();
            TrySetDialogOwner(settingsWindow); // Set owner only when current window is visible and valid

            // ShowDialog returns a nullable bool (bool?). True if OK/Save, False if Cancel, Null if just closed.
            bool? dialogResult = settingsWindow.ShowDialog();

            if (dialogResult == true) // This implies settings were saved and DialogResult was set to true in LlmSettingsWindow
            {
                // Check if _llmService is null, though it should be initialized in the constructor
                if (_llmService == null)
                {
                    _llmService = LlmService.Create(); // Or handle error appropriately
                    MessageBox.Show("LLM Service was not initialized. It has been initialized now. Please try your operation again.", "Service Re-initialized", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                else
                {
                    // Assuming LlmService will have a public method to reload its config.
                    // This method needs to be added in the next step.
                    _llmService.ReloadConfigAndReinitialize();
                    MessageBox.Show("LLM settings have been updated and the service has been re-initialized.", "Settings Updated", MessageBoxButton.OK, MessageBoxImage.Information);
                }

                // Optionally, you might want to refresh or reload data that depends on LLM service,
                // for example, if LLM is used to process tasks on load.
                // loadDataGridView(); // Consider if this is needed and its implications.
                // For now, just re-initializing the service.

                // Re-initialize sync service with potentially new settings
                if (_syncTimer != null) _syncTimer.Stop(); // Stop existing timer before re-init
                InitializeSyncService();
            }
        }

        private async void LongTermGoalButton_Click(object sender, RoutedEventArgs e)
        {
            SetLongTermGoalWindow goalDialog = new SetLongTermGoalWindow();
            TrySetDialogOwner(goalDialog);

            if (goalDialog.ShowDialog() == true)
            {
                bool isLearningPlan = goalDialog.IsLearningPlan;

                if (isLearningPlan)
                {
                    await HandleLearningPlanCreation(goalDialog);
                }
                else
                {
                    await HandleNormalGoalCreation(goalDialog);
                }
            }
        }

        private async Task HandleNormalGoalCreation(SetLongTermGoalWindow goalDialog)
        {
            string userGoalDescription = goalDialog.GoalDescription;
            string userDuration = goalDialog.Duration;

            if (_llmService == null)
            {
                MessageBox.Show("LLM Service is not available. Cannot decompose goal.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            List<ProposedDailyTask> proposedTasks = null;
            try
            {
                proposedTasks = await _llmService.DecomposeGoalIntoDailyTasksAsync(userGoalDescription, userDuration);
            }
            catch (Exception ex)
            {
                string friendlyError = GetFriendlyErrorMessage(ex.Message);
                MessageBox.Show(friendlyError, "目标分解失败", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            if (proposedTasks == null || !proposedTasks.Any())
            {
                MessageBox.Show(this, "The LLM could not break down this goal into daily tasks. Please try a different goal or phrasing.", "Goal Decomposition Failed", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            ConfirmGoalTasksWindow confirmDialog = new ConfirmGoalTasksWindow(proposedTasks);
            TrySetDialogOwner(confirmDialog);

            if (confirmDialog.ShowDialog() == true && confirmDialog.SelectedTasks.Any())
            {
                var newLongTermGoal = new LongTermGoal
                {
                    Description = userGoalDescription,
                    TotalDuration = userDuration,
                    IsActive = true,
                    IsLearningPlan = false
                };

                string longTermGoalsCsvPath = Path.Combine(currentPath, "data", "long_term_goals.csv");
                List<LongTermGoal> allLongTermGoals = HelperClass.ReadLongTermGoalsCsv(longTermGoalsCsvPath);

                foreach (var goal in allLongTermGoals)
                {
                    goal.IsActive = false;
                }

                var existingGoal = allLongTermGoals.FirstOrDefault(g => g.Id == newLongTermGoal.Id);
                if (existingGoal != null)
                {
                    allLongTermGoals.Remove(existingGoal);
                }
                allLongTermGoals.Add(newLongTermGoal);
                HelperClass.WriteLongTermGoalsCsv(allLongTermGoals, longTermGoalsCsvPath);
                _behaviorObserver?.RecordGoalOperation("create_long_term_goal", newLongTermGoal.Description, newLongTermGoal.Id);

                int tasksProcessedCount = 0;
                var tasksByQuadrant = confirmDialog.SelectedTasks.GroupBy(taskToAdd =>
                {
                    string quadrant = taskToAdd.Quadrant?.ToLowerInvariant();
                    if (quadrant == "important & urgent") return "1";
                    if (quadrant == "important & not urgent") return "2";
                    if (quadrant == "not important & urgent") return "3";
                    if (quadrant == "not important & not urgent") return "4";
                    return "1";
                });

                foreach (var group in tasksByQuadrant)
                {
                    string targetCsvNumber = group.Key;
                    string quadrantCsvPath = Path.Combine(currentPath, "data", $"{targetCsvNumber}.csv");
                    List<ItemGrid> quadrantTasks = HelperClass.ReadCsv(quadrantCsvPath);
                    if (quadrantTasks == null) quadrantTasks = new List<ItemGrid>();

                    foreach (var taskToAdd in group)
                    {
                        string displayTaskDescription = string.IsNullOrWhiteSpace(taskToAdd.TaskDescription) ? "(Task description not provided)" : taskToAdd.TaskDescription;
                        string displayEstimatedTime = !string.IsNullOrWhiteSpace(taskToAdd.EstimatedTime) ? $" ({taskToAdd.EstimatedTime})" : "";

                        int dayNumber = taskToAdd.Day > 0 ? taskToAdd.Day : 0;

                        var newItem = new ItemGrid
                        {
                            Task = displayTaskDescription + displayEstimatedTime,
                            IsActive = true,
                            Result = string.Empty,
                            CreatedDate = DateTime.Now,
                            LastModifiedDate = DateTime.Now,
                            LastProgressDate = DateTime.Now,
                            LastInteractionDate = DateTime.Now,
                            LongTermGoalId = newLongTermGoal.Id,
                            OriginalScheduledDay = dayNumber,
                            IsActiveInQuadrant = false
                        };

                        switch (taskToAdd.Quadrant?.ToLowerInvariant())
                        {
                            case "important & urgent":
                                newItem.Importance = "High"; newItem.Urgency = "High";
                                break;
                            case "important & not urgent":
                                newItem.Importance = "High"; newItem.Urgency = "Low";
                                break;
                            case "not important & urgent":
                                newItem.Importance = "Low"; newItem.Urgency = "High";
                                break;
                            case "not important & not urgent":
                                newItem.Importance = "Low"; newItem.Urgency = "Low";
                                break;
                            default:
                                newItem.Importance = "High"; newItem.Urgency = "High";
                                break;
                        }
                        quadrantTasks.Add(newItem);
                        TrackTaskInteraction(newItem, "progress");
                        RecordTaskProgressProfile(newItem, "goal_plan_create");
                        tasksProcessedCount++;
                    }
                    HelperClass.WriteCsv(quadrantTasks, quadrantCsvPath);
                }

                if (tasksProcessedCount > 0)
                {
                    MessageBox.Show($"{tasksProcessedCount} sub-task(s) for your long-term goal '{newLongTermGoal.Description}' have been planned. You can manage and activate them from the main screen.", "Long-Term Goal Set", MessageBoxButton.OK, MessageBoxImage.Information);
                    loadDataGridView();
                }
            }
        }

        private async Task HandleLearningPlanCreation(SetLongTermGoalWindow goalDialog)
        {
            string goal = goalDialog.GoalDescription;
            string duration = goalDialog.Duration;
            string subject = goal.Split(new[] { '、', '，', ',', ' ', '的' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? goal;
            DateTime? startDate = DateTime.Now;

            if (_llmService == null)
            {
                MessageBox.Show("LLM Service is not available. Cannot decompose learning plan.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            var loadingWindow = new Window
            {
                Title = "正在生成学习计划",
                Width = 400,
                Height = 150,
                WindowStartupLocation = WindowStartupLocation.CenterOwner,
                Owner = this,
                ResizeMode = ResizeMode.NoResize,
                WindowStyle = WindowStyle.SingleBorderWindow,
                Content = new StackPanel
                {
                    Margin = new System.Windows.Thickness(20),
                    Children =
                    {
                        new TextBlock
                        {
                            Text = "📚 正在为您生成学习计划...",
                            FontSize = 16,
                            FontWeight = FontWeights.Bold,
                            Margin = new System.Windows.Thickness(0, 0, 0, 10)
                        },
                        new TextBlock
                        {
                            Text = $"目标：{goal}\n时长：{duration}",
                            FontSize = 12,
                            Foreground = System.Windows.Media.Brushes.Gray
                        }
                    }
                }
            };

            loadingWindow.Show();

            List<LlmLearningMilestone> proposedMilestones = null;
            try
            {
                proposedMilestones = await _llmService.DecomposeLearningPlanIntoMilestonesAsync(subject, goal, duration);
            }
            catch (Exception ex)
            {
                loadingWindow.Close();
                string friendlyError = GetFriendlyErrorMessage(ex.Message);
                MessageBox.Show(friendlyError, "学习计划生成失败", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            loadingWindow.Close();

            if (proposedMilestones == null || !proposedMilestones.Any())
            {
                MessageBox.Show(this, "The LLM could not break down this learning plan into milestones. Please try a different plan or phrasing.", "Learning Plan Decomposition Failed", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            var newLearningPlan = new LongTermGoal
            {
                Id = Guid.NewGuid().ToString(),
                Description = goal,
                TotalDuration = duration,
                CreationDate = DateTime.Now,
                IsActive = true,
                IsLearningPlan = true,
                Subject = subject,
                StartDate = startDate,
                TotalStages = proposedMilestones.Count,
                CompletedStages = 0
            };

            string longTermGoalsCsvPath = Path.Combine(currentPath, "data", "long_term_goals.csv");
            List<LongTermGoal> allLongTermGoals = HelperClass.ReadLongTermGoalsCsv(longTermGoalsCsvPath);

            foreach (var plan in allLongTermGoals)
            {
                plan.IsActive = false;
            }
            allLongTermGoals.Add(newLearningPlan);
            HelperClass.WriteLongTermGoalsCsv(allLongTermGoals, longTermGoalsCsvPath);
            _behaviorObserver?.RecordGoalOperation("create_learning_plan", newLearningPlan.Description, newLearningPlan.Id);

            var convertedMilestones = new List<LearningMilestone>();
            foreach (var llmMilestone in proposedMilestones)
            {
                convertedMilestones.Add(new LearningMilestone
                {
                    Id = Guid.NewGuid().ToString(),
                    LearningPlanId = newLearningPlan.Id,
                    StageName = llmMilestone.Title,
                    Description = llmMilestone.Description,
                    StageNumber = llmMilestone.Stage,
                    TargetDate = null,
                    IsCompleted = false,
                    CompletedDate = null,
                    AssociatedTaskId = null
                });
            }

            string milestonesCsvPath = Path.Combine(currentPath, "data", $"learning_milestones_{newLearningPlan.Id}.csv");
            HelperClass.WriteLearningMilestonesCsv(convertedMilestones, milestonesCsvPath);

            LoadActiveLongTermGoalAndRefreshDisplay();

            var learningPlanManager = new LearningPlanManagerWindow(newLearningPlan, Path.Combine(currentPath, "data"));
            learningPlanManager.Owner = this;
            learningPlanManager.ShowDialog();
        }

        private string GetFriendlyErrorMessage(string errorMessage)
        {
            if (string.IsNullOrWhiteSpace(errorMessage))
                return "未知错误";

            if (errorMessage.Contains("余额不足或无可用资源包"))
                return "API余额不足或无可用资源包，请充值后再试。";

            if (errorMessage.Contains("认证失败") || errorMessage.Contains("401") || errorMessage.Contains("403"))
                return "API认证失败，请检查您的API密钥设置。";

            if (errorMessage.Contains("请求过于频繁") || errorMessage.Contains("429"))
                return "请求过于频繁，请稍后再试。";

            if (errorMessage.Contains("Error from Zhipu AI"))
                return $"智谱AI API错误: {errorMessage}";

            if (errorMessage.Contains("Error from LLM"))
                return $"LLM API错误: {errorMessage}";

            return errorMessage;
        }

        private void OpenReminderSettings()
        {
            ReminderSettingsWindow settingsWindow = new ReminderSettingsWindow();
            settingsWindow.Owner = this;
            settingsWindow.ShowDialog();
        }

        private void OpenSkillManagement()
        {
            var window = new SkillManagementWindow
            {
                Owner = this
            };
            window.ShowDialog();
        }

        private void OpenStrategyDashboard()
        {
            var window = new StrategyDashboardWindow(Path.Combine(currentPath, "data"))
            {
                Owner = this
            };
            window.ShowDialog();
        }

        private void ShowAbout()
        {
            Version version = Assembly.GetExecutingAssembly().GetName().Version ?? new Version(1, 0, 0, 0);
            string displayVersion = version.Build > 0 ? version.ToString(3) : version.ToString(2);
            MessageBox.Show(I18n.Tf("About_Text", displayVersion), I18n.T("Title_About"), MessageBoxButton.OK, MessageBoxImage.Information);
        }
    }
}

namespace TimeTask // For InverseBooleanConverter
{
    [System.Windows.Data.ValueConversion(typeof(bool), typeof(bool))]
    public class InverseBooleanConverter : System.Windows.Data.IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (targetType != typeof(bool) && targetType != typeof(bool?))
                throw new InvalidOperationException("The target must be a boolean");

            return !(bool?)value;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (targetType != typeof(bool) && targetType != typeof(bool?))
                throw new InvalidOperationException("The target must be a boolean");

            return !(bool?)value;
        }
    }
}

namespace TimeTask // Ensure it's within the same namespace or accessible
{
    public class LongTermGoal
    {
        public string Id { get; set; }
        public string Description { get; set; }
        public string TotalDuration { get; set; }
        public DateTime CreationDate { get; set; }
        public bool IsActive { get; set; }
        public bool IsLearningPlan { get; set; }
        public string Subject { get; set; }
        public DateTime? StartDate { get; set; }
        public DateTime? EndDate { get; set; }
        public DateTime LastReviewDate { get; set; }
        public int TotalStages { get; set; }
        public int CompletedStages { get; set; }

        public LongTermGoal()
        {
            Id = Guid.NewGuid().ToString();
            CreationDate = DateTime.Now;
            LastReviewDate = DateTime.Now;
            IsActive = false;
            IsLearningPlan = false;
            TotalStages = 0;
            CompletedStages = 0;
        }

        public double ProgressPercentage
        {
            get
            {
                if (!IsLearningPlan || TotalStages == 0) return 0;
                return (double)CompletedStages / TotalStages * 100;
            }
        }
    }

    public class LearningPlan
    {
        public string Id { get; set; }
        public string Subject { get; set; }
        public string Goal { get; set; }
        public string Duration { get; set; }
        public DateTime CreationDate { get; set; }
        public DateTime? StartDate { get; set; }
        public DateTime? EndDate { get; set; }
        public bool IsActive { get; set; }
        public int TotalStages { get; set; }
        public int CompletedStages { get; set; }

        public LearningPlan()
        {
            Id = Guid.NewGuid().ToString();
            CreationDate = DateTime.Now;
            IsActive = false;
            TotalStages = 0;
            CompletedStages = 0;
        }

        public double ProgressPercentage
        {
            get
            {
                if (TotalStages == 0) return 0;
                return (double)CompletedStages / TotalStages * 100;
            }
        }
    }

    public class LearningMilestone
    {
        public string Id { get; set; }
        public string LearningPlanId { get; set; }
        public string StageName { get; set; }
        public string Description { get; set; }
        public int StageNumber { get; set; }
        public DateTime? TargetDate { get; set; }
        public bool IsCompleted { get; set; }
        public DateTime? CompletedDate { get; set; }
        public string AssociatedTaskId { get; set; }

        public LearningMilestone()
        {
            Id = Guid.NewGuid().ToString();
            IsCompleted = false;
        }
    }

    public class DataExportPackage
    {
        public int Version { get; set; } = 1;
        public DateTime ExportedAt { get; set; } = DateTime.Now;
        public Dictionary<string, List<ItemGrid>> Tasks { get; set; }
        public List<LongTermGoal> LongTermGoals { get; set; }
        public List<LearningMilestone> LearningMilestones { get; set; }
    }
}

// Add this class within the TimeTask namespace, but outside the MainWindow class.
// The namespace TimeTask is already declared above, so we are effectively adding to it.
// No need to redeclare "namespace TimeTask" if the class is meant to be in the same one.
// However, the original file has two namespace blocks. Let's keep that structure.
namespace TimeTask
{
    public class TaskWithReminderIndicatorConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (values == null || values.Length < 2)
                return string.Empty;

            string taskDescription = values[0] as string ?? string.Empty;
            DateTime? reminderTime = null;

            if (values[1] != null && values[1] != DependencyProperty.UnsetValue)
            {
                reminderTime = values[1] as DateTime?;
            }

            if (reminderTime.HasValue)
            {
                return $"{taskDescription} ⏰";
            }
            return taskDescription;
        }

        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    public class IsGreaterThanConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is int intValue && parameter is string paramString && int.TryParse(paramString, out int compareToValue))
            {
                return intValue > compareToValue;
            }
            return false;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    public class NonEmptyStringToVisibilityConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var text = value as string;
            return string.IsNullOrWhiteSpace(text) ? Visibility.Collapsed : Visibility.Visible;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotSupportedException();
        }
    }
}