using AutoMapper;
using CommunityToolkit.Mvvm.ComponentModel;
using DMS.Application.DTOs;
using DMS.Application.Events;
using DMS.Application.Interfaces;
using DMS.Core.Enums;
using DMS.Core.Events;
using DMS.WPF.Interfaces;
using DMS.WPF.ItemViewModel;
using DMS.WPF.ViewModels;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows.Threading;

namespace DMS.WPF.Services.ViewService;

/// <summary>
/// 设备数据服务类，负责管理设备相关的数据和操作。
/// </summary>
public class DeviceViewService : IDeviceDataService
{
    private readonly IMapper _mapper;
    private readonly IAppCenterService _appCenterService;
    private readonly IAppDataService _appDataService;
    private readonly IViewDataService _viewDataService;
    private readonly IVariableTableViewService _variableTableDataService;
    private readonly IEventService _eventService;
    private readonly INotificationService _notificationService;
    private readonly IMenuViewService _menuDataService;
    private readonly IVariableViewService _variableDataService;
    private readonly Dispatcher _uiDispatcher;

    /// <summary>
    /// DeviceDataService类的构造函数。
    /// </summary>
    /// <param name="mapper">AutoMapper 实例。</param>
    /// <param name="appCenterService">数据服务中心实例。</param>
    public DeviceViewService(IMapper mapper, IAppCenterService appCenterService,
                             IAppDataService appStorageService, IViewDataService dataStorageService,
                             IVariableTableViewService variableTableDataService,
                             IEventService eventService, INotificationService notificationService,
                             IMenuViewService menuDataService, IVariableViewService variableDataService)
    {
        _mapper = mapper;
        _appCenterService = appCenterService;
        _appDataService = appStorageService;
        _viewDataService = dataStorageService;
        _variableTableDataService = variableTableDataService;
        _eventService = eventService;
        _notificationService = notificationService;
        _menuDataService = menuDataService;
        _variableDataService = variableDataService;
        _uiDispatcher = Dispatcher.CurrentDispatcher;

        _eventService.OnDeviceStateChanged += OnDeviceStateChanged;
    }

    private void OnDeviceStateChanged(object? sender, DeviceStateChangedEventArgs e)
    {
        // 只处理连接状态变化
        if (e.StateType == DeviceStateType.Connection)
        {
            _uiDispatcher.Invoke(() =>
            {
                if (_viewDataService.Devices.TryGetValue(e.DeviceId, out DeviceItem device))
                {
                    device.IsRunning = e.StateValue;
                    if (device.IsRunning)
                    {
                        _notificationService.ShowSuccess($"设备：{device.Name},连接成功。");
                    }
                    else
                    {
                        _notificationService.ShowSuccess($"设备：{device.Name},已断开连接。");
                    }
                }
            });
        }
    }

    /// <summary>
    /// 加载所有设备数据。
    /// </summary>
    public void LoadAllDevices()
    {
        foreach (var device in _appDataService.Devices.Values)
        {
            _viewDataService.Devices.Add(device.Id, _mapper.Map<DeviceItem>(device));
        }
    }

    /// <summary>
    /// 添加设备。
    /// </summary>
    public async Task<CreateDeviceWithDetailsDto?> AddDeviceAsync(CreateDeviceWithDetailsDto dto)
    {
        // 添加null检查
        if (dto is null) return null;

        if (dto.VariableTable is not null)
        {
            dto.VariableTable.Protocol = dto.Device.Protocol;
            dto.VariableTableMenu.MenuType = MenuType.VariableTableMenu;
        }


        //查找到设备的根菜单
        var parentMenu
            = _appDataService.Menus.Values.FirstOrDefault(m => m.TargetViewKey == nameof(DevicesViewModel) &&
                                                                  m.TargetId == 0);
        if (parentMenu is not null)
        {
            dto.DeviceMenu.MenuType = MenuType.DeviceMenu;
            dto.DeviceMenu.ParentId = parentMenu.Id;
        }

        var addDto = await _appCenterService.DeviceManagementService.CreateDeviceWithDetailsAsync(dto);

        // 添加null检查
        if (addDto is null) return null;

        //给界面添加设备
        DeviceItem deviceItem = _mapper.Map<DeviceItem>(addDto.Device);
        _viewDataService.Devices.Add(addDto.Device.Id, deviceItem);
        foreach (var variableTable in deviceItem.VariableTables)
        {
            _viewDataService.VariableTables.Add(variableTable.Id,variableTable);
        }

        // 给界面添加设备菜单
        if (addDto.DeviceMenu != null)
        {
            MenuItem menuItem = _mapper.Map<MenuItem>(addDto.DeviceMenu);
            _menuDataService.AddMenuToView(menuItem);
        }



        return addDto;
    }

    /// <summary>
    /// 删除设备。
    /// </summary>
    public async Task<bool> DeleteAsync(DeviceItem deviceItem)
    {

        if (!_appDataService.Devices.TryGetValue(deviceItem.Id, out var device))
        {
            return false;
        }

        //从数据库和内存中删除设备相关数据
        if (!await _appCenterService.DeviceManagementService.DeleteAsync(device))
        {
            return false;
        }


        // 从界面删除设备相关数据集
        foreach (var variableTable in deviceItem.VariableTables)
        {
            foreach (var variableItem in variableTable.Variables)
            {
                _viewDataService.Variables.Remove(variableItem.Id);
            }
            _viewDataService.VariableTables.Remove(deviceItem.Id);
        }

        //删除菜单
        var deviceMenu
            = _viewDataService.Menus.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu &&
                                                            m.TargetId == deviceItem.Id);
        if (deviceMenu != null)
        {
             _menuDataService.DeleteMenuToView(deviceMenu);
        }

        _viewDataService.Devices.Remove(deviceItem.Id);


        return true;
    }

    /// <summary>
    /// 更新设备。
    /// </summary>
    public async Task<bool> UpdateDevice(DeviceItem device)
    {
        if (!_appDataService.Devices.TryGetValue(device.Id, out var deviceInMen))
        {
            return false;
        }
        //更新内存中的设备数据
        _mapper.Map(device, deviceInMen);

        if (await _appCenterService.DeviceManagementService.UpdateDeviceAsync(deviceInMen) > 0)
        {
            //更新界面中的设备数据
            if (_viewDataService.Devices.TryGetValue(device.Id, out var deviceInView))
            {
                _mapper.Map(device, deviceInView);
            }
            //更新设备菜单名称
            var deviceMenuItem = _viewDataService.Menus
                 .FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
            if (deviceMenuItem is not null && deviceMenuItem.Header != device.Name)
            {
                deviceMenuItem.Header = device.Name;
            }


                return true;
        }

        return false;
    }
}