DMS/DMS.Application/Services/DataCenterService.cs

using AutoMapper;
using DMS.Application.DTOs;
using DMS.Application.DTOs.Events;
using DMS.Application.Interfaces;
using DMS.Core.Interfaces;
using DMS.Core.Models;
using DMS.Core.Enums;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using System;
using System.Linq;

namespace DMS.Application.Services;

/// <summary>
/// 数据中心服务，负责管理所有的数据，包括设备、变量表和变量。
/// 实现 <see cref="IDataCenterService"/> 接口。
/// </summary>
public class DataCenterService : IDataCenterService
{
    #region 事件定义

    /// <summary>
    /// 当数据加载完成时触发
    /// </summary>
    public event EventHandler<DataLoadCompletedEventArgs> DataLoadCompleted;

    /// <summary>
    /// 当设备数据发生变化时触发
    /// </summary>
    public event EventHandler<DeviceChangedEventArgs> DeviceChanged;

    /// <summary>
    /// 当变量表数据发生变化时触发
    /// </summary>
    public event EventHandler<VariableTableChangedEventArgs> VariableTableChanged;

    /// <summary>
    /// 当变量数据发生变化时触发
    /// </summary>
    public event EventHandler<VariableChangedEventArgs> VariableChanged;

    /// <summary>
    /// 当数据发生任何变化时触发
    /// </summary>
    public event EventHandler<DataChangedEventArgs> DataChanged;

    #endregion
    private readonly IRepositoryManager _repositoryManager;
    private readonly IMapper _mapper;
    private readonly IDeviceAppService _deviceAppService;
    private readonly IVariableTableAppService _variableTableAppService;
    private readonly IVariableAppService _variableAppService;

    /// <summary>
    /// 安全字典，用于存储所有设备数据
    /// </summary>
    public ConcurrentDictionary<int, DeviceDto> Devices { get; } = new();

    /// <summary>
    /// 安全字典，用于存储所有变量表数据
    /// </summary>
    public ConcurrentDictionary<int, VariableTableDto> VariableTables { get; } = new();

    /// <summary>
    /// 安全字典，用于存储所有变量数据
    /// </summary>
    public ConcurrentDictionary<int, VariableDto> Variables { get; } = new();

    /// <summary>
    /// 构造函数，通过依赖注入获取仓储管理器和相关服务实例。
    /// </summary>
    /// <param name="repositoryManager">仓储管理器实例。</param>
    /// <param name="mapper">AutoMapper 实例。</param>
    /// <param name="deviceAppService">设备应用服务实例。</param>
    /// <param name="variableTableAppService">变量表应用服务实例。</param>
    /// <param name="variableAppService">变量应用服务实例。</param>
    public DataCenterService(
        IRepositoryManager repositoryManager,
        IMapper mapper,
        IDeviceAppService deviceAppService,
        IVariableTableAppService variableTableAppService,
        IVariableAppService variableAppService)
    {
        _repositoryManager = repositoryManager;
        _mapper = mapper;
        _deviceAppService = deviceAppService;
        _variableTableAppService = variableTableAppService;
        _variableAppService = variableAppService;
    }

    #region 设备管理

    /// <summary>
    /// 异步根据ID获取设备DTO。
    /// </summary>
    public async Task<DeviceDto> GetDeviceByIdAsync(int id)
    {
        return await _deviceAppService.GetDeviceByIdAsync(id);
    }

    /// <summary>
    /// 异步获取所有设备DTO列表。
    /// </summary>
    public async Task<List<DeviceDto>> GetAllDevicesAsync()
    {
        return await _deviceAppService.GetAllDevicesAsync();
    }

    /// <summary>
    /// 异步创建一个新设备及其关联的变量表和菜单（事务性操作）。
    /// </summary>
    public async Task<CreateDeviceWithDetailsDto> CreateDeviceWithDetailsAsync(CreateDeviceWithDetailsDto dto)
    {
        return await _deviceAppService.CreateDeviceWithDetailsAsync(dto);
    }

    /// <summary>
    /// 异步更新一个已存在的设备。
    /// </summary>
    public async Task<int> UpdateDeviceAsync(DeviceDto deviceDto)
    {
        return await _deviceAppService.UpdateDeviceAsync(deviceDto);
    }

