using System.Text.Json;
using System.Text;

namespace GSModbus.Config
{
    /// <summary>
    /// 配置管理器 - 负责加载、验证和保存Modbus配置
    /// </summary>
    public class ConfigurationManager
    {
        #region 常量定义

        /// <summary>
        /// 默认配置文件路径
        /// </summary>
        public const string DEFAULT_CONFIG_PATH = "config/modbus_config.json";

        /// <summary>
        /// 配置文件搜索模式
        /// </summary>
        public const string CONFIG_FILE_PATTERN = "*.json";

        /// <summary>
        /// 支持的配置文件版本
        /// </summary>
        public readonly string[] SUPPORTED_VERSIONS = { "1.0" };

        #endregion

        #region 私有字段

        /// <summary>
        /// 当前加载的配置
        /// </summary>
        private ModbusConfiguration? _currentConfiguration;

        /// <summary>
        /// 当前配置文件路径
        /// </summary>
        private string? _currentConfigPath;

        /// <summary>
        /// JSON序列化选项
        /// </summary>
        private readonly JsonSerializerOptions _jsonOptions;

        #endregion

        #region 事件定义

        /// <summary>
        /// 配置加载事件
        /// </summary>
        public event EventHandler<ConfigurationLoadedEventArgs>? ConfigurationLoaded;

        /// <summary>
        /// 配置错误事件
        /// </summary>
        public event EventHandler<ConfigurationErrorEventArgs>? ConfigurationError;

        #endregion

        #region 公共属性

        /// <summary>
        /// 获取当前配置
        /// </summary>
        public ModbusConfiguration? CurrentConfiguration => _currentConfiguration;

        /// <summary>
        /// 获取当前配置文件路径
        /// </summary>
        public string? CurrentConfigPath => _currentConfigPath;

        /// <summary>
        /// 获取配置是否已加载
        /// </summary>
        public bool IsConfigurationLoaded => _currentConfiguration != null;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化配置管理器
        /// </summary>
        public ConfigurationManager()
        {
            // 配置JSON序列化选项
            _jsonOptions = new JsonSerializerOptions
            {
                PropertyNamingPolicy = null, // 保持原始属性名
                WriteIndented = true,        // 格式化输出
                Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, // 支持中文
                AllowTrailingCommas = true,  // 允许尾随逗号
                ReadCommentHandling = JsonCommentHandling.Skip // 跳过注释
            };
        }

        #endregion

        #region 配置加载方法

        /// <summary>
        /// 加载默认配置文件
        /// </summary>
        /// <returns>是否加载成功</returns>
        public async Task<bool> LoadDefaultConfigurationAsync()
        {
            return await LoadConfigurationAsync(DEFAULT_CONFIG_PATH);
        }

        /// <summary>
        /// 从指定路径加载配置文件
        /// </summary>
        /// <param name="configPath">配置文件路径</param>
        /// <returns>是否加载成功</returns>
        public async Task<bool> LoadConfigurationAsync(string configPath)
        {
            try
            {
                // 检查文件是否存在
                if (!File.Exists(configPath))
                {
                    var error = $"配置文件不存在: {configPath}";
                    LogError(error);
                    OnConfigurationError(new ConfigurationErrorEventArgs(error, null));
                    return false;
                }

                // 读取配置文件内容
                LogInfo($"正在加载配置文件: {configPath}");
                var jsonContent = await File.ReadAllTextAsync(configPath, Encoding.UTF8);

                // 反序列化配置
                var configuration = JsonSerializer.Deserialize<ModbusConfiguration>(jsonContent, _jsonOptions);
                if (configuration == null)
                {
                    var error = "配置文件格式无效，反序列化失败";
                    LogError(error);
                    OnConfigurationError(new ConfigurationErrorEventArgs(error, null));
                    return false;
                }

                // 验证配置
                var validationResult = ValidateConfiguration(configuration);
                if (!validationResult.IsValid)
                {
                    var error = $"配置验证失败: {string.Join(", ", validationResult.Errors)}";
                    LogError(error);
                    OnConfigurationError(new ConfigurationErrorEventArgs(error, null));
                    return false;
                }

                // 设置当前配置
                _currentConfiguration = configuration;
                _currentConfigPath = configPath;

                LogInfo($"配置加载成功: {configuration.ProjectName}");
                OnConfigurationLoaded(new ConfigurationLoadedEventArgs(configuration, configPath));

                return true;
            }
            catch (JsonException jsonEx)
            {
                var error = $"JSON格式错误: {jsonEx.Message}";
                LogError(error);
                OnConfigurationError(new ConfigurationErrorEventArgs(error, jsonEx));
                return false;
            }
            catch (Exception ex)
            {
                var error = $"加载配置文件时发生错误: {ex.Message}";
                LogError(error);
                OnConfigurationError(new ConfigurationErrorEventArgs(error, ex));
                return false;
            }
        }

