using AutoMapper;
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 DeviceManagementService : IDeviceManagementService
{
    private readonly IMapper _mapper;
    private readonly IDeviceAppService _deviceAppService;
    private readonly IAppDataService _appDataService;
    private readonly IEventService _eventService;

    public DeviceManagementService(IMapper mapper, IDeviceAppService deviceAppService, IAppDataService appStorageService, IEventService eventService)
    {
        _mapper = mapper;
        _deviceAppService = deviceAppService;
        _appDataService = appStorageService;
        _eventService = eventService;
    }

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

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

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

        var result = await _deviceAppService.CreateDeviceWithDetailsAsync(dto);

        // 创建成功后，将设备添加到内存中
        if (result?.Device != null)
        {
            if (_appDataService.Devices.TryAdd(result.Device.Id, result.Device))
            {

                if (result.VariableTable is not null)
                {
                    if (_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
                    {
                        result.VariableTable.Device = result.Device;
                        //将默认变量表添加到设备中
                        result.Device.VariableTables.Add(result.VariableTable);

                        _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(DataChangeType.Added, result.VariableTable));
                    }
                }

                //关联菜单
                if (result.DeviceMenu is not null)
                {

                    var deviceRootMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.TargetViewKey == "DevicesViewModel" && m.TargetId == 0);
                    if (deviceRootMenu is not null)
                    {
                        _appDataService.Menus.TryAdd(result.DeviceMenu.Id, result.DeviceMenu);
                        //将设备菜单添加到根菜单中
                        deviceRootMenu.Children.Add(result.DeviceMenu);

                        if (result.VariableTableMenu is not null)
                        {
                            _appDataService.Menus.TryAdd(result.VariableTableMenu.Id, result.VariableTableMenu);
                            //将变量表菜单添加到设备菜单中
                            result.DeviceMenu.Children.Add(result.VariableTableMenu);
                        }
                    }

                }

                _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Added, result.Device));
            }

            




        }

        return result;
    }

    /// <summary>
    /// 异步更新一个已存在的设备。
    /// </summary>
    public async Task<int> UpdateDeviceAsync(Device device)
    {
        var result = await _deviceAppService.UpdateDeviceAsync(device);

        // 更新成功后，更新内存中的设备
        if (result > 0)
        {
            var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
            if (deviceMenu is not null && deviceMenu.Header != device.Name)
            {
                deviceMenu.Header = device.Name;
            }

            _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Updated, device));
        }

        return result;
    }

    /// <summary>
    /// 异步删除一个设备。
    /// </summary>
    public async Task<bool> DeleteAsync(Device device)
    {
        var result = await _deviceAppService.DeleteAsync(device);

        // 删除成功后，从内存中移除设备
        if (result)
        {
            if (_appDataService.Devices.TryGetValue(device.Id, out var deviceInStorage))
            {
                //删除设备的所有变量表和变量
                foreach (var variableTable in deviceInStorage.VariableTables)
                {
                    foreach (var variable in variableTable.Variables)
                    {
                        _appDataService.Variables.TryRemove(variable.Id, out _);
                    }

                    _appDataService.VariableTables.TryRemove(variableTable.Id, out _);
                }
                //删除菜单
                var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
                if (deviceMenu is not null)
                {
                    foreach (var menu in deviceMenu.Children)
                    {
                        _appDataService.Menus.TryRemove(menu.Id, out _);
                    }

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

                //删除设备
                _appDataService.Devices.TryRemove(device.Id, out _);

                _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Deleted, deviceInStorage));
            }
        }

        return result;
    }

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

        // 更新内存中的设备状态
        var device = await _deviceAppService.GetDeviceByIdAsync(id);
        if (device != null)
        {
            _appDataService.Devices.AddOrUpdate(device.Id, device, (key, oldValue) => device);
            _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Updated, device));
        }
    }

    /// <summary>
    /// 异步加载所有设备数据到内存中。
    /// </summary>
    public async Task LoadAllDevicesAsync()
    {
        _appDataService.Devices.Clear();
        var devices = await _deviceAppService.GetAllDevicesAsync();

        // 建立设备与变量表的关联
        foreach (var device in devices)
        {
            // 将设备添加到安全字典
            _appDataService.Devices.TryAdd(device.Id, device);
        }
    }

}