using CapMachine.Core;
using CapMachine.Shared.Controls;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.Models;
using CapMachine.Wpf.Models.Tag;
using CapMachine.Wpf.PrismEvent;
using CapMachine.Wpf.Services;
using ImTools;
using Prism.Commands;
using Prism.Events;
using Prism.Services.Dialogs;
using System.Collections.ObjectModel;
using System.Windows.Controls.Primitives;
using static CapMachine.Wpf.Models.ComEnum;

namespace CapMachine.Wpf.ViewModels
{
    public class MonitorViewModel : NavigationViewModel
    {
        /// <summary>
        /// 实例化函数
        /// </summary>
        /// <param name="configService"></param>
        /// <param name="eventAggregator"></param>
        /// <param name="dataRecordService"></param>
        /// <param name="sysRunService"></param>
        /// <param name="machineRtDataService"></param>
        /// <param name="dialogService"></param>
        public MonitorViewModel(ConfigService configService, IEventAggregator eventAggregator,
            DataRecordService dataRecordService, SysRunService sysRunService, AlarmService alarmService, PPCService pPCService, CanDriveService canDriveService, LinDriveService linDriveService,
            ProRuntimeService proRuntimeService,
            MachineRtDataService machineRtDataService, IDialogService dialogService)
        {
            ConfigService = configService;
            //事件服务
            _EventAggregator = eventAggregator;
            DataRecordService = dataRecordService;
            SysRunServer = sysRunService;
            AlarmService = alarmService;
            PPCService = pPCService;
            CanDriveService = canDriveService;
            LinDriveService = linDriveService;
            ProRuntimeService = proRuntimeService;
            MachineRtDataService = machineRtDataService;
            DialogService = dialogService;
            TagManager = MachineRtDataService.TagManger;
            _EventAggregator.GetEvent<ChartRtEvent>().Subscribe(GetChartRtEvent);
            _EventAggregator.GetEvent<ProRunEvent>().Subscribe(GetProRunEvent);

            //赋值实例化
            ListHandSwitchData = MachineRtDataService.ListHandSwitchData;

            ListTag = new ObservableCollection<ITag>(TagManager.DicTags.Values.ToList());
            ListMeterTag = TagManager.DicTags.Values.Where(a => a.IsMeter == true).ToList();

            SpeedTag = TagManager.DicTags.GetValueOrDefault("转速[rpm]");
            ExPressTag = TagManager.DicTags.GetValueOrDefault("排气压力[BarA]");
            ExTempTag = TagManager.DicTags.GetValueOrDefault("排气温度[℃]");
            InhPressTag = TagManager.DicTags.GetValueOrDefault("吸气压力[BarA]");
            InhTempTag = TagManager.DicTags.GetValueOrDefault("吸气温度[℃]");
            ComCapBusVolTag = TagManager.DicTags.GetValueOrDefault("通讯母线电压[V]");
            ComCapBusCurTag = TagManager.DicTags.GetValueOrDefault("通讯母线电流[A]");
            ComCapPwTag = TagManager.DicTags.GetValueOrDefault("通讯功率[W]");
            OS2TempTag = TagManager.DicTags.GetValueOrDefault("吸气混合器温度[℃]");
            TxvFrTempTag = TagManager.DicTags.GetValueOrDefault("膨胀阀前温度[℃]");
            TxvFrPressTag = TagManager.DicTags.GetValueOrDefault("膨胀阀前压力[BarA]");
            Cond1TempTag = TagManager.DicTags.GetValueOrDefault("冷凝器出口水温[℃]");
            CondInTempTag = TagManager.DicTags.GetValueOrDefault("冷凝器进口温度[℃]");


        }

        public ConfigService ConfigService { get; }

        private IEventAggregator _EventAggregator { get; set; }
        public DataRecordService DataRecordService { get; }
        public SysRunService SysRunServer { get; }
        public AlarmService AlarmService { get; }
        public PPCService PPCService { get; }
        public CanDriveService CanDriveService { get; }
        public LinDriveService LinDriveService { get; }
        public ProRuntimeService ProRuntimeService { get; }
        public MachineRtDataService MachineRtDataService { get; }
        public IDialogService DialogService { get; }
        public List<ChartRtValue> ListChartRtValue { get; set; } = new List<ChartRtValue>()
        {
            new ChartRtValue(){ Name="温度",Value=12.3,Unit="℃"},
            new ChartRtValue(){ Name="压力",Value=12.3,Unit="bar"},
            new ChartRtValue(){ Name="湿度",Value=12.3,Unit="%"},
        };

