using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using WIDESEAWCS_S7Simulator.Core.Entities;
using WIDESEAWCS_S7Simulator.Core.Enums;
using WIDESEAWCS_S7Simulator.Core.Interfaces;
using WIDESEAWCS_S7Simulator.Core.Persistence.Models;

namespace WIDESEAWCS_S7Simulator.Core.Persistence
{
    /// <summary>
    /// 文件持久化服务实现
    /// 将实例配置和内存数据保存到本地JSON文件
    /// </summary>
    public class FilePersistenceService : IPersistenceService
    {
        /// <summary>
        /// 数据目录路径
        /// </summary>
        private readonly string _dataPath;

        /// <summary>
        /// JSON序列化选项（线程安全）
        /// </summary>
        private static readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        };

        /// <summary>
        /// 文件操作锁（线程安全）
        /// </summary>
        private readonly SemaphoreSlim _fileLock = new SemaphoreSlim(1, 1);

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataPath">数据目录路径</param>
        public FilePersistenceService(string dataPath = "Data")
        {
            // 转换为绝对路径（基于当前工作目录）
            _dataPath = Path.GetFullPath(dataPath);

            try
            {
                // 确保数据目录存在
                if (!Directory.Exists(_dataPath))
                {
                    Directory.CreateDirectory(_dataPath);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error creating data directory '{_dataPath}': {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 保存实例配置
        /// </summary>
        public async Task SaveInstanceConfigAsync(InstanceConfig config)
        {
            if (config == null)
                throw new ArgumentNullException(nameof(config));

            await _fileLock.WaitAsync();
            try
            {
                var instanceDir = GetInstanceDirectory(config.Id);
                if (!Directory.Exists(instanceDir))
                {
                    Directory.CreateDirectory(instanceDir);
                }

                var configPath = Path.Combine(instanceDir, "config.json");
                var model = ToDataModel(config);

                var json = JsonSerializer.Serialize(model, _jsonOptions);
                await WriteFileAtomicAsync(configPath, json);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error saving instance config for '{config.Id}': {ex.Message}");
                throw;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 加载实例配置
        /// </summary>
        public async Task<InstanceConfig> LoadInstanceConfigAsync(string instanceId)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
                throw new ArgumentException("实例ID不能为空", nameof(instanceId));

            ValidateInstanceId(instanceId);

            await _fileLock.WaitAsync();
            try
            {
                var configPath = Path.Combine(GetInstanceDirectory(instanceId), "config.json");
                if (!File.Exists(configPath))
                    throw new FileNotFoundException($"实例配置文件不存在: {configPath}");

                var json = await File.ReadAllTextAsync(configPath);
                var model = JsonSerializer.Deserialize<InstanceDataModel>(json, _jsonOptions);

                if (model == null)
                    throw new InvalidOperationException("无法反序列化实例配置");

                return ToEntity(model);
            }
            catch (Exception ex) when (!(ex is FileNotFoundException || ex is InvalidOperationException || ex is ArgumentException))
            {
                Console.WriteLine($"Error loading instance config for '{instanceId}': {ex.Message}");
                throw;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 加载所有实例配置
        /// </summary>
        public async Task<List<InstanceConfig>> LoadAllInstanceConfigsAsync()
        {
            await _fileLock.WaitAsync();
            try
            {
                var configs = new List<InstanceConfig>();

                if (!Directory.Exists(_dataPath))
                    return configs;

                var instanceDirs = Directory.GetDirectories(_dataPath)
                    .Where(d => Path.GetFileName(d).StartsWith("instance-"))
                    .ToList();

                foreach (var dir in instanceDirs)
                {
                    var configPath = Path.Combine(dir, "config.json");
                    if (File.Exists(configPath))
                    {
                        try
                        {
                            var json = await File.ReadAllTextAsync(configPath);
                            var model = JsonSerializer.Deserialize<InstanceDataModel>(json, _jsonOptions);
                            if (model != null)
                            {
                                configs.Add(ToEntity(model));
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Error loading instance config from '{configPath}': {ex.Message}");
                            // 跳过无法加载的配置文件
                            continue;
                        }
                    }
                }

                return configs;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 删除实例配置
        /// </summary>
        public async Task DeleteInstanceConfigAsync(string instanceId)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
                throw new ArgumentException("实例ID不能为空", nameof(instanceId));

            ValidateInstanceId(instanceId);

            await _fileLock.WaitAsync();
            try
            {
                var instanceDir = GetInstanceDirectory(instanceId);
                if (Directory.Exists(instanceDir))
                {
                    Directory.Delete(instanceDir, recursive: true);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error deleting instance '{instanceId}': {ex.Message}");
                throw;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 保存内存数据
        /// </summary>
        public async Task SaveMemoryDataAsync(string instanceId, IMemoryStore memoryStore)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
                throw new ArgumentException("实例ID不能为空", nameof(instanceId));

            ValidateInstanceId(instanceId);

            if (memoryStore == null)
                throw new ArgumentNullException(nameof(memoryStore));

            await _fileLock.WaitAsync();
            try
            {
                var instanceDir = GetInstanceDirectory(instanceId);
                if (!Directory.Exists(instanceDir))
                {
                    Directory.CreateDirectory(instanceDir);
                }

                var memoryPath = Path.Combine(instanceDir, "memory.json");
                var exportedData = memoryStore.Export();

                // 将字节数组转换为Base64字符串以便JSON序列化
                var memoryDataModel = new MemoryDataModel
                {
                    MemoryData = exportedData.ToDictionary(
                        kvp => kvp.Key,
                        kvp => Convert.ToBase64String(kvp.Value)
                    )
                };

                var json = JsonSerializer.Serialize(memoryDataModel, _jsonOptions);
                await WriteFileAtomicAsync(memoryPath, json);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error saving memory data for instance '{instanceId}': {ex.Message}");
                throw;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 加载内存数据
        /// </summary>
        public async Task LoadMemoryDataAsync(string instanceId, IMemoryStore memoryStore)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
                throw new ArgumentException("实例ID不能为空", nameof(instanceId));

            ValidateInstanceId(instanceId);

            if (memoryStore == null)
                throw new ArgumentNullException(nameof(memoryStore));

            await _fileLock.WaitAsync();
            try
            {
                var memoryPath = Path.Combine(GetInstanceDirectory(instanceId), "memory.json");
                if (!File.Exists(memoryPath))
                    return; // 内存文件不存在，跳过加载

                var json = await File.ReadAllTextAsync(memoryPath);
                var memoryDataModel = JsonSerializer.Deserialize<MemoryDataModel>(json, _jsonOptions);

                if (memoryDataModel?.MemoryData == null)
                    return;

                // 将Base64字符串转换回字节数组
                var importedData = new Dictionary<string, byte[]>();
                foreach (var kvp in memoryDataModel.MemoryData)
                {
                    try
                    {
                        importedData[kvp.Key] = Convert.FromBase64String(kvp.Value);
                    }
                    catch (FormatException ex)
                    {
                        Console.WriteLine($"Warning: Invalid Base64 data for memory region '{kvp.Key}' in instance '{instanceId}': {ex.Message}");
                        // 跳过无效的Base64数据
                        continue;
                    }
                }

                memoryStore.Import(importedData);
            }
            catch (Exception ex) when (!(ex is FileNotFoundException))
            {
                Console.WriteLine($"Error loading memory data for instance '{instanceId}': {ex.Message}");
                throw;
            }
            finally
            {
                _fileLock.Release();
            }
        }

        /// <summary>
        /// 获取实例目录路径
        /// </summary>
        private string GetInstanceDirectory(string instanceId)
        {
            return Path.Combine(_dataPath, $"instance-{instanceId}");
        }

        /// <summary>
        /// 验证实例ID（防止路径遍历攻击）
        /// </summary>
        private void ValidateInstanceId(string instanceId)
        {
            if (string.IsNullOrWhiteSpace(instanceId))
                throw new ArgumentException("实例ID不能为空", nameof(instanceId));

            // 检查路径遍历字符
            if (instanceId.Contains("..") || instanceId.Contains("/") || instanceId.Contains("\\"))
                throw new ArgumentException("实例ID包含非法字符", nameof(instanceId));

            // 检查无效路径字符
            var invalidChars = Path.GetInvalidFileNameChars();
            if (instanceId.IndexOfAny(invalidChars) >= 0)
                throw new ArgumentException("实例ID包含非法字符", nameof(instanceId));
        }

        /// <summary>
        /// 写入文件（直接写入，简化版本）
        /// </summary>
        private async Task WriteFileAtomicAsync(string filePath, string content)
        {
            // 确保目标文件的父目录存在
            var directory = Path.GetDirectoryName(filePath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            // 直接写入文件
            await File.WriteAllTextAsync(filePath, content, Encoding.UTF8);
        }

        /// <summary>
        /// 将实体转换为数据模型
        /// </summary>
        private InstanceDataModel ToDataModel(InstanceConfig config)
        {
            return new InstanceDataModel
            {
                Id = config.Id,
                Name = config.Name,
                PlcType = config.PLCType.ToString(),
                Port = config.Port,
                ActivationKey = config.ActivationKey,
                AutoStart = config.AutoStart,
                MemoryConfig = new MemoryRegionConfigModel
                {
                    MRegionSize = config.MemoryConfig.MRegionSize,
                    DBBlockCount = config.MemoryConfig.DBBlockCount,
                    DBBlockSize = config.MemoryConfig.DBBlockSize,
                    IRegionSize = config.MemoryConfig.IRegionSize,
                    QRegionSize = config.MemoryConfig.QRegionSize,
                    TRegionCount = config.MemoryConfig.TRegionCount,
                    CRegionCount = config.MemoryConfig.CRegionCount
                }
            };
        }

        /// <summary>
        /// 将数据模型转换为实体
        /// </summary>
        private InstanceConfig ToEntity(InstanceDataModel model)
        {
            return new InstanceConfig
            {
                Id = model.Id,
                Name = model.Name,
                PLCType = Enum.Parse<SiemensPLCType>(model.PlcType),
                Port = model.Port,
                ActivationKey = model.ActivationKey,
                AutoStart = model.AutoStart,
                MemoryConfig = new MemoryRegionConfig
                {
                    MRegionSize = model.MemoryConfig.MRegionSize,
                    DBBlockCount = model.MemoryConfig.DBBlockCount,
                    DBBlockSize = model.MemoryConfig.DBBlockSize,
                    IRegionSize = model.MemoryConfig.IRegionSize,
                    QRegionSize = model.MemoryConfig.QRegionSize,
                    TRegionCount = model.MemoryConfig.TRegionCount,
                    CRegionCount = model.MemoryConfig.CRegionCount
                }
            };
        }
    }
}