using UIShare.UIViewModel;
using UIShare.GlobalVariable;
using UIShare.PubEvent;
using Logger;
using MaterialDesignThemes.Wpf;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Reflection;
using System.Windows.Input;
using System.Xml;
using UIShare.ViewModelBase;
using Prism.Events;

namespace TestingModule.ViewModels
{
    public class ParametersManagerViewModel:NavigateViewModelBase, IDisposable
    {
        #region 属性
        //private ObservableCollection<DeviceConfigModel> _DeviceList;

        //public ObservableCollection<DeviceConfigModel> DeviceList
        //{
        //    get { return _DeviceList; }
        //    set { SetProperty(ref _DeviceList,value); }
        //}
        private ObservableCollection<DeviceInfoVM> _DeviceInfoModel;

        public ObservableCollection<DeviceInfoVM> DeviceInfoVM
        {
            get { return _DeviceInfoModel; }
            set { SetProperty(ref _DeviceInfoModel, value); }
        }

        public ProgramVM Program
        {
            get => _ScopedContext.Program;
            set
            {
                if (_ScopedContext.Program != value)
                {
                    _ScopedContext.Program = value;
                    RaisePropertyChanged();
                }
            }
        }
        private ParameterVM _SelectedParameter;
        public ParameterVM SelectedParameter
        {
            get => _SelectedParameter;
            set
            {
                if (SetProperty(ref _SelectedParameter, value))
                {
                    _ScopedContext.SelectedParameter = value;
                }
            }
        }
        private DeviceInfoVM _SelectedDevice;

        

        public DeviceInfoVM SelectedDevice
        {
            get { return _SelectedDevice; }
            set { SetProperty(ref _SelectedDevice, value); }
        }
        #endregion
        private ScopedContext _ScopedContext { get; set; }
        private readonly SystemConfig _systemConfig;
        private readonly GlobalInfo _globalInfo;
        private readonly DeviceManager _deviceManager;
        private readonly IContainerProvider _containerProvider;
        #region 命令
        public ICommand ParameterAddCommand { get; set; }
        public ICommand ParameterEditCommand { get; set; }
        public ICommand ParameterDeleteCommand { get; set; }
        public ICommand DeviceEditCommand { get; set; }
        public ICommand ReConnectCommand { get; set; }
        public ICommand CloseCommand { get; set; }
        public ICommand LoadedCommand { get; set; }
        #endregion

        public ParametersManagerViewModel(IContainerProvider containerProvider) : base(containerProvider)
        {

            _ScopedContext = containerProvider.Resolve<ScopedContext>();
            _systemConfig = containerProvider.Resolve<SystemConfig>();
            _deviceManager = containerProvider.Resolve<DeviceManager>();
            _globalInfo = containerProvider.Resolve<GlobalInfo>();
            _containerProvider = containerProvider;
            Program = _ScopedContext.Program;
            ParameterAddCommand = new DelegateCommand(ParameterAdd);
            ParameterEditCommand = new DelegateCommand(ParameterEdit);
            ParameterDeleteCommand = new DelegateCommand(ParameterDelete);
            DeviceEditCommand = new DelegateCommand(DeviceEdit);
            ReConnectCommand = new AsyncDelegateCommand(OnReConnect);
            CloseCommand = new AsyncDelegateCommand(OnClose);
            LoadedCommand = new DelegateCommand(OnLoad);
        }
        #region 委托命令
        private void OnLoad()
        {
            DeviceInfoVM = _systemConfig.DeviceList;
        }  private async Task OnReConnect()
        {
            await _deviceManager.ConnectSpecifiedDevice(SelectedDevice.DeviceName);
        }  private async Task OnClose()
        {
            await _deviceManager.CloseDeviceAsync(SelectedDevice.DeviceName);
        }
        /// <summary>
        /// 跟踪已打开的弹窗管理器窗口实例，避免重复打开多个 DialogMangerView 窗口。
        /// </summary>
        private static System.Windows.Window? _dialogWindow;

