using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Linq;
using Microsoft.Extensions.Configuration;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Serilog;
using Serilog.Events;
using Serilog.Extensions.Logging;
using ILogger = Microsoft.Extensions.Logging.ILogger;

namespace JiShe.CollectBus.PluginFileWatcher
{
    // 删除配置类的定义

    class Program
    {
        // 配置对象，从appsettings.json加载
        private static FileMonitorConfig _config = new FileMonitorConfig();

        // 全局计数器和动态配置参数
        private static long _totalEventsProcessed = 0;

        // 监控器健康状态追踪
        private static DateTime _lastEventTime = DateTime.UtcNow;
        private static int _watcherRestartAttempts = 0;
        private static FileSystemWatcher _activeWatcher = null;

        // 事件存储和回放
        private static EventStorage _eventStorage = null;
        private static EventReplaySession _currentReplaySession = null;
        private static ILogger _logger = NullLogger.Instance;

        static async Task Main(string[] args)
        {
            Console.OutputEncoding = System.Text.Encoding.UTF8;

            // 检查是否以数据库工具模式运行
            if (args.Length > 0 && args[0].Equals("db", StringComparison.OrdinalIgnoreCase))
            {
                // 运行数据库工具
                await RunDatabaseUtilityAsync(args.Skip(1).ToArray());
                return;
            }

            // 加载配置文件
            LoadConfiguration();

            // 配置Serilog
            ConfigureSerilog();

            // 初始化日志记录器
            _logger = new SerilogLoggerFactory().CreateLogger("FileMonitor");

            Log.Information("高性能文件监控程序启动中...");

            // 初始化事件存储
            if (_config.EventStorage.EnableEventStorage)
            {
                _eventStorage = new EventStorage(_config, _logger);
                Log.Information("事件存储已启用，存储目录：{Directory}", _config.EventStorage.StorageDirectory);
            }

            // 打印配置信息
            LogConfiguration();

            // 获取监控路径：优先命令行参数，其次配置文件，最后使用当前目录
            string pathToMonitor = args.Length > 0 ? args[0] :
                                   !string.IsNullOrEmpty(_config.General.DefaultMonitorPath) ?
                                   _config.General.DefaultMonitorPath : Directory.GetCurrentDirectory();

            // 命令行参数可以覆盖配置文件
            if (args.Length > 1 && args[1].Equals("--no-filter", StringComparison.OrdinalIgnoreCase))
            {
                _config.General.EnableFileFiltering = false;
                Log.Information("通过命令行参数禁用文件类型过滤，将监控所有文件");
            }
            else if (_config.General.EnableFileFiltering)
            {
                Log.Information("已启用文件类型过滤，仅监控以下类型: {Extensions}", string.Join(", ", _config.FileFilters.AllowedExtensions));
            }

            if (!Directory.Exists(pathToMonitor))
            {
                Log.Warning("错误：监控目录 '{Path}' 不存在。", pathToMonitor);
                Log.Information("尝试创建该目录...");

                try
                {
                    Directory.CreateDirectory(pathToMonitor);
                    Log.Information("已成功创建目录: {Path}", pathToMonitor);
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "创建目录失败: {Message}", ex.Message);
                    Log.Information("将使用当前目录作为监控路径。");
                    pathToMonitor = Directory.GetCurrentDirectory();
                }
            }

            Log.Information("开始监控目录: {Path}", pathToMonitor);
            Log.Information("按 'Q' 退出程序，按 'R' 重新加载配置，按 'H' 检查监控器健康状态。");
            if (_config.EventStorage.EnableEventStorage && _config.EventStorage.EnableEventReplay)
            {
                Log.Information("按 'P' 开始/暂停回放，按 'S' 停止回放，按 'B' 查询事件。");
            }

            // 创建一个容量由配置文件指定的有界通道
            var channel = Channel.CreateBounded<FileSystemEventArgs>(new BoundedChannelOptions(_config.Performance.ChannelCapacity)
            {
                FullMode = BoundedChannelFullMode.DropOldest // 当通道满时丢弃旧事件
            });

            using var cts = new CancellationTokenSource();

            // 启动内存监控
            var memoryMonitorTask = StartMemoryMonitorAsync(cts.Token);

            // 启动文件监控器
            var monitorTask = StartFileMonitorAsync(pathToMonitor, channel.Writer, cts.Token);

            // 启动健康监控任务
            var healthMonitorTask = _config.Robustness.EnableAutoRecovery ?
                StartWatcherHealthMonitorAsync(pathToMonitor, channel.Writer, cts.Token) : Task.CompletedTask;

            // 启动事件处理器
            var processorTask = ProcessEventsAsync(channel.Reader, cts.Token);