    /// <summary>
    /// 异步删除一个设备。
    /// </summary>
    public async Task<bool> DeleteDeviceByIdAsync(int deviceId)
    {
        return await _deviceAppService.DeleteDeviceByIdAsync(deviceId);
    }

    /// <summary>
    /// 异步切换设备的激活状态。
    /// </summary>
    public async Task ToggleDeviceActiveStateAsync(int id)
    {
        await _deviceAppService.ToggleDeviceActiveStateAsync(id);
    }

    /// <summary>
    /// 在内存中添加设备
    /// </summary>
    public void AddDeviceToMemory(DeviceDto deviceDto)
    {
        if (Devices.TryAdd(deviceDto.Id, deviceDto))
        {
            OnDeviceChanged(new DeviceChangedEventArgs(DataChangeType.Added, deviceDto.Id, deviceDto.Name));
        }
    }

    /// <summary>
    /// 在内存中更新设备
    /// </summary>
    public void UpdateDeviceInMemory(DeviceDto deviceDto)
    {
        Devices.AddOrUpdate(deviceDto.Id, deviceDto, (key, oldValue) => deviceDto);
        OnDeviceChanged(new DeviceChangedEventArgs(DataChangeType.Updated, deviceDto.Id, deviceDto.Name));
    }

    /// <summary>
    /// 在内存中删除设备
    /// </summary>
    public void RemoveDeviceFromMemory(int deviceId)
    {
        if (Devices.TryRemove(deviceId, out var deviceDto))
        {
            OnDeviceChanged(new DeviceChangedEventArgs(DataChangeType.Deleted, deviceId, deviceDto?.Name ?? ""));
        }
    }

    #endregion

    #region 变量表管理

    /// <summary>
    /// 异步根据ID获取变量表DTO。
    /// </summary>
    public async Task<VariableTableDto> GetVariableTableByIdAsync(int id)
    {
        return await _variableTableAppService.GetVariableTableByIdAsync(id);
    }

    /// <summary>
    /// 异步获取所有变量表DTO列表。
    /// </summary>
    public async Task<List<VariableTableDto>> GetAllVariableTablesAsync()
    {
        return await _variableTableAppService.GetAllVariableTablesAsync();
    }

