/**
 * CoreServices.cs - 核心业务服务实现
 * 
 * 实现CNC机床数据采集分析系统的核心业务服务。
 * 
 * 修订历史：
 * - 2026-04-13: 初始实现
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Threading;
using System.Threading.Tasks;
using System.Text.Json;
using System.Text.Json.Nodes;
using Microsoft.Extensions.Logging;
using Haoliang.Models.Device;
using Haoliang.Models.Production;
using Haoliang.Models.DataCollection;
using Haoliang.Data.Repositories;

namespace Haoliang.Core.Services
{
    #region ========== Ping服务实现 ==========

    /// <summary>
    /// Ping服务实现 - 设备网络连通性检测
    /// </summary>
    public class PingService : IPingService
    {
        private readonly ILogger<PingService> _logger;
        private const int DefaultTimeout = 5000; // 5秒超时

        public PingService(ILogger<PingService> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Ping指定设备
        /// </summary>
        public async Task<PingResult> PingAsync(int deviceId, string ipAddress)
        {
            var result = new PingResult
            {
                DeviceId = deviceId,
                IpAddress = ipAddress,
                Timestamp = DateTime.UtcNow
            };

            try
            {
                using var ping = new Ping();
                var reply = await ping.SendPingAsync(ipAddress, DefaultTimeout);
                
                result.Success = reply.Status == IPStatus.Success;
                result.RoundtripTime = reply.RoundtripTime;
                
                if (!result.Success)
                {
                    result.ErrorMessage = $"Ping失败: {reply.Status}";
                    _logger.LogWarning("设备{DeviceId} Ping {IpAddress} 失败: {Status}", 
                        deviceId, ipAddress, reply.Status);
                }
            }
            catch (PingException ex)
            {
                result.Success = false;
                result.ErrorMessage = ex.Message;
                _logger.LogError(ex, "设备{DeviceId} Ping {IpAddress} 异常", deviceId, ipAddress);
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.ErrorMessage = ex.Message;
                _logger.LogError(ex, "设备{DeviceId} Ping {IpAddress} 未知错误", deviceId, ipAddress);
            }

            return result;
        }

        /// <summary>
        /// 批量Ping设备
        /// </summary>
        public async Task<IEnumerable<PingResult>> PingAllAsync(IEnumerable<(int DeviceId, string IpAddress)> devices)
        {
            var tasks = devices.Select(d => PingAsync(d.DeviceId, d.IpAddress));
            var results = await Task.WhenAll(tasks);
            return results;
        }

        /// <summary>
        /// 检查设备是否可达
        /// </summary>
        public async Task<bool> IsReachableAsync(string ipAddress, TimeSpan? timeout = null)
        {
            try
            {
                using var ping = new Ping();
                var timeoutMs = timeout.HasValue ? (int)timeout.Value.TotalMilliseconds : DefaultTimeout;
                var reply = await ping.SendPingAsync(ipAddress, timeoutMs);
                return reply.Status == IPStatus.Success;
            }
            catch
            {
                return false;
            }
        }
    }

    #endregion

    #region ========== 数据解析服务实现（发那科JSON解析） ==========

    /// <summary>
    /// 数据解析服务实现 - 解析发那科CNC设备返回的JSON数据
    /// 
    /// 发那科标准JSON格式：
    /// {
    ///   "device": "设备编号",
    ///   "desc": "设备描述",
    ///   "tags": [
    ///     { "id": "Tag5", "value": "NC程序名", ... },
    ///     { "id": "Tag8", "value": "12345.00000", ... },
    ///     { "id": "_io_status", "value": "1", ... },
    ///     ...
    ///   ]
    /// }
    /// </summary>
    public class DataParserService : IDataParserService
    {
        private readonly ILogger<DataParserService> _logger;

        public DataParserService(ILogger<DataParserService> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// 解析设备原始数据
        /// </summary>
        public Task<ParsedDeviceData> ParseRawDataAsync(string rawData, int templateId)
        {
            try
            {
                var json = JsonNode.Parse(rawData);
                if (json == null)
                {
                    throw new InvalidOperationException("JSON解析失败：返回空对象");
                }

                var result = new ParsedDeviceData
                {
                    Timestamp = DateTime.UtcNow,
                    RawJson = rawData,
                    Tags = new Dictionary<string, TagValue>()
                };

                // 解析device字段 - 设备标识
                result.DeviceName = json["device"]?.GetValue<string>();

                // 解析tags数组 - 关键字段
                var tags = json["tags"]?.AsArray();
                if (tags != null)
                {
                    foreach (var tag in tags)
                    {
                        if (tag == null) continue;

                        var tagId = tag["id"]?.GetValue<string>();
                        if (string.IsNullOrEmpty(tagId)) continue;

                        var tagValue = new TagValue
                        {
                            Id = tagId,
                            Description = tag["desc"]?.GetValue<string>(),
                            Value = ParseTagValue(tag["value"]),
                            Quality = tag["quality"]?.GetValue<string>(),
                            Timestamp = DateTime.TryParse(tag["time"]?.GetValue<string>(), out var ts) 
                                ? ts : DateTime.UtcNow
                        };

                        result.Tags[tagId] = tagValue;
                    }
                }

                _logger.LogDebug("解析设备数据成功: Device={Device}, TagCount={Count}", 
                    result.DeviceName, result.Tags?.Count ?? 0);

                return Task.FromResult(result);
            }
            catch (JsonException ex)
            {
                _logger.LogError(ex, "JSON解析异常: {RawData}", rawData);
                throw new InvalidOperationException($"JSON格式错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 解析多设备数据（数组格式）
        /// </summary>
        public Task<IEnumerable<ParsedDeviceData>> ParseMultiDeviceDataAsync(string rawData, int templateId)
        {
            try
            {
                var jsonArray = JsonNode.Parse(rawData)?.AsArray();
                if (jsonArray == null)
                {
                    return Task.FromResult<IEnumerable<ParsedDeviceData>>(
                        Array.Empty<ParsedDeviceData>());
                }

                var results = new List<ParsedDeviceData>();
                foreach (var item in jsonArray)
                {
                    if (item == null) continue;
                    
                    var jsonStr = item.ToJsonString();
                    try
                    {
                        var parsed = ParseRawDataAsync(jsonStr, templateId).Result;
                        results.Add(parsed);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogWarning(ex, "解析单个设备数据失败: {Json}", jsonStr);
                    }
                }

                return Task.FromResult<IEnumerable<ParsedDeviceData>>(results);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "解析多设备数据异常");
                return Task.FromResult<IEnumerable<ParsedDeviceData>>(
                    Array.Empty<ParsedDeviceData>());
            }
        }

        /// <summary>
        /// 验证数据格式
        /// </summary>
        public bool ValidateDataFormat(string rawData)
        {
            if (string.IsNullOrWhiteSpace(rawData))
                return false;

            try
            {
                var json = JsonNode.Parse(rawData);
                if (json == null)
                    return false;

                // 检查必要字段：发那科格式应该有 device, desc, tags
                var hasDevice = json["device"] != null;
                var hasTags = json["tags"] != null;

                return hasDevice && hasTags;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 解析Tag值 - 处理数值类型的尾缀去除
        /// 发那科返回的数值如 "12345.00000" 需要转换为整数/小数
        /// </summary>
        private object? ParseTagValue(JsonNode? valueNode)
        {
            if (valueNode == null)
                return null;

            var strValue = valueNode.GetValue<string>();
            if (string.IsNullOrEmpty(strValue))
                return strValue;

            // 尝试解析为数值
            if (decimal.TryParse(strValue, out var decValue))
            {
                // 如果是小数且尾缀为.00000，去除尾缀转为整数
                if (decValue == Math.Floor(decValue) && strValue.Contains(".00000"))
                {
                    return (long)decValue;
                }
                // 如果是整数
                if (decValue == Math.Floor(decValue))
                {
                    return (long)decValue;
                }
                // 否则返回小数
                return decValue;
            }

            return strValue;
        }
    }

    #endregion

    #region ========== 设备采集服务实现 ==========

    /// <summary>
    /// 设备采集服务实现
    /// 
    /// 负责定时轮询采集CNC设备数据，支持：
    /// - Ping检测设备连通性
    /// - HTTP请求采集数据
    /// - 失败自动重试（3次，间隔30秒）
    /// - 并行采集多设备
    /// </summary>
    public class DeviceCollectionService : IDeviceCollectionService
    {
        private readonly ILogger<DeviceCollectionService> _logger;
        private readonly IPingService _pingService;
        private readonly IDataParserService _dataParserService;
        private readonly IDeviceRepository _deviceRepository;

        private const int MaxRetryCount = 3;
        private const int RetryIntervalSeconds = 30;

        public DeviceCollectionService(
            ILogger<DeviceCollectionService> logger,
            IPingService pingService,
            IDataParserService dataParserService,
            IDeviceRepository deviceRepository)
        {
            _logger = logger;
            _pingService = pingService;
            _dataParserService = dataParserService;
            _deviceRepository = deviceRepository;
        }

        /// <summary>
        /// 获取所有设备
        /// </summary>
        public async Task<IEnumerable<CNCDevice>> GetAllDevicesAsync()
        {
            return await _deviceRepository.GetAllAsync();
        }

        /// <summary>
        /// 根据ID获取设备
        /// </summary>
        public async Task<CNCDevice?> GetDeviceByIdAsync(int deviceId)
        {
            return await _deviceRepository.GetByIdAsync(deviceId);
        }

        /// <summary>
        /// 创建设备
        /// </summary>
        public async Task<CNCDevice> CreateDeviceAsync(CNCDevice device)
        {
            device.CreatedAt = DateTime.UtcNow;
            device.UpdatedAt = DateTime.UtcNow;
            await _deviceRepository.AddAsync(device);
            await _deviceRepository.SaveAsync();
            return device;
        }

        /// <summary>
        /// 更新设备信息
        /// </summary>
        public async Task<CNCDevice?> UpdateDeviceAsync(CNCDevice device)
        {
            device.UpdatedAt = DateTime.UtcNow;
            _deviceRepository.Update(device);
            var affected = await _deviceRepository.SaveAsync();
            return affected > 0 ? device : null;
        }

        /// <summary>
        /// 删除设备
        /// </summary>
        public async Task<bool> DeleteDeviceAsync(int deviceId)
        {
            var device = await _deviceRepository.GetByIdAsync(deviceId);
            if (device == null) return false;
            
            _deviceRepository.Remove(device);
            return await _deviceRepository.SaveAsync() > 0;
        }

        /// <summary>
        /// 采集指定设备数据
        /// 采集流程：Ping检测 -> HTTP请求 -> 数据解析 -> 存储
        /// </summary>
        public async Task CollectDeviceAsync(int deviceId)
        {
            var device = await _deviceRepository.GetByIdAsync(deviceId);
            if (device == null)
            {
                _logger.LogWarning("采集失败：设备{DeviceId}不存在", deviceId);
                return;
            }

            // 检查设备是否可用
            if (!device.IsAvailable)
            {
                _logger.LogDebug("设备{DeviceId}标记为不可用，跳过采集", deviceId);
                return;
            }

            // Ping检测
            var pingResult = await _pingService.PingAsync(deviceId, device.IPAddress);
            if (!pingResult.Success)
            {
                _logger.LogWarning("设备{DeviceId} Ping失败: {Error}", deviceId, pingResult.ErrorMessage);
                await UpdateDeviceOnlineStatus(deviceId, false);
                return;
            }

            // HTTP请求采集数据，带重试
            var retryCount = 0;
            while (retryCount < MaxRetryCount)
            {
                try
                {
                    var rawData = await HttpCollectAsync(device);
                    if (string.IsNullOrEmpty(rawData))
                    {
                        throw new InvalidOperationException("HTTP返回空数据");
                    }

                    // 解析数据
                    var parsedData = await _dataParserService.ParseRawDataAsync(rawData, device.TemplateId);
                    parsedData.DeviceId = deviceId;

                    _logger.LogInformation("设备{DeviceId}采集成功", deviceId);

                    // 更新设备在线状态
                    await UpdateDeviceOnlineStatus(deviceId, true);
                    await UpdateLastCollectionTime(deviceId);
                    return;
                }
                catch (Exception ex)
                {
                    retryCount++;
                    _logger.LogWarning(ex, "设备{DeviceId}采集失败 (重试 {Retry}/{Max})", 
                        deviceId, retryCount, MaxRetryCount);
                    
                    if (retryCount < MaxRetryCount)
                    {
                        await Task.Delay(TimeSpan.FromSeconds(RetryIntervalSeconds));
                    }
                }
            }

            // 连续MaxRetryCount次失败
            _logger.LogError("设备{DeviceId}连续{Attempts}次采集失败", deviceId, MaxRetryCount);
        }

        /// <summary>
        /// 采集所有设备数据
        /// </summary>
        public async Task CollectAllDevicesAsync()
        {
            var devices = await _deviceRepository.GetAllAsync();
            var availableDevices = devices.Where(d => d.IsAvailable).ToList();

            _logger.LogInformation("开始采集 {Count} 台设备", availableDevices.Count);

            foreach (var device in availableDevices)
            {
                try
                {
                    await CollectDeviceAsync(device.Id);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "设备{DeviceId}采集异常", device.Id);
                }
            }

            _logger.LogInformation("采集任务完成");
        }

        /// <summary>
        /// 获取设备状态
        /// </summary>
        public Task<DeviceStatus> GetDeviceStatusAsync(int deviceId)
        {
            return Task.FromResult(new DeviceStatus
            {
                DeviceId = deviceId,
                Timestamp = DateTime.UtcNow
            });
        }

        /// <summary>
        /// 获取设备健康状态
        /// </summary>
        public Task<DeviceHealth> GetDeviceHealthAsync(int deviceId)
        {
            return Task.FromResult(new DeviceHealth
            {
                DeviceId = deviceId,
                IsHealthy = true,
                LastCheck = DateTime.UtcNow
            });
        }

        /// <summary>
        /// 获取设备当前状态
        /// </summary>
        public Task<DeviceStatus> GetDeviceCurrentStatusAsync(int deviceId)
        {
            return GetDeviceStatusAsync(deviceId);
        }

        #region 私有方法

        /// <summary>
        /// HTTP采集数据
        /// </summary>
        private async Task<string?> HttpCollectAsync(CNCDevice device)
        {
            try
            {
                using var httpClient = new HttpClient();
                httpClient.Timeout = TimeSpan.FromSeconds(10);
                var response = await httpClient.GetAsync(device.HttpUrl);
                
                if (response.IsSuccessStatusCode)
                {
                    return await response.Content.ReadAsStringAsync();
                }
                
                _logger.LogWarning("HTTP请求失败: {StatusCode}", response.StatusCode);
                return null;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "HTTP请求异常: {Url}", device.HttpUrl);
                return null;
            }
        }

        /// <summary>
        /// 更新设备在线状态
        /// </summary>
        private async Task UpdateDeviceOnlineStatus(int deviceId, bool isOnline)
        {
            var device = await _deviceRepository.GetByIdAsync(deviceId);
            if (device != null && device.IsOnline != isOnline)
            {
                device.IsOnline = isOnline;
                device.UpdatedAt = DateTime.UtcNow;
                _deviceRepository.Update(device);
                await _deviceRepository.SaveAsync();
            }
        }

        /// <summary>
        /// 更新最后采集时间
        /// </summary>
        private async Task UpdateLastCollectionTime(int deviceId)
        {
            var device = await _deviceRepository.GetByIdAsync(deviceId);
            if (device != null)
            {
                device.LastCollectionTime = DateTime.UtcNow;
                device.UpdatedAt = DateTime.UtcNow;
                _deviceRepository.Update(device);
                await _deviceRepository.SaveAsync();
            }
        }

        #endregion
    }

    #endregion

    #region ========== 产量计算服务实现 ==========

    /// <summary>
    /// 产量计算服务实现
    /// 
    /// 核心差分计算逻辑：
    /// 1. 同一程序连续加工：产量 = MAX(0, 当前累计数 - 上次累计数)
    /// 2. 程序切换(A→B)：A产量锁定，B以当前累计数为新起点
    /// 3. 切回历史程序(B→A)：视为A重新开始，增量累加到当日产量
    /// 4. 跨天处理：0点自动重置，新日期以首次采集累计值为起点
    /// </summary>
    public class ProductionCalculator : IProductionCalculator
    {
        private readonly ILogger<ProductionCalculator> _logger;
        
        // 存储每个设备的生产状态：设备ID -> (程序名, 上次累计数, 记录时间, 上次日期)
        private readonly Dictionary<int, DeviceProductionState> _productionStates = new();
        
        // 异常值检测阈值：产量变化超过此值视为异常
        private const decimal AbnormalJumpThreshold = 1000;

        private class DeviceProductionState
        {
            public string? ProgramName { get; set; }
            public decimal LastValue { get; set; }
            public DateTime LastTime { get; set; }
            public DateTime LastDate { get; set; }
        }

        public ProductionCalculator(ILogger<ProductionCalculator> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// 计算生产增量
        /// </summary>
        public Task<decimal> CalculateProductionIncrementAsync(int deviceId, decimal currentValue, string programName, DateTime timestamp)
        {
            decimal increment = 0;

            lock (_productionStates)
            {
                // 首次采集或跨天：初始化状态
                if (!_productionStates.TryGetValue(deviceId, out var state))
                {
                    state = new DeviceProductionState
                    {
                        ProgramName = programName,
                        LastValue = currentValue,
                        LastTime = timestamp,
                        LastDate = timestamp.Date
                    };
                    _productionStates[deviceId] = state;
                    _logger.LogDebug("设备{DeviceId}首次采集，程序={Program}，初始值={Value}", 
                        deviceId, programName, currentValue);
                    return Task.FromResult(0m);
                }

                // 跨天处理：0点自动重置
                if (timestamp.Date != state.LastDate)
                {
                    _logger.LogInformation("设备{DeviceId}跨天重置，昨日程序={Program}，新日期={Date}", 
                        deviceId, state.ProgramName, timestamp.Date);
                    state.ProgramName = programName;
                    state.LastValue = currentValue;
                    state.LastTime = timestamp;
                    state.LastDate = timestamp.Date;
                    return Task.FromResult(0m);
                }

                // 同一程序连续加工
                if (state.ProgramName == programName)
                {
                    var diff = currentValue - state.LastValue;
                    
                    // 异常值保护：负数视为0
                    if (diff < 0)
                    {
                        _logger.LogWarning("设备{DeviceId}产量为负，忽略: {Diff}", deviceId, diff);
                        diff = 0;
                    }
                    // 异常值保护：跳变过大视为异常
                    else if (diff > AbnormalJumpThreshold)
                    {
                        _logger.LogWarning("设备{DeviceId}产量跳变过大，忽略: {Diff}", deviceId, diff);
                        diff = 0;
                    }
                    
                    increment = diff;
                    state.LastValue = currentValue;
                    state.LastTime = timestamp;
                    
                    _logger.LogDebug("设备{DeviceId}连续加工，程序={Program}，增量={Increment}", 
                        deviceId, programName, increment);
                }
                // 程序切换
                else
                {
                    // 切回历史程序：增量累加
                    // 新程序：以当前累计数为新起点
                    _logger.LogInformation("设备{DeviceId}程序切换 {OldProgram}→{NewProgram}，新起点={Value}", 
                        deviceId, state.ProgramName, programName, currentValue);
                    
                    state.ProgramName = programName;
                    state.LastValue = currentValue;
                    state.LastTime = timestamp;
                    increment = 0; // 程序切换不计入产量
                }
            }

            return Task.FromResult(increment);
        }

        /// <summary>
        /// 重置设备生产状态
        /// </summary>
        public void ResetDeviceProductionState(int deviceId)
        {
            lock (_productionStates)
            {
                if (_productionStates.ContainsKey(deviceId))
                {
                    _productionStates.Remove(deviceId);
                    _logger.LogInformation("设备{DeviceId}生产状态已重置", deviceId);
                }
            }
        }

        /// <summary>
        /// 验证生产数据有效性
        /// </summary>
        public bool ValidateProductionValue(int deviceId, decimal value)
        {
            // 负数无效
            if (value < 0)
            {
                _logger.LogWarning("设备{DeviceId}产量验证失败：负数 {Value}", deviceId, value);
                return false;
            }

            lock (_productionStates)
            {
                if (_productionStates.TryGetValue(deviceId, out var state))
                {
                    var diff = Math.Abs(value - state.LastValue);
                    
                    // 跳变过大无效
                    if (diff > AbnormalJumpThreshold)
                    {
                        _logger.LogWarning("设备{DeviceId}产量验证失败：跳变过大 {Diff}", deviceId, diff);
                        return false;
                    }
                }
            }

            return true;
        }
    }

    #endregion

    #region ========== 数据存储服务实现 ==========

    /// <summary>
    /// 数据存储服务实现
    /// 
    /// 负责将解析后的数据存储到数据库：
    /// - 原始JSON存入日志库(cnc_log)
    /// - 解析后结构化数据存入业务库(cnc_business)
    /// </summary>
    public class DataStorageService : IDataStorageService
    {
        private readonly ILogger<DataStorageService> _logger;
        private readonly IDeviceRepository _deviceRepository;

        public DataStorageService(
            ILogger<DataStorageService> logger,
            IDeviceRepository deviceRepository)
        {
            _logger = logger;
            _deviceRepository = deviceRepository;
        }

        /// <summary>
        /// 存储设备数据
        /// </summary>
        public Task StoreDeviceDataAsync(ParsedDeviceData data)
        {
            try
            {
                // 更新设备状态
                _deviceRepository.UpdateDeviceStatusAsync(data.DeviceId, true, true).Wait();
                
                _logger.LogDebug("设备{DeviceId}数据存储成功", data.DeviceId);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "设备{DeviceId}数据存储失败", data.DeviceId);
            }
            return Task.CompletedTask;
        }

        /// <summary>
        /// 批量存储设备数据
        /// </summary>
        public Task StoreDeviceDataBatchAsync(IEnumerable<ParsedDeviceData> dataList)
        {
            foreach (var data in dataList)
            {
                try
                {
                    StoreDeviceDataAsync(data).Wait();
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "批量存储中设备{DeviceId}失败", data.DeviceId);
                }
            }
            return Task.CompletedTask;
        }

        /// <summary>
        /// 存储生产记录
        /// </summary>
        public Task StoreProductionRecordAsync(ProductionRecord record)
        {
            // TODO: 调用ProductionRepository存储
            _logger.LogDebug("存储生产记录: DeviceId={DeviceId}, Quantity={Quantity}", 
                record.DeviceId, record.Quantity);
            return Task.CompletedTask;
        }

        /// <summary>
        /// 更新设备状态
        /// </summary>
        public Task UpdateDeviceStatusAsync(int deviceId, DeviceStatus status)
        {
            _deviceRepository.UpdateDeviceStatusAsync(deviceId, true, true).Wait();
            return Task.CompletedTask;
        }
    }

    #endregion
}