            // 等待用户按下键退出或重新加载配置
            bool needRestart = false;
            while (true)
            {
                var key = Console.ReadKey(true).Key;
                if (key == ConsoleKey.Q)
                {
                    break; // 退出循环
                }
                else if (key == ConsoleKey.R)
                {
                    Log.Information("正在重新加载配置...");
                    LoadConfiguration();
                    // 重新配置Serilog
                    ConfigureSerilog();
                    LogConfiguration();
                    Log.Information("配置已重新加载，部分配置需要重启程序才能生效。");
                }
                else if (key == ConsoleKey.H)
                {
                    // 手动检查监控器健康状态
                    bool isHealthy = _activeWatcher != null &&
                                     FileWatcherUtils.IsWatcherHealthy(_activeWatcher, _lastEventTime, _config.Robustness);
                    Log.Information("监控器健康状态: {Status}", (isHealthy ? "正常" : "异常"));
                    Log.Information("上次事件时间: {Time}", _lastEventTime);
                    Log.Information("重启次数: {Count}/{MaxCount}", _watcherRestartAttempts, _config.Robustness.MaxRestartAttempts);
                    Log.Information("已处理事件总数: {Count}", _totalEventsProcessed);
                }
                else if (key == ConsoleKey.P && _config.EventStorage.EnableEventStorage && _config.EventStorage.EnableEventReplay)
                {
                    await HandleEventReplayToggleAsync();
                }
                else if (key == ConsoleKey.S && _config.EventStorage.EnableEventStorage && _config.EventStorage.EnableEventReplay)
                {
                    await StopReplayAsync();
                }
                else if (key == ConsoleKey.B && _config.EventStorage.EnableEventStorage)
                {
                    await QueryEventsAsync();
                }

                await Task.Delay(100);
            }

            // 取消所有任务
            cts.Cancel();

            // 停止回放（如果正在进行）
            await StopReplayAsync();

            // 释放事件存储
            _eventStorage?.Dispose();

            try
            {
                var tasks = new List<Task> { monitorTask, processorTask, memoryMonitorTask };
                if (_config.Robustness.EnableAutoRecovery)
                {
                    tasks.Add(healthMonitorTask);
                }

                await Task.WhenAll(tasks);
            }
            catch (OperationCanceledException)
            {
                Log.Information("程序已正常退出。");
            }

            // 关闭Serilog
            Log.CloseAndFlush();
        }

