using System;
using Prism.Mvvm;
using Prism.Events;
using Prism.Regions;
using Prism.Commands;
using System.Windows;
using SHJX.Service.Common.Event;
using SHJX.Service.Common.Constants;

using SHJX.Service.Common.Interface;
using SHJX.Service.Control.Interface;
using System.Runtime.InteropServices;
using SHJX.Service.Shell.Views.Manual;
using SHJX.Service.Shell.Views.TagForm;
using SHJX.Service.Shell.Views.Setting;

namespace SHJX.Service.Shell.ViewModels
{
    public class MainWindowViewModel : BindableBase
    {
        #region Field
        private readonly ILogService _log;
        private readonly IMainService _mainService;
        private readonly IWorkFlowService _workflowService;
        #endregion

        #region Property
        public IRegionManager RegionMannager { get; }

        /// <summary>
        /// 遮蔽层
        /// </summary>
        private Visibility _hiddenValue;
        public Visibility MainHiddenValue
        {
            get => _hiddenValue;
            set => SetProperty(ref _hiddenValue, value);
        }
        #endregion

        public MainWindowViewModel(IEventAggregator ea, IRegionManager regionManager, IMainService mainService, ILogService log, IWorkFlowService workflowService)
        {
            _log = log;
            _mainService = mainService;
            _workflowService = workflowService;
            RegionMannager = regionManager;
            MainHiddenValue = Visibility.Hidden;
            ea.GetEvent<WindowShowEvent>().Subscribe(WindowShowExecute);
            ea.GetEvent<LockDesktopEvent>().Subscribe(LockDesktopExecute);
        }

        #region Command
        private DelegateCommand<object> _loadingCommand;
        public DelegateCommand<object> LoadingCommand => _loadingCommand ??= new DelegateCommand<object>(ExecuteLoadingCommand);
        private DelegateCommand _closingCommand;
        public DelegateCommand ClosingCommand => _closingCommand ??= new DelegateCommand(ExecuteClosingCommand);
        #endregion

        #region Execute

        /// <summary>
        /// 加载
        /// </summary>
        /// <param name="obj"></param>
        private void ExecuteLoadingCommand(object obj)
        {
            _mainService.InitRepositorys().InitService().CheckExistResidueTask();
            HoldBackWindowsSleep(true);
        }

        /// <summary>
        /// 关闭
        /// </summary>
        private void ExecuteClosingCommand()
        {
            HoldBackWindowsSleep(false);
            try
            {
                _mainService.CloseCamera();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat(ex.ToString());
            }
            _mainService.StopHeating(EquipmentNames.DissolveHeating);
            _mainService.StopHeating(EquipmentNames.TitrationHeating);
            Application.Current.Shutdown();
        }

        /// <summary>
        /// 窗体展示
        /// </summary>
        /// <param name="windowName"></param>
        void WindowShowExecute(string windowName)
        {
            try
            {
                Window win = windowName switch
                {
                    "About" => new AboutWindow(),
                    "Setting" => new SettingWindow(),
                    "TaskTemplate" => new TemplateWindow(),
                    "ManualControl" => new ManualWindow(),
                    _ => throw new ArgumentNullException(windowName),
                };
                win.ShowDialog();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat(ex.ToString());
            }
        }

        /// <summary>
        /// 桌面锁定
        /// </summary>
        /// <param name="bl"></param>
        private void LockDesktopExecute(bool bl)
        {
            MainHiddenValue = bl ? Visibility.Visible : Visibility.Hidden;
        }
        #endregion

        #region 窗体休眠
        [DllImport("kernel32.dll")] //定义API函数
        private static extern uint SetThreadExecutionState(uint esFlags);
        private const uint ES_SYSTEM_REQUIRED = 0x00000001;
        private const uint ES_DISPLAY_REQUIRED = 0x00000002;
        private const uint ES_CONTINUOUS = 0x80000000;

        /// <summary>
        /// 阻止休眠
        /// </summary>
        /// <param name="sleepOrNot"></param>
        public static void HoldBackWindowsSleep(bool sleepOrNot)
        {
            SetThreadExecutionState(sleepOrNot ? ES_CONTINUOUS | ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED : ES_CONTINUOUS);//阻止休眠时调用
        }
        #endregion
    }
}