        /// <summary>
        /// 重新加载当前配置文件
        /// </summary>
        /// <returns>是否重新加载成功</returns>
        public async Task<bool> ReloadConfigurationAsync()
        {
            if (string.IsNullOrEmpty(_currentConfigPath))
            {
                LogWarning("没有当前配置文件可以重新加载");
                return false;
            }

            return await LoadConfigurationAsync(_currentConfigPath);
        }

        #endregion

        #region 配置保存方法

        /// <summary>
        /// 保存当前配置到文件
        /// </summary>
        /// <param name="configPath">保存路径，如果为空则使用当前路径</param>
        /// <returns>是否保存成功</returns>
        public async Task<bool> SaveConfigurationAsync(string? configPath = null)
        {
            if (_currentConfiguration == null)
            {
                LogError("没有配置可以保存");
                return false;
            }

            var savePath = configPath ?? _currentConfigPath;
            if (string.IsNullOrEmpty(savePath))
            {
                LogError("没有指定保存路径");
                return false;
            }

            try
            {
                // 确保目录存在
                var directory = Path.GetDirectoryName(savePath);
                if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                // 序列化配置
                var jsonContent = JsonSerializer.Serialize(_currentConfiguration, _jsonOptions);

                // 写入文件
                await File.WriteAllTextAsync(savePath, jsonContent, Encoding.UTF8);

                // 更新当前路径
                _currentConfigPath = savePath;

                LogInfo($"配置已保存到: {savePath}");
                return true;
            }
            catch (Exception ex)
            {
                var error = $"保存配置文件时发生错误: {ex.Message}";
                LogError(error);
                OnConfigurationError(new ConfigurationErrorEventArgs(error, ex));
                return false;
            }
        }

        #endregion

        #region 配置验证方法

        /// <summary>
        /// 验证配置完整性和有效性
        /// </summary>
        /// <param name="configuration">要验证的配置</param>
        /// <returns>验证结果</returns>
        public ConfigurationValidationResult ValidateConfiguration(ModbusConfiguration configuration)
        {
            var result = new ConfigurationValidationResult();
            var errors = new List<string>();

            try
            {
                // 验证配置版本
                if (string.IsNullOrEmpty(configuration.ConfigVersion))
                {
                    errors.Add("配置版本不能为空");
                }
                else if (!SUPPORTED_VERSIONS.Contains(configuration.ConfigVersion))
                {
                    errors.Add($"不支持的配置版本: {configuration.ConfigVersion}");
                }

                // 验证连接配置
                ValidateConnectionConfig(configuration.Connection, errors);

                // 验证通信配置
                ValidateCommunicationConfig(configuration.Communication, errors);

                // 验证地址配置
                ValidateAddressConfig(configuration, errors);

                result.IsValid = errors.Count == 0;
                result.Errors = errors;
            }
            catch (Exception ex)
            {
                errors.Add($"验证过程中发生错误: {ex.Message}");
                result.IsValid = false;
                result.Errors = errors;
            }

            return result;
        }

        /// <summary>
        /// 验证连接配置
        /// </summary>
        private void ValidateConnectionConfig(ConnectionConfig connection, List<string> errors)
        {
            if (string.IsNullOrEmpty(connection.IpAddress))
            {
                errors.Add("IP地址不能为空");
            }
            else if (!System.Net.IPAddress.TryParse(connection.IpAddress, out _))
            {
                errors.Add($"IP地址格式无效: {connection.IpAddress}");
            }

            if (connection.Port <= 0 || connection.Port > 65535)
            {
                errors.Add($"端口号无效: {connection.Port}");
            }

            if (connection.ConnectionTimeoutMs <= 0)
            {
                errors.Add("连接超时时间必须大于0");
            }

            if (connection.OperationTimeoutMs <= 0)
            {
                errors.Add("操作超时时间必须大于0");
            }
        }

        /// <summary>
        /// 验证通信配置
        /// </summary>
        private void ValidateCommunicationConfig(CommunicationConfig communication, List<string> errors)
        {
            if (communication.HeartbeatIntervalMs <= 0)
            {
                errors.Add("心跳间隔必须大于0");
            }

            if (communication.DataPollingIntervalMs <= 0)
            {
                errors.Add("数据轮询间隔必须大于0");
            }

            if (communication.ReconnectDelayMs <= 0)
            {
                errors.Add("重连延迟必须大于0");
            }

            if (communication.MaxRetryCount < 0)
            {
                errors.Add("最大重试次数不能小于0");
            }
        }

        /// <summary>
        /// 验证地址配置
        /// </summary>
        private void ValidateAddressConfig(ModbusConfiguration configuration, List<string> errors)
        {
            // 验证输出地址
            if (configuration.OutputAddresses.HeartbeatAddress.Address < 0)
            {
                errors.Add("心跳地址无效");
            }

            if (configuration.OutputAddresses.DataConfirmationAddress.Address < 0)
            {
                errors.Add("数据确认地址无效");
            }

            // 验证输入地址中的数据字段
            var allFields = new List<DataField>();
            allFields.AddRange(configuration.InputAddresses.ControlSignals.Values);
            allFields.AddRange(configuration.InputAddresses.ProductData.Values);
            allFields.AddRange(configuration.InputAddresses.MeasurementData.Values);

            foreach (var field in allFields)
            {
                if (field.Address < 0)
                {
                    errors.Add($"字段地址无效: {field.DisplayName}");
                }

                if (field.Length <= 0)
                {
                    errors.Add($"字段长度无效: {field.DisplayName}");
                }

                if (string.IsNullOrEmpty(field.DataType))
                {
                    errors.Add($"字段数据类型不能为空: {field.DisplayName}");
                }
            }
        }