        // 配置Serilog
        private static void ConfigureSerilog()
        {
            var configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .Build();

            var loggerConfig = new LoggerConfiguration()
                .ReadFrom.Configuration(configuration);

            // 根据配置设置最小日志级别
            LogEventLevel minimumLevel = LogEventLevel.Information;
            if (!string.IsNullOrEmpty(_config.Logging?.LogLevel))
            {
                switch (_config.Logging.LogLevel.ToLower())
                {
                    case "verbose":
                        minimumLevel = LogEventLevel.Verbose;
                        break;
                    case "debug":
                        minimumLevel = LogEventLevel.Debug;
                        break;
                    case "information":
                        minimumLevel = LogEventLevel.Information;
                        break;
                    case "warning":
                        minimumLevel = LogEventLevel.Warning;
                        break;
                    case "error":
                        minimumLevel = LogEventLevel.Error;
                        break;
                    case "fatal":
                        minimumLevel = LogEventLevel.Fatal;
                        break;
                }
            }

            // 如果配置文件中没有Serilog节，使用默认配置
            var hasConfig = configuration.GetSection("Serilog").Exists();
            if (!hasConfig)
            {
                loggerConfig
                    .MinimumLevel.Is(minimumLevel)
                    .WriteTo.Console(
                        outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff}] [{Level:u3}] {Message:lj}{NewLine}{Exception}"
                    )
                    .WriteTo.File(
                        Path.Combine(_config.Logging?.LogDirectory ?? "Logs", "filemonitor-.log"),
                        rollingInterval: RollingInterval.Day,
                        outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff}] [{Level:u3}] {Message:lj}{NewLine}{Exception}",
                        retainedFileCountLimit: _config.Logging?.RetainedLogDays ?? 30
                    );
            }

            Log.Logger = loggerConfig.CreateLogger();
        }

        // 查询事件
        private static async Task QueryEventsAsync()
        {
            if (_eventStorage == null)
            {
                Log.Warning("事件存储未启用");
                return;
            }

            try
            {
                Log.Information("\n================ 事件查询 ================");
                Console.WriteLine("请输入查询参数，直接回车使用默认值");

                // 收集查询参数
                var queryParams = new EventQueryParams();

                Console.Write("开始时间 (yyyy-MM-dd HH:mm:ss)，默认24小时前: ");
                string startTimeStr = Console.ReadLine();
                if (!string.IsNullOrEmpty(startTimeStr))
                {
                    if (DateTime.TryParse(startTimeStr, out var startTime))
                    {
                        queryParams.StartTime = startTime;
                    }
                    else
                    {
                        Log.Warning("无效的日期格式，使用默认值");
                        queryParams.StartTime = DateTime.Now.AddDays(-1);
                    }
                }
                else
                {
                    queryParams.StartTime = DateTime.Now.AddDays(-1);
                }

                Console.Write("结束时间 (yyyy-MM-dd HH:mm:ss)，默认当前时间: ");
                string endTimeStr = Console.ReadLine();
                if (!string.IsNullOrEmpty(endTimeStr))
                {
                    if (DateTime.TryParse(endTimeStr, out var endTime))
                    {
                        queryParams.EndTime = endTime;
                    }
                    else
                    {
                        Log.Warning("无效的日期格式，使用默认值");
                    }
                }

                Console.Write("事件类型 (Created, Modified, Deleted, Renamed, All)，默认All: ");
                string eventTypeStr = Console.ReadLine();
                if (!string.IsNullOrEmpty(eventTypeStr) && eventTypeStr.ToLower() != "all")
                {
                    if (Enum.TryParse<FileEventType>(eventTypeStr, true, out var eventType))
                    {
                        queryParams.EventType = eventType;
                    }
                    else
                    {
                        Log.Warning("无效的事件类型，使用默认值All");
                    }
                }

                Console.Write("路径过滤 (包含此文本的路径)，默认无: ");
                string pathFilter = Console.ReadLine();
                if (!string.IsNullOrEmpty(pathFilter))
                {
                    queryParams.PathFilter = pathFilter;
                }

                Console.Write("文件扩展名过滤 (.txt, .exe等)，默认无: ");
                string extensionFilter = Console.ReadLine();
                if (!string.IsNullOrEmpty(extensionFilter))
                {
                    queryParams.ExtensionFilter = extensionFilter;
                }

                Console.Write("每页显示数量，默认20: ");
                string pageSizeStr = Console.ReadLine();
                if (!string.IsNullOrEmpty(pageSizeStr) && int.TryParse(pageSizeStr, out var pageSize))
                {
                    queryParams.PageSize = pageSize;
                }
                else
                {
                    queryParams.PageSize = 20;
                }

                // 执行查询
                var result = await _eventStorage.QueryEventsAsync(queryParams);

                Log.Information("查询结果 (共{Count}条记录)：", result.TotalCount);
                Log.Information("时间范围: {StartTime} 至 {EndTime}", result.StartTime, result.EndTime);
                Console.WriteLine("---------------------------------------------");

                if (result.Events.Count == 0)
                {
                    Log.Warning("未找到符合条件的事件");
                }
                else
                {
                    foreach (var evt in result.Events)
                    {
                        string eventType = evt.EventType.ToString();
                        string timeStr = evt.Timestamp.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss.fff");

                        Console.WriteLine($"[{timeStr}] [{eventType}] {evt.FileName}");
                        Console.WriteLine($"  路径: {evt.Directory}");

                        if (evt.EventType == FileEventType.Renamed && !string.IsNullOrEmpty(evt.OldFileName))
                        {
                            Console.WriteLine($"  原名称: {evt.OldFileName}");
                        }

                        Console.WriteLine();
                    }

                    if (result.HasMore)
                    {
                        Log.Warning("... 还有更多记录未显示 ...");
                    }
                }

                // 询问是否开始回放
                if (result.Events.Count > 0 && _config.EventStorage.EnableEventReplay)
                {
                    Console.Write("\n是否要回放这些事件? (Y/N): ");
                    string replayAnswer = Console.ReadLine();
                    if (!string.IsNullOrEmpty(replayAnswer) && replayAnswer.ToUpper().StartsWith("Y"))
                    {
                        await StartReplayAsync(queryParams);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "查询事件时出错: {Message}", ex.Message);
            }

            Console.WriteLine("=============================================\n");
        }

        // 处理回放切换（开始/暂停）
        private static async Task HandleEventReplayToggleAsync()
        {
            if (_eventStorage == null) return;

            try
            {
                if (_currentReplaySession == null)
                {
                    // 如果没有活动的回放会话，创建一个简单的查询参数并开始回放
                    var queryParams = new EventQueryParams
                    {
                        StartTime = DateTime.Now.AddHours(-1),
                        PageSize = 1000
                    };

                    await StartReplayAsync(queryParams);
                }
                else if (_currentReplaySession.IsPaused)
                {
                    // 恢复回放
                    await _currentReplaySession.ResumeAsync();
                    Log.Information("已恢复事件回放");
                }
                else
                {
                    // 暂停回放
                    await _currentReplaySession.PauseAsync();
                    Log.Information("已暂停事件回放");
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "处理回放时出错: {Message}", ex.Message);
            }
        }

        // 开始回放
        private static async Task StartReplayAsync(EventQueryParams queryParams)
        {
            if (_eventStorage == null || !_config.EventStorage.EnableEventReplay) return;

            try
            {
                // 停止现有回放
                await StopReplayAsync();

                // 创建回放处理器
                Func<FileEvent, Task> replayHandler = async (e) =>
                {
                    // 在控制台上显示回放的事件
                    string eventType = e.EventType.ToString();
                    string timeStr = e.Timestamp.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss.fff");

                    Log.Information("[回放] [{Time}] [{Type}] {FileName}", timeStr, eventType, e.FileName);

                    if (_config.Logging.LogFileEventDetails)
                    {
                        Log.Debug("  路径: {Path}", e.Directory);

                        if (e.EventType == FileEventType.Renamed && !string.IsNullOrEmpty(e.OldFileName))
                        {
                            Log.Debug("  原名称: {OldName}", e.OldFileName);
                        }
                    }

                    // 这里可以添加实际的文件操作，比如创建、删除文件等
                    // 但在此示例中，我们只是显示事件而不执行实际操作

                    await Task.CompletedTask;
                };

                // 开始回放会话
                _currentReplaySession = await _eventStorage.StartReplayAsync(
                    queryParams,
                    replayHandler,
                    CancellationToken.None);

                // 如果会话创建成功，开始回放
                if (_currentReplaySession != null)
                {
                    await _currentReplaySession.StartAsync();
                    Log.Information("开始回放事件，共 {Count} 个事件", _currentReplaySession.TotalEvents);
                    Log.Information("回放速度: {Speed}", (_config.EventStorage.ReplaySpeedFactor > 1 ?
                        $"{_config.EventStorage.ReplaySpeedFactor}x (加速)" :
                        $"{_config.EventStorage.ReplaySpeedFactor}x (减速)"));
                }
                else
                {
                    Log.Warning("未找到符合条件的事件，回放未开始");
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "开始回放时出错: {Message}", ex.Message);
            }
        }

        // 停止回放
        private static async Task StopReplayAsync()
        {
            if (_currentReplaySession != null)
            {
                try
                {
                    await _currentReplaySession.StopAsync();
                    Log.Information("已停止事件回放");

                    // 输出回放统计
                    Log.Information("回放统计: 共处理 {Processed}/{Total} 个事件",
                        _currentReplaySession.ProcessedEvents,
                        _currentReplaySession.TotalEvents);

                    TimeSpan duration = (_currentReplaySession.EndTime ?? DateTime.Now) - _currentReplaySession.StartTime;
                    Log.Information("回放持续时间: {Duration:F1} 秒", duration.TotalSeconds);
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "停止回放时出错: {Message}", ex.Message);
                }
                finally
                {
                    _currentReplaySession.Dispose();
                    _currentReplaySession = null;
                }
            }
        }

        // 加载配置文件
        private static void LoadConfiguration()
        {
            try
            {
                // 检查配置文件是否存在
                string configPath = Path.Combine(Directory.GetCurrentDirectory(), "appsettings.json");
                if (!File.Exists(configPath))
                {
                    Log.Warning("配置文件不存在，使用默认配置。");

                    // 使用默认配置
                    _config = new FileMonitorConfig
                    {
                        General = new GeneralConfig
                        {
                            EnableFileFiltering = true,
                            MemoryMonitorIntervalMinutes = 1,
                            DefaultMonitorPath = Path.Combine(Directory.GetCurrentDirectory(), "MonitorFiles")
                        },
                        FileFilters = new FileFiltersConfig
                        {
                            AllowedExtensions = new[] { ".dll" },
                            ExcludedDirectories = new[] { "bin", "obj", "node_modules" },
                            IncludeSubdirectories = true
                        },
                        Performance = new PerformanceConfig
                        {
                            MemoryCleanupThreshold = 5000,
                            ChannelCapacity = 1000,
                            EventDebounceTimeSeconds = 3,
                            MaxDictionarySize = 10000,
                            CleanupIntervalSeconds = 5,
                            ProcessingDelayMs = 5
                        },
                        Robustness = new RobustnessConfig
                        {
                            EnableAutoRecovery = true,
                            WatcherHealthCheckIntervalSeconds = 30,
                            WatcherTimeoutSeconds = 60,
                            MaxRestartAttempts = 3,
                            RestartDelaySeconds = 5,
                            EnableFileLockDetection = true,
                            LockedFileStrategy = "Retry",
                            FileLockRetryCount = 3,
                            FileLockRetryDelayMs = 500
                        },
                        NotifyFilters = new List<string> { "LastWrite", "FileName", "DirectoryName", "CreationTime" },
                        EventStorage = new EventStorageConfig
                        {
                            EnableEventStorage = false,
                            StorageDirectory = Path.Combine(Directory.GetCurrentDirectory(), "EventStorage"),
                            EnableEventReplay = false,
                            ReplaySpeedFactor = 1
                        },
                        Logging = new LoggingConfig
                        {
                            LogLevel = "Information",
                            LogFileEventDetails = false,
                            RetainedLogDays = 30,
                            LogDirectory = "Logs"
                        }
                    };

                    return;
                }

                var builder = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

                var configuration = builder.Build();

                // 绑定配置到对象
                var config = new FileMonitorConfig();
                configuration.GetSection("FileMonitorConfig").Bind(config);

                // 更新全局配置
                _config = config;
            }
            catch (Exception ex)
            {
                Log.Error(ex, "加载配置文件失败: {Message}", ex.Message);
                Log.Warning("将使用默认配置。");

                // 使用默认配置
                _config = new FileMonitorConfig
                {
                    General = new GeneralConfig
                    {
                        EnableFileFiltering = true,
                        MemoryMonitorIntervalMinutes = 1,
                        DefaultMonitorPath = Path.Combine(Directory.GetCurrentDirectory(), "MonitorFiles")
                    },
                    FileFilters = new FileFiltersConfig
                    {
                        AllowedExtensions = new[] { ".dll" },
                        ExcludedDirectories = new[] { "bin", "obj", "node_modules" },
                        IncludeSubdirectories = true
                    },
                    Performance = new PerformanceConfig
                    {
                        MemoryCleanupThreshold = 5000,
                        ChannelCapacity = 1000,
                        EventDebounceTimeSeconds = 3,
                        MaxDictionarySize = 10000,
                        CleanupIntervalSeconds = 5,
                        ProcessingDelayMs = 5
                    },
                    Robustness = new RobustnessConfig
                    {
                        EnableAutoRecovery = true,
                        WatcherHealthCheckIntervalSeconds = 30,
                        WatcherTimeoutSeconds = 60,
                        MaxRestartAttempts = 3,
                        RestartDelaySeconds = 5,
                        EnableFileLockDetection = true,
                        LockedFileStrategy = "Retry",
                        FileLockRetryCount = 3,
                        FileLockRetryDelayMs = 500
                    },
                    NotifyFilters = new List<string> { "LastWrite", "FileName", "DirectoryName", "CreationTime" },
                    EventStorage = new EventStorageConfig
                    {
                        EnableEventStorage = false,
                        StorageDirectory = Path.Combine(Directory.GetCurrentDirectory(), "EventStorage"),
                        EnableEventReplay = false,
                        ReplaySpeedFactor = 1
                    },
                    Logging = new LoggingConfig
                    {
                        LogLevel = "Information",
                        LogFileEventDetails = false,
                        RetainedLogDays = 30,
                        LogDirectory = "Logs"
                    }
                };
            }
        }

        // 打印当前配置信息
        private static void LogConfiguration()
        {
            Log.Information("当前配置信息:");
            Log.Information("  默认监控路径: {Path}", _config.General.DefaultMonitorPath);
            Log.Information("  文件过滤: {Status}", (_config.General.EnableFileFiltering ? "启用" : "禁用"));
            if (_config.General.EnableFileFiltering)
            {
                Log.Information("  监控文件类型: {Types}", string.Join(", ", _config.FileFilters.AllowedExtensions));
                Log.Information("  排除目录: {Dirs}", string.Join(", ", _config.FileFilters.ExcludedDirectories));
            }
            Log.Information("  内存监控间隔: {Minutes}分钟", _config.General.MemoryMonitorIntervalMinutes);
            Log.Information("  内存清理阈值: 每{Threshold}个事件", _config.Performance.MemoryCleanupThreshold);
            Log.Information("  通道容量: {Capacity}", _config.Performance.ChannelCapacity);
            Log.Information("  事件去抖时间: {Seconds}秒", _config.Performance.EventDebounceTimeSeconds);
            Log.Information("  自动恢复: {Status}", (_config.Robustness.EnableAutoRecovery ? "启用" : "禁用"));
            Log.Information("  文件锁检测: {Status}", (_config.Robustness.EnableFileLockDetection ? "启用" : "禁用"));
            if (_config.Robustness.EnableFileLockDetection)
            {
                Log.Information("  锁定文件策略: {Strategy}", _config.Robustness.LockedFileStrategy);
            }
            Log.Information("  日志级别: {Level}", _config.Logging?.LogLevel ?? "Information");
        }

        // 检查文件是否应该被处理的方法
        private static bool ShouldProcessFile(string filePath)
        {
            if (!_config.General.EnableFileFiltering)
                return true;

            if (string.IsNullOrEmpty(filePath))
                return false;

            // 检查是否在排除目录中
            foreach (var excludedDir in _config.FileFilters.ExcludedDirectories)
            {
                if (filePath.Contains($"{Path.DirectorySeparatorChar}{excludedDir}{Path.DirectorySeparatorChar}", StringComparison.OrdinalIgnoreCase) ||
                    filePath.EndsWith($"{Path.DirectorySeparatorChar}{excludedDir}", StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }
            }

            string extension = Path.GetExtension(filePath);
            return _config.FileFilters.AllowedExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);
        }

        // 添加内存监控方法
        private static async Task StartMemoryMonitorAsync(CancellationToken cancellationToken)
        {
            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    // 等待指定时间
                    await Task.Delay(TimeSpan.FromMinutes(_config.General.MemoryMonitorIntervalMinutes), cancellationToken);

                    // 获取当前内存使用情况
                    long currentMemory = GC.GetTotalMemory(false) / (1024 * 1024); // MB

                    Log.Information("内存使用: {Memory} MB, 已处理事件: {EventCount}", currentMemory, _totalEventsProcessed);

                    // 强制执行垃圾回收
                    GC.Collect();
                    GC.WaitForPendingFinalizers();

                    // 显示垃圾回收后的内存
                    long afterGCMemory = GC.GetTotalMemory(true) / (1024 * 1024); // MB
                    Log.Debug("内存清理后: {Memory} MB (释放: {Released} MB)", afterGCMemory, currentMemory - afterGCMemory);
                }
            }
            catch (OperationCanceledException)
            {
                // 预期的取消异常
            }
        }

        // 创建文件监控器
        private static FileSystemWatcher CreateFileWatcher(string path, ChannelWriter<FileSystemEventArgs> writer, CancellationToken cancellationToken)
        {
            // 创建一个新的文件系统监控器
            var watcher = new FileSystemWatcher(path);

            // 从配置设置NotifyFilters
            NotifyFilters notifyFilters = NotifyFilters.LastWrite; // 默认值
            foreach (var filterName in _config.NotifyFilters)
            {
                if (Enum.TryParse<NotifyFilters>(filterName, out var filter))
                {
                    notifyFilters |= filter;
                }
            }

            watcher.NotifyFilter = notifyFilters;
            watcher.IncludeSubdirectories = _config.FileFilters.IncludeSubdirectories;
            watcher.EnableRaisingEvents = true;

            // 设置文件过滤器，如果启用了过滤
            if (_config.General.EnableFileFiltering && _config.FileFilters.AllowedExtensions.Length > 0)
            {
                // 在FileSystemWatcher级别设置过滤器，这样可以减少系统生成的事件数量
                // 只能设置一个扩展名作为Filter，所以我们选择第一个
                string firstExtension = _config.FileFilters.AllowedExtensions[0];
                watcher.Filter = $"*{firstExtension}";
                Log.Information("已设置文件系统监控过滤器: *{Filter}", firstExtension);

                if (_config.FileFilters.AllowedExtensions.Length > 1)
                {
                    Log.Warning("注意: FileSystemWatcher只支持单一过滤器，其他文件类型将在事件处理时过滤。");
                }
            }

            // 注册事件处理程序
            watcher.Created += (sender, e) => HandleFileEvent(sender, e, writer, cancellationToken);
            watcher.Changed += (sender, e) => HandleFileEvent(sender, e, writer, cancellationToken);
            watcher.Deleted += (sender, e) => HandleFileEvent(sender, e, writer, cancellationToken);
            watcher.Renamed += (sender, e) => HandleFileEvent(sender, e, writer, cancellationToken);
            watcher.Error += (sender, e) =>
            {
                Log.Error(e.GetException(), "文件监控错误: {Message}", e.GetException().Message);
            };

            return watcher;
        }

        // 文件事件处理
        private static void HandleFileEvent(object sender, FileSystemEventArgs e, ChannelWriter<FileSystemEventArgs> writer, CancellationToken cancellationToken)
        {
            // 更新最后事件时间
            _lastEventTime = DateTime.UtcNow;

            // 如果启用了事件存储，记录事件
            _eventStorage?.RecordEvent(e);

            try
            {
                // 如果是退出信号，忽略后续处理
                if (cancellationToken.IsCancellationRequested)
                {
                    return;
                }

                // 只处理指定类型的文件，如果启用了文件过滤
                if (!ShouldProcessFile(e.FullPath))
                {
                    return;
                }

                // 尝试将事件写入通道，如果满了就丢弃
                // 不等待，以免阻塞文件系统事件
                if (!writer.TryWrite(e))
                {
                    Log.Warning("警告: 事件处理队列已满，部分事件被丢弃");
                }
            }
            catch (Exception ex)
            {
                // 捕获任何异常，防止崩溃
                Log.Error(ex, "处理文件事件时出错: {Message}", ex.Message);
            }
        }

        private static async Task StartFileMonitorAsync(string path, ChannelWriter<FileSystemEventArgs> writer, CancellationToken cancellationToken)
        {
            // 使用TaskCompletionSource来控制任务的完成
            var tcs = new TaskCompletionSource<bool>();

            try
            {
                // 创建并启动监控器
                _activeWatcher = CreateFileWatcher(path, writer, cancellationToken);

                // 注册取消回调
                cancellationToken.Register(() =>
                {
                    try
                    {
                        if (_activeWatcher != null)
                        {
                            // 确保所有资源正确清理
                            _activeWatcher.EnableRaisingEvents = false;
                            _activeWatcher.Dispose();
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex, "关闭文件监控器时出错: {Message}", ex.Message);
                    }
                    finally
                    {
                        tcs.TrySetResult(true);
                    }
                });

                // 等待任务被取消或完成
                await tcs.Task;
            }
            catch (Exception ex)
            {
                Log.Error(ex, "启动文件监控器时出错: {Message}", ex.Message);
                tcs.TrySetException(ex);
                throw;
            }
        }

        private static async Task ProcessEventsAsync(ChannelReader<FileSystemEventArgs> reader, CancellationToken cancellationToken)
        {
            try
            {
                // 使用配置的字典大小
                var recentlyProcessed = new ConcurrentDictionary<string, DateTime>();

                // 清理计时器，频率由配置决定
                using var cleanupTimer = new Timer(_ =>
                {
                    try
                    {
                        var cutoff = DateTime.UtcNow.AddSeconds(-_config.Performance.EventDebounceTimeSeconds);
                        int removedCount = 0;

                        // 限制字典大小
                        if (recentlyProcessed.Count > _config.Performance.MaxDictionarySize)
                        {
                            // 找出最旧的条目删除
                            var oldestItems = recentlyProcessed
                                .OrderBy(kv => kv.Value)
                                .Take(recentlyProcessed.Count - _config.Performance.MaxDictionarySize / 2);

                            foreach (var item in oldestItems)
                            {
                                DateTime dummy;
                                if (recentlyProcessed.TryRemove(item.Key, out dummy))
                                {
                                    removedCount++;
                                }
                            }
                        }

                        // 常规清理
                        foreach (var key in recentlyProcessed.Keys)
                        {
                            if (recentlyProcessed.TryGetValue(key, out var time) && time < cutoff)
                            {
                                DateTime dummy;
                                if (recentlyProcessed.TryRemove(key, out dummy))
                                {
                                    removedCount++;
                                }
                            }
                        }

                        if (removedCount > 0)
                        {
                            Log.Debug("已清理 {Count} 个过期事件记录", removedCount);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex, "清理定时器错误: {Message}", ex.Message);
                    }
                }, null, TimeSpan.FromSeconds(_config.Performance.CleanupIntervalSeconds),
                     TimeSpan.FromSeconds(_config.Performance.CleanupIntervalSeconds));

                // 从通道读取事件并处理
                await foreach (var e in reader.ReadAllAsync(cancellationToken))
                {
                    // 再次确认文件扩展名，双重检查
                    if (!ShouldProcessFile(e.FullPath))
                    {
                        continue;
                    }

                    // 增加计数器
                    long count = Interlocked.Increment(ref _totalEventsProcessed);

                    // 周期性清理内存
                    if (count % _config.Performance.MemoryCleanupThreshold == 0)
                    {
                        // 在后台线程执行垃圾回收，但直接等待完成避免警告
                        await Task.Run(() =>
                        {
                            GC.Collect();
                            GC.WaitForPendingFinalizers();
                        });
                    }

                    // 只使用文件路径作为键，忽略事件类型，这样同一文件的创建和修改事件会被视为同一事件
                    var key = e.FullPath;

                    // 对于创建事件，如果之前有相同文件的其他事件，则跳过
                    if (e.ChangeType == WatcherChangeTypes.Changed &&
                        recentlyProcessed.TryGetValue(key, out var _))
                    {
                        // 如果是修改事件且文件最近被处理过，则跳过
                        continue;
                    }

                    // 更新或添加文件处理时间，使用原子操作
                    recentlyProcessed[key] = DateTime.UtcNow;

                    string eventType = e.ChangeType switch
                    {
                        WatcherChangeTypes.Created => "创建",
                        WatcherChangeTypes.Deleted => "删除",
                        WatcherChangeTypes.Changed => "修改",
                        WatcherChangeTypes.Renamed => "重命名",
                        _ => "未知"
                    };

                    string fileName = e.Name ?? Path.GetFileName(e.FullPath);
                    string directoryName = Path.GetDirectoryName(e.FullPath) ?? string.Empty;

                    Log.Information("{EventType}: {FileName}", eventType, fileName);

                    if (_config.Logging.LogFileEventDetails)
                    {
                        Log.Debug("  路径: {Path}", directoryName);

                        var extension = Path.GetExtension(e.FullPath);
                        Log.Debug("  类型: {Extension}", extension);

                        if (e is RenamedEventArgs renamedEvent)
                        {
                            Log.Debug("  原名称: {OldName}", Path.GetFileName(renamedEvent.OldFullPath));
                        }
                    }

                    // 延迟可配置
                    await Task.Delay(_config.Performance.ProcessingDelayMs, cancellationToken);
                }
            }
            catch (OperationCanceledException)
            {
                // 预期的取消异常，正常退出
            }
            catch (Exception ex)
            {
                Log.Error(ex, "处理事件时发生错误: {Message}", ex.Message);
            }
            finally
            {
                // 确保资源释放
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
        }

        // 健康监控任务，监视文件监控器的状态并在需要时重启它
        private static async Task StartWatcherHealthMonitorAsync(
            string path, ChannelWriter<FileSystemEventArgs> writer, CancellationToken cancellationToken)
        {
            Log.Information("已启动监控器健康检查，间隔: {Seconds}秒", _config.Robustness.WatcherHealthCheckIntervalSeconds);

            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    // 等待指定的健康检查间隔
                    await Task.Delay(TimeSpan.FromSeconds(_config.Robustness.WatcherHealthCheckIntervalSeconds),
                                     cancellationToken);

                    // 如果监控器不健康且重启次数未超过上限，尝试重启
                    if (_activeWatcher != null &&
                        !FileWatcherUtils.IsWatcherHealthy(_activeWatcher, _lastEventTime, _config.Robustness) &&
                        _watcherRestartAttempts < _config.Robustness.MaxRestartAttempts)
                    {
                        // 停止当前的监控器
                        Log.Warning("检测到监控器异常，准备重启...");

                        try
                        {
                            _activeWatcher.EnableRaisingEvents = false;
                            _activeWatcher.Dispose();
                        }
                        catch (Exception ex)
                        {
                            Log.Error(ex, "停止异常监控器时出错: {Message}", ex.Message);
                        }

                        _watcherRestartAttempts++;
                        Log.Warning("正在重启监控器，尝试次数: {Current}/{Max}",
                            _watcherRestartAttempts, _config.Robustness.MaxRestartAttempts);

                        // 等待指定的重启延迟时间
                        await Task.Delay(TimeSpan.FromSeconds(_config.Robustness.RestartDelaySeconds),
                                         cancellationToken);

                        // 创建新的监控器
                        try
                        {
                            _activeWatcher = CreateFileWatcher(path, writer, cancellationToken);
                            _lastEventTime = DateTime.UtcNow; // 重置最后事件时间
                            Log.Information("监控器已成功重启");
                        }
                        catch (Exception ex)
                        {
                            Log.Error(ex, "重启监控器失败: {Message}", ex.Message);
                        }
                    }
                    else if (_watcherRestartAttempts >= _config.Robustness.MaxRestartAttempts)
                    {
                        Log.Error("警告: 已达到最大重启次数({Max})，不再尝试重启", _config.Robustness.MaxRestartAttempts);
                        Log.Warning("请检查文件系统或手动重启程序");
                        break;
                    }
                }
            }
            catch (OperationCanceledException)
            {
                // 预期的取消异常，正常退出
            }
            catch (Exception ex)
            {
                Log.Error(ex, "健康监控任务异常: {Message}", ex.Message);
            }
        }

        /// <summary>
        /// 运行数据库工具
        /// </summary>
        private static async Task RunDatabaseUtilityAsync(string[] args)
        {
            Console.WriteLine("正在启动SQLite数据库管理工具...");

            try
            {
                var dbUtility = new DbUtility();
                await dbUtility.ExecuteAsync(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"运行数据库工具时发生错误: {ex.Message}");
            }
        }
    }
}