using DMS.Application.DTOs;
using DMS.Application.Events;
using DMS.Application.Interfaces;
using DMS.Application.Interfaces.Database;
using DMS.Application.Interfaces.Management;
using DMS.Core.Enums;
using DMS.Core.Models;

namespace DMS.Application.Services.Management;

/// <summary>
/// 变量表管理服务，负责变量表相关的业务逻辑。
/// </summary>
public class VariableTableManagementService : IVariableTableManagementService
{
    private readonly IVariableTableAppService _variableTableAppService;
    private readonly IAppDataService _appDataService;
    private readonly IEventService _eventService;

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

    public VariableTableManagementService(IVariableTableAppService variableTableAppService,
                                         IAppDataService appStorageService,
                                         IEventService eventService)
    {
        _variableTableAppService = variableTableAppService;
        _appDataService = appStorageService;
        _eventService = eventService;
    }

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

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

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


        var result = await _variableTableAppService.AddAsync(dto);

        // 检查结果是否为空
        if (result?.VariableTable is null)
        {
            return null;
        }

        // 获取设备对象
        if (!_appDataService.Devices.TryGetValue(result.VariableTable.DeviceId, out var device))
        {
            return null;
        }

        // 将变量表添加到设备列表并设置设备引用
        device.VariableTables.Add(result.VariableTable);
        result.VariableTable.Device = device;

        // 尝试将变量表添加到内存中
        if (!_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
        {
            return null;
        }

        // 如果有菜单对象，则处理菜单相关逻辑
        if (result.Menu is null) return null;

        var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
        if (deviceMenu is not null)
        {
            _appDataService.Menus.TryAdd(result.Menu.Id, result.Menu);
            //将设备菜单添加到根菜单中
            deviceMenu.Children.Add(result.Menu);
        }

        // 触发变量表变化事件
        _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
                                           DataChangeType.Added,
                                           result.VariableTable));

        return result;
    }

    /// <summary>
    /// 异步更新一个已存在的变量表。
    /// </summary>
    public async Task<int> UpdateAsync(VariableTable variableTable)
    {
        var result = await _variableTableAppService.UpdateAsync(variableTable);

        // 更新成功后，更新内存中的变量表
        if (result > 0 && variableTable != null)
        {
            _appDataService.VariableTables.AddOrUpdate(variableTable.Id, variableTable, (key, oldValue) => variableTable);
            _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
                                             DataChangeType.Updated,
                                             variableTable));
        }

        return result;
    }

    /// <summary>
    /// 异步删除一个变量表。
    /// </summary>
    public async Task<bool> DeleteAsync(VariableTable variableTable)
    {
        var result = await _variableTableAppService.DeleteAsync(variableTable);

        // 删除成功后，从内存中移除变量表
        if (result)
        {
            if (_appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
            {
                device.VariableTables.Remove(variableTable);

                _appDataService.VariableTables.TryRemove(variableTable.Id, out _);

                //删除菜单
                var variableTableMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.VariableTableMenu && m.TargetId == variableTable.Id);
                if (variableTableMenu is not null)
                {
                    if (_appDataService.Menus.TryGetValue(variableTableMenu.ParentId, out var deviceMenu))
                    {
                        deviceMenu.Children.Remove(variableTableMenu);
                    }


                    _appDataService.Menus.TryRemove(variableTableMenu.Id, out _);
                }

            }

            _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
                                             DataChangeType.Deleted,
                                             variableTable));
        }

        return result;
    }


    /// <summary>
    /// 异步加载所有变量表数据到内存中。
    /// </summary>
    public async Task LoadAllVariableTablesAsync()
    {
        _appDataService.VariableTables.Clear();
        var variableTables = await _variableTableAppService.GetAllVariableTablesAsync();
        // 建立变量表与变量的关联
        foreach (var variableTable in variableTables)
        {
            if (_appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
            {
                variableTable.Device = device;
                if (device.VariableTables == null)
                    device.VariableTables = new List<VariableTable>();
                device.VariableTables.Add(variableTable);
            }

            // 将变量表添加到安全字典
            _appDataService.VariableTables.TryAdd(variableTable.Id, variableTable);
        }
    }

}