        private ObservableCollection<ITag> _ListTag;
        /// <summary>
        /// 标签集合信息
        /// </summary>
        public ObservableCollection<ITag> ListTag
        {
            get { return _ListTag; }
            set { _ListTag = value; RaisePropertyChanged(); }
        }

        private List<ITag> _ListMeterTag;
        /// <summary>
        /// 标签集合信息 仪表的参数
        /// </summary>
        public List<ITag> ListMeterTag
        {
            get { return _ListMeterTag; }
            set { _ListMeterTag = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 标签中心
        /// </summary>
        public TagManager TagManager { get; set; }

        //// <summary>
        ///// 手自动切换集合数据
        ///// </summary>
        public List<HandSwitchData> ListHandSwitchData { get; set; }

        /// <summary>
        /// 复位标签
        /// </summary>
        public HandSwitchData ResetTag { get; set; }


        /// <summary>
        /// 消音标签
        /// </summary>
        public HandSwitchData MuteTag { get; set; }

        #region 工艺图数据

        /// <summary>
        /// 转速标签
        /// </summary>
        public ITag SpeedTag { get; set; }

        /// <summary>
        /// 排气压力
        /// </summary>
        public ITag ExPressTag { get; set; }

        /// <summary>
        /// 排气温度
        /// </summary>
        public ITag ExTempTag { get; set; }

        /// <summary>
        /// 吸气压力
        /// </summary>
        public ITag InhPressTag { get; set; }

        /// <summary>
        /// 吸气温度
        /// </summary>
        public ITag InhTempTag { get; set; }

        /// <summary>
        /// 通讯母线电压
        /// </summary>
        public ITag ComCapBusVolTag { get; set; }

        /// <summary>
        /// 通讯母线电流
        /// </summary>
        public ITag ComCapBusCurTag { get; set; }

        /// <summary>
        /// 通讯功率
        /// </summary>
        public ITag ComCapPwTag { get; set; }

        /// <summary>
        /// 吸气混合器温度
        /// </summary>
        public ITag OS2TempTag { get; set; }

        /// <summary>
        /// 膨胀阀前温度
        /// </summary>
        public ITag TxvFrTempTag { get; set; }

        /// <summary>
        /// 膨胀阀前压力
        /// </summary>
        public ITag TxvFrPressTag { get; set; }

        /// <summary>
        /// 冷凝器出口水温
        /// </summary>
        public ITag Cond1TempTag { get; set; }

        /// <summary>
        /// 冷凝器进口温度
        /// </summary>
        public ITag CondInTempTag { get; set; }

        #endregion

        private DelegateCommand<string> _OperCmd;
        /// <summary>
        /// 操作指令你
        /// </summary>
        public DelegateCommand<string> OperCmd
        {
            set
            {
                _OperCmd = value;
            }
            get
            {
                if (_OperCmd == null)
                {
                    _OperCmd = new DelegateCommand<string>((p) => OperCmdCall(p));
                }
                return _OperCmd;
            }
        }





        /// <summary>
        /// 操作指令执行方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void OperCmdCall(string Par)
        {
            switch (Par)
            {
                case "开始":
                    //状态机运行 用状态机的状态判断逻辑
                    if (this.SysRunServer.MachineRunState1.FireStart())
                    {
                        //程序步骤执行开始运行
                        ProRuntimeService.StartProRun();
                        //运行 一些PLC的状态写入
                        MachineRtDataService.SysStart();
                        //开始记录数据
                        DataRecordService.StartRecord();
                        
                    }

                    break;
                case "结束":
                    //状态机结束 用状态机的状态判断逻辑
                    if (this.SysRunServer.MachineRunState1.FireEnd())
                    {
                        //程序步骤执行结束运行
                        ProRuntimeService.EndProRun();
                        //结束 一些PLC的状态写入
                        MachineRtDataService.SysEnd();
                        //结束记录数据
                        DataRecordService.EndRecord();

                        //结束运行的时候，需要将压缩机的速度值设置为0
                        switch (ConfigService.CanLinRunStateModel.CurSysSelectedCanLin)
                        {
                            case CanLinEnum.Can:
                                //获取PLC的SV数据 更新SV的速度值到压缩机
                                CanDriveService.UpdateSpeedCmdData(0);
                                //itemTag.Value.EngPvValue = 0;
                                break;
                            case CanLinEnum.Lin:
                                //获取PLC的SV数据 更新SV的速度值到压缩机
                                LinDriveService.UpdateSpeedCmdData(0);
                                //itemTag.Value.EngPvValue = 0;
                                break;
                            default:
                                break;
                        }
                    }

                    break;
                case "复位":
                    //状态机 复位 用状态机的状态判断逻辑
                    if (this.SysRunServer.MachineRunState1.FireReset())
                    {
                        //程序步骤执行结束运行
                        ProRuntimeService.EndProRun();
                        //复位 一些PLC的状态写入
                        MachineRtDataService.SysReset();
                        //结束记录数据
                        DataRecordService.EndRecord();

                        //结束运行的时候，需要将压缩机的速度值设置为0
                        switch (ConfigService.CanLinRunStateModel.CurSysSelectedCanLin)
                        {
                            case CanLinEnum.Can:
                                //获取PLC的SV数据 更新SV的速度值到压缩机
                                CanDriveService.UpdateSpeedCmdData(0);
                                //itemTag.Value.EngPvValue = 0;
                                break;
                            case CanLinEnum.Lin:
                                //获取PLC的SV数据 更新SV的速度值到压缩机
                                LinDriveService.UpdateSpeedCmdData(0);
                                //itemTag.Value.EngPvValue = 0;
                                break;
                            default:
                                break;
                        }

                    }

                    break;
                case "消音":

                    MachineRtDataService.SysMute();

                    //ShowDialogExpInfo(); 
                    break;
                case "暂停":

                    //状态机 暂停 用状态机的状态判断逻辑
                    if (this.SysRunServer.MachineRunState1.FirePause())
                    {
                        //程序步骤执行暂停运行
                        ProRuntimeService.PauseProRun();
                        //暂停 一些PLC的状态写入
                        MachineRtDataService.SysPause();

                    }

                    break;
                case "继续":
                    //状态机 继续 用状态机的状态判断逻辑
                    if (this.SysRunServer.MachineRunState1.FireContinue())
                    {
                        //程序步骤执行继续运行
                        ProRuntimeService.ContinueProRun();
                        //继续 一些PLC的状态写入
                        MachineRtDataService.SysContinue();
                    }
                    //ShowDialogExpInfo(); 
                    break;
                case "试验信息":
                    ShowDialogExpInfo();
                    break;
                case "SuperHeatCool":
                    //ShowSuperHeatCool();
                    break;
                default:
                    break;
            }
        }



        /// <summary>
        /// 程序运行的状态
        /// 来自于程序的自动调度执行
        /// </summary>
        /// <param name="msg"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void GetProRunEvent(ProRunEventMsg msg)
        {
            switch (msg.Msg)
            {
                case "执行完毕":
                    OperCmdCall("结束");
                    break;
                default:
                    break;
            }

        }



        private DelegateCommand<object> _AutoHandCmd;
        /// <summary>
        /// 操作指令你
        /// </summary>
        public DelegateCommand<object> AutoHandCmd
        {
            set
            {
                _AutoHandCmd = value;
            }
            get
            {
                if (_AutoHandCmd == null)
                {
                    _AutoHandCmd = new DelegateCommand<object>((p) => AutoHandCmdCall(p));
                }
                return _AutoHandCmd;
            }
        }
        /// <summary>
        /// 操作指令执行方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void AutoHandCmdCall(object Par)
        {
            if (Par != null && Par is Meter)
            {
                //True-手动，False-自动
                var MeterControl = (Meter)Par;
                Console.WriteLine($"{MeterControl.MeterName}-{MeterControl.AutoHandState}");

                //
                foreach (var item in TagManager.DicTags)
                {
                    if (item.Value.NameNoUnit == MeterControl.MeterName)
                    {
                        if (!string.IsNullOrEmpty(item.Value.AutoHandSwitchAddress))
                        {
                            var Result = MachineRtDataService.SiemensDrive.Write(item.Value.AutoHandSwitchAddress, MeterControl.AutoHandState == true ? (short)1 : (short)0);
                        }
                        break;
                    }
                }
            }

        }

        private DelegateCommand<object> _HandValueCmd;
        /// <summary>
        /// 手动给值
        /// </summary>
        public DelegateCommand<object> HandValueCmd
        {
            set
            {
                _HandValueCmd = value;
            }
            get
            {
                if (_HandValueCmd == null)
                {
                    _HandValueCmd = new DelegateCommand<object>((p) => HandValueCmdCall(p));
                }
                return _HandValueCmd;
            }
        }
        /// <summary>
        /// 手动给值执行方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void HandValueCmdCall(object Par)
        {
            if (Par != null && Par is MeterChannelValue)
            {
                var ChannelValue = (MeterChannelValue)Par;
                Console.WriteLine($"{ChannelValue.Name}-{ChannelValue.Value}-{ChannelValue.Type}");

                //
                foreach (var item in TagManager.DicTags)
                {
                    if (item.Value.NameNoUnit == ChannelValue.Name)
                    {
                        switch (ChannelValue.Type)
                        {
                            case "MV"://10的倍率
                                if (!string.IsNullOrEmpty(item.Value.MVAddress))
                                {
                                    var Result = MachineRtDataService.SiemensDrive.Write(item.Value.MVAddress, (short)((double)ChannelValue.Value * 10));
                                    break;
                                }
                                break;
                            case "SV":
                                if (!string.IsNullOrEmpty(item.Value.SVAddress))
                                {
                                    var Result = MachineRtDataService.SiemensDrive.Write(item.Value.SVAddress, (short)((double)ChannelValue.Value * item.Value.Precision));
                                    break;
                                }
                                break;
                            default:
                                break;
                        }

                    }
                }
            }
        }

        private int _HandValueParameter = 80;
        /// <summary>
        /// 手动的值，直接和控件绑定，初始的时候用，也可以用做更新采集的数据到界面上
        /// 当前是所有的控件都绑定的
        /// </summary>
        public int HandValueParameter
        {
            get { return _HandValueParameter; }
            set { _HandValueParameter = value; RaisePropertyChanged(); }
        }


        private DelegateCommand<object> _HandEnableCmd;
        /// <summary>
        /// 阀门的手自动切换
        /// </summary>
        public DelegateCommand<object> HandEnableCmd
        {
            set
            {
                _HandEnableCmd = value;
            }
            get
            {
                if (_HandEnableCmd == null)
                {
                    _HandEnableCmd = new DelegateCommand<object>((p) => HandEnableCmdCall(p));
                }
                return _HandEnableCmd;
            }
        }

        /// <summary>
        /// 操作指令执行方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void HandEnableCmdCall(object Par)
        {
            if (Par != null && Par is ToggleButton)
            {
                var ControlData = Par as ToggleButton;
                var Name = ControlData.ToolTip;
                var Data = ControlData.IsChecked;
                //ToDo cmd

                var FindData = ListHandSwitchData.FirstOrDefault(a => a.Name == Name);
                if (FindData != null)
                {
                    if (Name == "自动")
                    {
                        //手动切换是可以自由的切换，不受限制

                        //ToDo
                        Console.WriteLine($"{FindData.Name}-{FindData.ActionAddress}-{FindData.StateAddress}-{Data}");
                        var Result = MachineRtDataService.SiemensDrive.Write(FindData.ActionAddress, (bool)Data);
                        if (Result.IsSuccess)
                        {

                        }
                    }
                    else
                    {
                        //其他的手自动切换受条件过滤处理
                        if (!MachineRtDataService.AutoHandSwtichConditionState.IsCanSwitch)
                        {
                            System.Windows.MessageBox.Show("当前的切换需要在【手动】和【无报警】的情况下进行");
                            return;
                        }

                        //满足条件进行操作，只进行True操作,PLC会处理的
                        Console.WriteLine($"{FindData.Name}-{FindData.ActionAddress}-{FindData.StateAddress}-{Data}");
                        var Result = MachineRtDataService.SiemensDrive.Write(FindData.ActionAddress, true);
                        if (Result.IsSuccess)
                        {

                        }
                    }

                    //FindData.State = false;
                }
            }

        }

        /// <summary>
        /// 试验信息弹窗
        /// </summary>
        private void ShowDialogExpInfo()
        {
            //弹窗
            DialogService.ShowDialog("DialogExpInfoView", new DialogParameters() { { "Name", "" } }, (par) =>
            {
                if (par.Result == ButtonResult.OK)
                {
                    //试验信息
                    var ListChartTabGroupDto = par.Parameters.GetValue<ExpInfoDto>("ReturnValue");


                }
                else if (par.Result == ButtonResult.Cancel)
                {
                    //取消

                }

            });
        }


        /// <summary>
        /// 获取曲线的实时值
        /// 数据是发布过来
        /// </summary>
        /// <param name="value"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void GetChartRtEvent(List<ChartRtValue> RtData)
        {
            //ListChartRtValue = RtData;

        }
    }
}