SOMS/src/YunDa.Server/YunDa.Server.ISMSTcp/Services/VirtualTerminalHandler.cs

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using YunDa.Server.ISMSTcp.Models;

namespace YunDa.Server.ISMSTcp.Services
{
    /// <summary>
    /// 虚端子处理服务
    /// 负责处理虚端子相关的业务逻辑
    /// </summary>
    public class VirtualTerminalHandler
    {
        private readonly ILogger<VirtualTerminalHandler> _logger;

        public VirtualTerminalHandler(ILogger<VirtualTerminalHandler> logger)
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        /// <summary>
        /// 处理虚端子数据
        /// </summary>
        /// <param name="virtualTerminalData">虚端子数据对象</param>
        /// <returns>处理任务</returns>
        public async Task ProcessVirtualTerminalDataAsync(VirtualTerminalData virtualTerminalData)
        {
            try
            {
                if (virtualTerminalData == null)
                {
                    _logger.LogWarning("虚端子数据为空，跳过处理");
                    return;
                }

                if (!virtualTerminalData.IsValid())
                {
                    _logger.LogWarning("虚端子数据无效：{Data}", virtualTerminalData);
                    return;
                }

                _logger.LogInformation("开始处理虚端子数据：{Data}", virtualTerminalData);

                // 解析时间戳
                if (virtualTerminalData.TryParseDateTime(out DateTime timestamp))
                {
                    _logger.LogDebug("虚端子时间戳解析成功：{Timestamp}", timestamp);
                }
                else
                {
                    _logger.LogWarning("虚端子时间戳解析失败：{TimeString}", virtualTerminalData.T);
                }

                // 解析数值
                if (virtualTerminalData.TryParseValue(out double value))
                {
                    _logger.LogDebug("虚端子数值解析成功：{Value}", value);
                }
                else
                {
                    _logger.LogDebug("虚端子数值为非数字类型：{ValueString}", virtualTerminalData.V);
                }

                // 根据UA_ID执行不同的处理逻辑
                await ProcessByUAId(virtualTerminalData);

                _logger.LogInformation("虚端子数据处理完成：{UA_ID}", virtualTerminalData.VA_ID);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理虚端子数据时发生异常：{Data}", virtualTerminalData);
            }
        }

        /// <summary>
        /// 根据UA_ID执行不同的处理逻辑
        /// </summary>
        /// <param name="data">虚端子数据</param>
        /// <returns>处理任务</returns>
        private async Task ProcessByUAId(VirtualTerminalData data)
        {
            try
            {
                switch (data.VA_ID)
                {
                    case "B009000":
                        await ProcessB009000Logic(data);
                        break;
                    
                    default:
                        _logger.LogInformation("未知的虚端子ID：{UA_ID}，执行默认处理逻辑", data.VA_ID);
                        await ProcessDefaultLogic(data);
                        break;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "根据UA_ID处理虚端子数据时发生异常：{UA_ID}", data.VA_ID);
            }
        }

        /// <summary>
        /// 处理B009000类型的虚端子逻辑
        /// </summary>
        /// <param name="data">虚端子数据</param>
        /// <returns>处理任务</returns>
        private async Task ProcessB009000Logic(VirtualTerminalData data)
        {
            try
            {
                _logger.LogInformation("执行B009000虚端子逻辑处理：值={Value}, 时间={Time}", data.V, data.T);
                
                // 这里可以添加具体的B009000处理逻辑
                // 例如：数据验证、状态更新、通知其他服务等
                
                // 示例：检查特定值的处理
                if (data.V == "2")
                {
                    _logger.LogInformation("B009000虚端子检测到值为2，执行特殊处理逻辑");
                    // 添加特殊处理逻辑
                }

                // 模拟异步处理
                await Task.Delay(10);
                
                _logger.LogDebug("B009000虚端子逻辑处理完成");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理B009000虚端子逻辑时发生异常");
            }
        }

        /// <summary>
        /// 默认虚端子处理逻辑
        /// </summary>
        /// <param name="data">虚端子数据</param>
        /// <returns>处理任务</returns>
        private async Task ProcessDefaultLogic(VirtualTerminalData data)
        {
            try
            {
                _logger.LogInformation("执行默认虚端子逻辑处理：UA_ID={UA_ID}, 值={Value}, 时间={Time}", 
                    data.VA_ID, data.V, data.T);
                
                // 默认处理逻辑
                // 例如：记录数据、基本验证等
                
                // 模拟异步处理
                await Task.Delay(5);
                
                _logger.LogDebug("默认虚端子逻辑处理完成");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "处理默认虚端子逻辑时发生异常");
            }
        }

        /// <summary>
        /// 尝试从JSON字符串解析虚端子数据
        /// </summary>
        /// <param name="json">JSON字符串</param>
        /// <param name="virtualTerminalData">解析后的虚端子数据</param>
        /// <returns>是否解析成功</returns>
        public bool TryParseVirtualTerminalData(string json, out VirtualTerminalData virtualTerminalData)
        {
            virtualTerminalData = null;
            
            try
            {
                if (string.IsNullOrEmpty(json))
                {
                    return false;
                }

                virtualTerminalData = JsonConvert.DeserializeObject<VirtualTerminalData>(json);
                return virtualTerminalData != null && virtualTerminalData.IsValid();
            }
            catch (Exception ex)
            {
                _logger.LogDebug(ex, "解析虚端子数据失败：{Json}", json);
                return false;
            }
        }
    }
}