        private void DeviceEdit()
        {
            if (!_globalInfo.IsAdmin) return;
            if (SelectedDevice == null) return;
            var type = SelectedDevice.DeviceType.Split('.').Last();
            var viewName = type + "View";

            try
            {
                // 1. 先确保弹窗管理器窗口已打开（首次 Show，后续只追加 Tab）
                if (_dialogWindow == null || !_dialogWindow.IsVisible)
                {
                    _dialogService.Show("DialogMangerView");

                    // 找到刚刚被 DialogService 打开的窗口（按 DataContext 类型名匹配）
                    _dialogWindow = System.Windows.Application.Current.Windows
                        .OfType<System.Windows.Window>()
                        .FirstOrDefault(w => w.DataContext?.GetType().Name == "DialogMangerViewModel");
                }

                // 2. 从容器按注册名解析设备编辑 View
                var view = _containerProvider.Resolve<object>(viewName) as System.Windows.FrameworkElement;
                if (view == null) return;

                // 3. 通过反射调用 ViewModel 上的 Initialize(deviceName) 方法，
                //    避免 TestingModule 直接引用 DeviceEditModule 的类型
                var vm = view.DataContext;
                if (vm != null)
                {
                    var initMethod = vm.GetType().GetMethod("Initialize", new[] { typeof(string) });
                    initMethod?.Invoke(vm, new object[] { SelectedDevice.DeviceName });
                }

                // 4. 发布事件 → DialogMangerViewModel 接收后将此 View 添加为 Tab
                _eventAggregator.GetEvent<AddDialogTabEvent>().Publish(new DialogTabInfo
                {
                    Title   = $"{type} [{SelectedDevice.DeviceName}]",
                    Content = view
                });

                // 5. 将窗口置顶（确保用户看到新增的 Tab）
                if (_dialogWindow != null && _dialogWindow.IsVisible)
                {
                    if (_dialogWindow.WindowState == System.Windows.WindowState.Minimized)
                        _dialogWindow.WindowState = System.Windows.WindowState.Normal;
                    _dialogWindow.Activate();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorWithNotify($"打开设备编辑窗口 [{type}] 失败：{ex.Message}");
            }
        }

        private void ParameterDelete()
        {
            if (!_globalInfo.IsAdmin) return;
            Program.Parameters.Remove(SelectedParameter);
        }

        private void ParameterEdit()
        {
            if (!_globalInfo.IsAdmin) return;
            var param = new DialogParameters
            {
                { "Mode",SelectedParameter==null?"ADD":"Edit" },
                { "ScopedContext",_ScopedContext }
            };
            _dialogService.ShowDialog("ParameterSetting", param, (r) =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    _eventAggregator.GetEvent<ParamsChangedEvent>().Publish();
                }
                else
                {

                }
                
            });
        }

        private void ParameterAdd()
        {
            if (!_globalInfo.IsAdmin) return;
            var param = new DialogParameters
            {
                { "Mode", "ADD" },
                { "ScopedContext",_ScopedContext }
            };
            _dialogService.ShowDialog("ParameterSetting", param, (r) =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    _eventAggregator.GetEvent<ParamsChangedEvent>().Publish();
                }
                else
                {

                }
                
            });
        }


        #endregion
        public void Dispose()
        {
            try
            {
                DeviceInfoVM?.Clear();
                DeviceInfoVM = null!;
                SelectedParameter = null!;
                SelectedDevice = null!;
                if (_ScopedContext != null)
                {
                    _ScopedContext.SelectedParameter = null;
                    _ScopedContext = null!;
                }
            }
            catch (Exception ex)
            {
                Logger.LoggerHelper.Error($"释放参数管理组件（ParametersManagerViewModel）资源失败: {ex.Message}");
            }
        }
    }
}