    /// <summary>
    /// 异步创建一个新变量表及其关联菜单（事务性操作）。
    /// </summary>
    public async Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto dto)
    {
        return await _variableTableAppService.CreateVariableTableAsync(dto);
    }

    /// <summary>
    /// 异步更新一个已存在的变量表。
    /// </summary>
    public async Task<int> UpdateVariableTableAsync(VariableTableDto variableTableDto)
    {
        return await _variableTableAppService.UpdateVariableTableAsync(variableTableDto);
    }

    /// <summary>
    /// 异步删除一个变量表。
    /// </summary>
    public async Task<bool> DeleteVariableTableAsync(int id)
    {
        return await _variableTableAppService.DeleteVariableTableAsync(id);
    }

    /// <summary>
    /// 在内存中添加变量表
    /// </summary>
    public void AddVariableTableToMemory(VariableTableDto variableTableDto)
    {
        if (VariableTables.TryAdd(variableTableDto.Id, variableTableDto))
        {
            OnVariableTableChanged(new VariableTableChangedEventArgs(
                DataChangeType.Added, 
                variableTableDto.Id, 
                variableTableDto.Name, 
                variableTableDto.DeviceId));
        }
    }

    /// <summary>
    /// 在内存中更新变量表
    /// </summary>
    public void UpdateVariableTableInMemory(VariableTableDto variableTableDto)
    {
        VariableTables.AddOrUpdate(variableTableDto.Id, variableTableDto, (key, oldValue) => variableTableDto);
        OnVariableTableChanged(new VariableTableChangedEventArgs(
            DataChangeType.Updated, 
            variableTableDto.Id, 
            variableTableDto.Name, 
            variableTableDto.DeviceId));
    }

    /// <summary>
    /// 在内存中删除变量表
    /// </summary>
    public void RemoveVariableTableFromMemory(int variableTableId)
    {
        if (VariableTables.TryRemove(variableTableId, out var variableTableDto))
        {
            OnVariableTableChanged(new VariableTableChangedEventArgs(
                DataChangeType.Deleted, 
                variableTableId, 
                variableTableDto?.Name ?? "", 
                variableTableDto?.DeviceId ?? 0));
        }
    }

    #endregion

    #region 变量管理

    /// <summary>
    /// 异步根据ID获取变量DTO。
    /// </summary>
    public async Task<VariableDto> GetVariableByIdAsync(int id)
    {
        return await _variableAppService.GetVariableByIdAsync(id);
    }

    /// <summary>
    /// 异步获取所有变量DTO列表。
    /// </summary>
    public async Task<List<VariableDto>> GetAllVariablesAsync()
    {
        return await _variableAppService.GetAllVariablesAsync();
    }

    /// <summary>
    /// 异步创建一个新变量（事务性操作）。
    /// </summary>
    public async Task<VariableDto> CreateVariableAsync(VariableDto variableDto)
    {
        return await _variableAppService.CreateVariableAsync(variableDto);
    }

    /// <summary>
    /// 异步更新一个已存在的变量（事务性操作）。
    /// </summary>
    public async Task<int> UpdateVariableAsync(VariableDto variableDto)
    {
        return await _variableAppService.UpdateVariableAsync(variableDto);
    }

    /// <summary>
    /// 异步批量更新变量（事务性操作）。
    /// </summary>
    public async Task<int> UpdateVariablesAsync(List<VariableDto> variableDtos)
    {
        return await _variableAppService.UpdateVariablesAsync(variableDtos);
    }

    /// <summary>
    /// 异步删除一个变量（事务性操作）。
    /// </summary>
    public async Task<bool> DeleteVariableAsync(int id)
    {
        return await _variableAppService.DeleteVariableAsync(id);
    }

    /// <summary>
    /// 异步批量删除变量（事务性操作）。
    /// </summary>
    public async Task<bool> DeleteVariablesAsync(List<int> ids)
    {
        return await _variableAppService.DeleteVariablesAsync(ids);
    }

    /// <summary>
    /// 异步批量导入变量。
    /// </summary>
    public async Task<bool> BatchImportVariablesAsync(List<VariableDto> variables)
    {
        return await _variableAppService.BatchImportVariablesAsync(variables);
    }

    /// <summary>
    /// 检测一组变量是否已存在。
    /// </summary>
    public async Task<List<VariableDto>> FindExistingVariablesAsync(IEnumerable<VariableDto> variablesToCheck)
    {
        return await _variableAppService.FindExistingVariablesAsync(variablesToCheck);
    }

    /// <summary>
    /// 检测单个变量是否已存在。
    /// </summary>
    public async Task<VariableDto?> FindExistingVariableAsync(VariableDto variableToCheck)
    {
        return await _variableAppService.FindExistingVariableAsync(variableToCheck);
    }

    /// <summary>
    /// 在内存中添加变量
    /// </summary>
    public void AddVariableToMemory(VariableDto variableDto)
    {
        if (Variables.TryAdd(variableDto.Id, variableDto))
        {
            OnVariableChanged(new VariableChangedEventArgs(
                DataChangeType.Added, 
                variableDto.Id, 
                variableDto.Name, 
                variableDto.VariableTableId));
        }
    }

    /// <summary>
    /// 在内存中更新变量
    /// </summary>
    public void UpdateVariableInMemory(VariableDto variableDto)
    {
        Variables.AddOrUpdate(variableDto.Id, variableDto, (key, oldValue) => variableDto);
        OnVariableChanged(new VariableChangedEventArgs(
            DataChangeType.Updated, 
            variableDto.Id, 
            variableDto.Name, 
            variableDto.VariableTableId));
    }

    /// <summary>
    /// 在内存中删除变量
    /// </summary>
    public void RemoveVariableFromMemory(int variableId)
    {
        if (Variables.TryRemove(variableId, out var variableDto))
        {
            OnVariableChanged(new VariableChangedEventArgs(
                DataChangeType.Deleted, 
                variableId, 
                variableDto?.Name ?? "", 
                variableDto?.VariableTableId ?? 0));
        }
    }

    /// <summary>
    /// 批量在内存中添加变量
    /// </summary>
    public void AddVariablesToMemory(List<VariableDto> variables)
    {
        foreach (var variable in variables)
        {
            if (Variables.TryAdd(variable.Id, variable))
            {
                OnVariableChanged(new VariableChangedEventArgs(
                    DataChangeType.Added, 
                    variable.Id, 
                    variable.Name, 
                    variable.VariableTableId));
            }
        }
        OnDataChanged(new DataChangedEventArgs(DataChangeType.BatchOperation));
    }

    /// <summary>
    /// 批量在内存中更新变量
    /// </summary>
    public void UpdateVariablesInMemory(List<VariableDto> variables)
    {
        foreach (var variable in variables)
        {
            Variables.AddOrUpdate(variable.Id, variable, (key, oldValue) => variable);
            OnVariableChanged(new VariableChangedEventArgs(
                DataChangeType.Updated, 
                variable.Id, 
                variable.Name, 
                variable.VariableTableId));
        }
        OnDataChanged(new DataChangedEventArgs(DataChangeType.BatchOperation));
    }

    /// <summary>
    /// 批量在内存中删除变量
    /// </summary>
    public void RemoveVariablesFromMemory(List<int> variableIds)
    {
        foreach (var variableId in variableIds)
        {
            if (Variables.TryRemove(variableId, out var variableDto))
            {
                OnVariableChanged(new VariableChangedEventArgs(
                    DataChangeType.Deleted, 
                    variableId, 
                    variableDto?.Name ?? "", 
                    variableDto?.VariableTableId ?? 0));
            }
        }
        OnDataChanged(new DataChangedEventArgs(DataChangeType.BatchOperation));
    }

    #endregion

    #region 事件触发方法

    /// <summary>
    /// 触发数据加载完成事件
    /// </summary>
    /// <param name="e">事件参数</param>
    protected virtual void OnDataLoadCompleted(DataLoadCompletedEventArgs e)
    {
        DataLoadCompleted?.Invoke(this, e);
        OnDataChanged(new DataChangedEventArgs(DataChangeType.Loaded));
    }

    /// <summary>
    /// 触发设备变更事件
    /// </summary>
    /// <param name="e">事件参数</param>
    protected virtual void OnDeviceChanged(DeviceChangedEventArgs e)
    {
        DeviceChanged?.Invoke(this, e);
        OnDataChanged(new DataChangedEventArgs(e.ChangeType));
    }

    /// <summary>
    /// 触发变量表变更事件
    /// </summary>
    /// <param name="e">事件参数</param>
    protected virtual void OnVariableTableChanged(VariableTableChangedEventArgs e)
    {
        VariableTableChanged?.Invoke(this, e);
        OnDataChanged(new DataChangedEventArgs(e.ChangeType));
    }

    /// <summary>
    /// 触发变量变更事件
    /// </summary>
    /// <param name="e">事件参数</param>
    protected virtual void OnVariableChanged(VariableChangedEventArgs e)
    {
        VariableChanged?.Invoke(this, e);
        OnDataChanged(new DataChangedEventArgs(e.ChangeType));
    }

    /// <summary>
    /// 触发数据变更事件
    /// </summary>
    /// <param name="e">事件参数</param>
    protected virtual void OnDataChanged(DataChangedEventArgs e)
    {
        DataChanged?.Invoke(this, e);
    }

    #endregion

    #region 数据加载和初始化

    /// <summary>
    /// 异步加载所有设备及其关联数据到内存中。
    /// </summary>
    public async Task LoadAllDataToMemoryAsync()
    {
        try
        {
            // 清空现有数据
            Devices.Clear();
            VariableTables.Clear();
            Variables.Clear();

            // 加载所有设备
            var devices = await _repositoryManager.Devices.GetAllAsync();
            var deviceDtos = _mapper.Map<List<DeviceDto>>(devices);
            
            // 加载所有变量表
            var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
            var variableTableDtos = _mapper.Map<List<VariableTableDto>>(variableTables);
            
            // 加载所有变量
            var variables = await _repositoryManager.Variables.GetAllAsync();
            var variableDtos = _mapper.Map<List<VariableDto>>(variables);

            // 建立设备与变量表的关联
            foreach (var deviceDto in deviceDtos)
            {
                deviceDto.VariableTables = variableTableDtos
                    .Where(vt => vt.DeviceId == deviceDto.Id)
                    .ToList();
                
                // 将设备添加到安全字典
                Devices.TryAdd(deviceDto.Id, deviceDto);
            }

            // 建立变量表与变量的关联
            foreach (var variableTableDto in variableTableDtos)
            {
                variableTableDto.Variables = variableDtos
                    .Where(v => v.VariableTableId == variableTableDto.Id)
                    .ToList();
                
                // 将变量表添加到安全字典
                VariableTables.TryAdd(variableTableDto.Id, variableTableDto);
            }

            // 将变量添加到安全字典
            foreach (var variableDto in variableDtos)
            {
                Variables.TryAdd(variableDto.Id, variableDto);
            }

            // 触发数据加载完成事件
            OnDataLoadCompleted(new DataLoadCompletedEventArgs(
                deviceDtos.Count, 
                variableTableDtos.Count, 
                variableDtos.Count, 
                true));
        }
        catch (Exception ex)
        {
            // 触发数据加载失败事件
            OnDataLoadCompleted(new DataLoadCompletedEventArgs(0, 0, 0, false, ex.Message));
            throw new ApplicationException($"加载所有数据到内存时发生错误,错误信息:{ex.Message}", ex);
        }
    }

    /// <summary>
    /// 异步加载所有设备及其关联数据。
    /// </summary>
    public async Task<List<DeviceDto>> LoadAllDevicesAsync()
    {
        try
        {
            // 获取所有设备
            var devices = await _repositoryManager.Devices.GetAllAsync();
            var deviceDtos = _mapper.Map<List<DeviceDto>>(devices);
            
            // 为每个设备加载关联的变量表和变量
            foreach (var deviceDto in deviceDtos)
            {
                // 获取设备的所有变量表
                var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
                var deviceVariableTables = variableTables.Where(vt => vt.DeviceId == deviceDto.Id).ToList();
                deviceDto.VariableTables = _mapper.Map<List<VariableTableDto>>(deviceVariableTables);
                
                // 为每个变量表加载关联的变量
                foreach (var variableTableDto in deviceDto.VariableTables)
                {
                    var variables = await _repositoryManager.Variables.GetAllAsync();
                    var tableVariables = variables.Where(v => v.VariableTableId == variableTableDto.Id).ToList();
                    variableTableDto.Variables = _mapper.Map<List<VariableDto>>(tableVariables);
                }
            }
            
            return deviceDtos;
        }
        catch (Exception ex)
        {
            throw new ApplicationException($"加载所有设备数据时发生错误,错误信息:{ex.Message}", ex);
        }
    }

    /// <summary>
    /// 异步加载所有变量表及其关联数据。
    /// </summary>
    public async Task<List<VariableTableDto>> LoadAllVariableTablesAsync()
    {
        try
        {
            // 获取所有变量表
            var variableTables = await _repositoryManager.VariableTables.GetAllAsync();
            var variableTableDtos = _mapper.Map<List<VariableTableDto>>(variableTables);
            
            // 为每个变量表加载关联的变量
            foreach (var variableTableDto in variableTableDtos)
            {
                var variables = await _repositoryManager.Variables.GetAllAsync();
                var tableVariables = variables.Where(v => v.VariableTableId == variableTableDto.Id).ToList();
                variableTableDto.Variables = _mapper.Map<List<VariableDto>>(tableVariables);
            }
            
            return variableTableDtos;
        }
        catch (Exception ex)
        {
            throw new ApplicationException($"加载所有变量表数据时发生错误,错误信息:{ex.Message}", ex);
        }
    }

    /// <summary>
    /// 异步加载所有变量数据。
    /// </summary>
    public async Task<List<VariableDto>> LoadAllVariablesAsync()
    {
        try
        {
            // 获取所有变量
            var variables = await _repositoryManager.Variables.GetAllAsync();
            return _mapper.Map<List<VariableDto>>(variables);
        }
        catch (Exception ex)
        {
            throw new ApplicationException($"加载所有变量数据时发生错误,错误信息:{ex.Message}", ex);
        }
    }

    #endregion
}