        #endregion

        #region 工具方法

        /// <summary>
        /// 创建默认配置
        /// </summary>
        /// <returns>默认配置对象</returns>
        public static ModbusConfiguration CreateDefaultConfiguration()
        {
            return new ModbusConfiguration
            {
                ConfigVersion = "1.0",
                ProjectName = "GSModbus默认配置",
                Description = "默认的Modbus通信配置",
                Connection = new ConnectionConfig
                {
                    IpAddress = "192.168.1.100",
                    Port = 502,
                    ConnectionTimeoutMs = 5000,
                    OperationTimeoutMs = 3000
                },
                Communication = new CommunicationConfig
                {
                    HeartbeatIntervalMs = 1000,
                    DataPollingIntervalMs = 500,
                    EnableAutoReconnect = true,
                    ReconnectDelayMs = 3000,
                    MaxRetryCount = 3
                },
                OutputAddresses = new OutputAddressConfig
                {
                    Description = "MES发送给PLC的地址",
                    HeartbeatAddress = new AddressField { Address = 6000, DataType = "Byte", Description = "心跳地址" },
                    DataConfirmationAddress = new AddressField { Address = 6001, DataType = "Byte", Description = "确认地址" }
                },
                InputAddresses = new InputAddressConfig
                {
                    Description = "从PLC读取的地址",
                    ControlSignals = new Dictionary<string, DataField>(),
                    ProductData = new Dictionary<string, DataField>(),
                    MeasurementData = new Dictionary<string, DataField>()
                }
            };
        }

        /// <summary>
        /// 获取配置文件列表
        /// </summary>
        /// <param name="searchDirectory">搜索目录</param>
        /// <returns>配置文件路径列表</returns>
        public static List<string> GetConfigurationFiles(string searchDirectory = "config")
        {
            var configFiles = new List<string>();

            try
            {
                if (Directory.Exists(searchDirectory))
                {
                    configFiles.AddRange(Directory.GetFiles(searchDirectory, CONFIG_FILE_PATTERN, SearchOption.TopDirectoryOnly));
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"搜索配置文件时发生错误: {ex.Message}");
            }

            return configFiles;
        }

        #endregion

        #region 事件触发方法

        /// <summary>
        /// 触发配置加载事件
        /// </summary>
        protected virtual void OnConfigurationLoaded(ConfigurationLoadedEventArgs e)
        {
            ConfigurationLoaded?.Invoke(this, e);
        }

        /// <summary>
        /// 触发配置错误事件
        /// </summary>
        protected virtual void OnConfigurationError(ConfigurationErrorEventArgs e)
        {
            ConfigurationError?.Invoke(this, e);
        }

        #endregion

        #region 日志方法

        private void LogInfo(string message)
        {
            Console.WriteLine($"[CONFIG-INFO] {DateTime.Now:HH:mm:ss} - {message}");
        }

        private void LogWarning(string message)
        {
            Console.WriteLine($"[CONFIG-WARN] {DateTime.Now:HH:mm:ss} - {message}");
        }

        private void LogError(string message)
        {
            Console.WriteLine($"[CONFIG-ERROR] {DateTime.Now:HH:mm:ss} - {message}");
        }

        #endregion
    }

    #region 事件参数类

    /// <summary>
    /// 配置加载事件参数
    /// </summary>
    public class ConfigurationLoadedEventArgs : EventArgs
    {
        public ModbusConfiguration Configuration { get; }
        public string ConfigPath { get; }

        public ConfigurationLoadedEventArgs(ModbusConfiguration configuration, string configPath)
        {
            Configuration = configuration;
            ConfigPath = configPath;
        }
    }

    /// <summary>
    /// 配置错误事件参数
    /// </summary>
    public class ConfigurationErrorEventArgs : EventArgs
    {
        public string ErrorMessage { get; }
        public Exception? Exception { get; }

        public ConfigurationErrorEventArgs(string errorMessage, Exception? exception)
        {
            ErrorMessage = errorMessage;
            Exception = exception;
        }
    }

    #endregion

    #region 验证结果类

    /// <summary>
    /// 配置验证结果
    /// </summary>
    public class ConfigurationValidationResult
    {
        /// <summary>
        /// 验证是否通过
        /// </summary>
        public bool IsValid { get; set; }

        /// <summary>
        /// 验证错误列表
        /// </summary>
        public List<string> Errors { get; set; } = new();

        /// <summary>
        /// 验证警告列表
        /// </summary>
        public List<string> Warnings { get; set; } = new();
    }

    #endregion
}