using Caliburn.Micro;
using Caliburn.Micro.Core;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.UI.ControlDataContext;
using Aitex.Core.Util;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using FurnaceUI.Models;
using FurnaceUI.Views.Editors;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Reflection;
using System;
using Aitex.Core.RT.Log;
using System.Linq;
using System.Windows;

namespace FurnaceUI.Views.Maintenances
{
    public class BoatSensorViewModel : FurnaceUIViewModelBase
    {
        public bool IsManagerPermission { get => this.Permission == 3; }

        #region boat sensors
        [Subscription("System.SensorASOpenPosition.DeviceData")]
        public AITSensorData SensorASOpenPosition { get; set; }
        [Subscription("System.SensorASClosePosition.DeviceData")]
        public AITSensorData SensorASClosePosition { get; set; }
        [Subscription("System.SensorASUpPositionW.DeviceData")]
        public AITSensorData SensorASUpPositionW { get; set; }
        [Subscription("System.SensorASDownPosition.DeviceData")]
        public AITSensorData SensorASDownPosition { get; set; }
        [Subscription("System.SensorASOpenStatus.DeviceData")]
        public AITSensorData SensorASOpenStatus { get; set; }
        [Subscription("System.SensorASTiltStatus.DeviceData")]
        public AITSensorData SensorASTiltStatus { get; set; }
        [Subscription("System.SensorSideDoorFfuOK.DeviceData")]
        public AITSensorData SensorSideDoorFfuOK { get; set; }
        [Subscription("System.SensorZAxisUpLimit.DeviceData")]
        public AITSensorData SensorZAxisUpLimit { get; set; }
        [Subscription("System.SensorZAxisDownLimit.DeviceData")]
        public AITSensorData SensorZAxisDownLimit { get; set; }
        [Subscription("System.SensorBEHumanInterlock.DeviceData")]
        public AITSensorData SensorBEHumanInterlock { get; set; }
        [Subscription("System.SensorTAxisHome.DeviceData")]
        public AITSensorData SensorTAxisHome { get; set; }
        [Subscription("System.SensorCapClose.DeviceData")]
        public AITSensorData SensorCapClose { get; set; }
        [Subscription("System.SensorZone1.DeviceData")]
        public AITSensorData SensorZone1 { get; set; }
        [Subscription("System.SensorZone2.DeviceData")]
        public AITSensorData SensorZone2 { get; set; }
        [Subscription("System.SensorR5ArmNotExtendToBE.DeviceData")]
        public AITSensorData SensorR5ArmNotExtendToBE { get; set; }
        [Subscription("System.SensorCapILOK.DeviceData")]
        public AITSensorData SensorCapILOK { get; set; }
        [Subscription("System.SensorPPPosition.DeviceData")]
        public AITSensorData SensorPPPosition { get; set; }
        [Subscription("System.SensorHomePosition.DeviceData")]
        public AITSensorData SensorHomePosition { get; set; }
        [Subscription("PM1.Status")]
        public string PM1Status { get; set; }
        [Subscription("Boat.Status")]
        public string BoatStatus { get; set; }
        [Subscription("WaferRobot.Status")]
        public string WaferRobotStatus { get; set; }
        [Subscription("Boat.BoatPosition")]
        public string BoatPosition { get; set; }
        [Subscription("AutoShutter.OpenCloseStatus")]
        public string AutoShutterOpenCloseStatus { get; set; }
        [Subscription("AutoShutter.UpDownStatus")]
        public string AutoShutterUpDownStatus { get; set; }
        [Subscription("Boat.IsBoatRotating")]
        public bool IsBoatRotating { get; set; }

        #endregion

        public ObservableCollection<SensorViewItem> BoatSensors { get; set; } = new ObservableCollection<SensorViewItem>();
        public bool IsEnableHomeOperation => BoatStatus == "Idle" || BoatStatus == "Init";
        public bool IsEnableManualOperation => BoatStatus == "Idle";
        public bool IsWaferRobotInitialized
        {
            get
            {
                return WaferRobotStatus != "Init" && WaferRobotStatus != "Homing";
            }
        }
        public string BoatRotateSttus => IsBoatRotating ? "Rotating" : "Stop";

        public BoatSensorViewModel()
        {

        }

        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeBeforeUpdateProperty(data);
            if (BoatSensors.Count == 0)
            {
                foreach (var key in data.Keys)
                {
                    if (!key.ToLower().Contains("pm1.status") && !key.ToLower().Contains("waferrobot.status") && !key.ToLower().Contains("boat.boatposition") &&
                        !key.ToLower().Contains("autoshutter.openclosestatus") && !key.ToLower().Contains("autoshutter.updownstatus") && !key.ToLower().Contains("boat.status") &&
                        !key.ToLower().Contains("boat.isboatrotating"))
                    {
                        BoatSensors.Add(new SensorViewItem()
                        {
                            Index = BoatSensors.Count + 1,
                            Name = (data[key] as AITSensorData).DeviceName,
                            DisplayName = (data[key] as AITSensorData).DisplayName,
                        });
                    }
                }
            }
        }

        public override void UpdateSubscribe(Dictionary<string, object> data, object target, string module = null)
        {
            Parallel.ForEach(target.GetType().GetProperties().Where(_hasSubscriptionAttribute),
                 property =>
                 {
                     PropertyInfo pi = (PropertyInfo)property;
                     SubscriptionAttribute subscription = property.GetCustomAttributes(false).First(_isSubscriptionAttribute) as SubscriptionAttribute;
                     string key = subscription.ModuleKey;
                     key = module == null ? key : string.Format("{0}.{1}", module, key);

                     if (_subscribedKeys.Contains(key) && data.ContainsKey(key))
                     {
                         try
                         {
                             var convertedValue = Convert.ChangeType(data[key], pi.PropertyType);
                             var originValue = Convert.ChangeType(pi.GetValue(target, null), pi.PropertyType);
                             if ((convertedValue as AITSensorData) != null && originValue != convertedValue)
                             {
                                 pi.SetValue(target, convertedValue, null);
                                 //if ((convertedValue as AITSensorData).DeviceName.ToLower().Contains(_para))
                                 //{
                                 Update(BoatSensors, convertedValue as AITSensorData);
                                 //}

                             }
                         }
                         catch (Exception ex)
                         {
                             LOG.Error("由RT返回的数据更新失败" + key, ex);
                         }
                     }
                 });
            base.UpdateSubscribe(data, target, module);
        }

        private void Update(ObservableCollection<SensorViewItem> sensors, object obj)
        {
            AITSensorData data = obj as AITSensorData;
            if (data != null && sensors.Count > 0)
            {
                var item = sensors.SingleOrDefault(x => x.Name == data.DeviceName);
                if (item != null)
                {
                    item.Value = data.Value;
                }
            }
        }

        public void Home()
        {
            InvokeClient.Instance.Service.DoOperation($"Boat.Home");
        }

        public void SetBoatZAxisMotion(object para)
        {
            InvokeClient.Instance.Service.DoOperation($"Boat.ZAxisManualMove", para.ToString());
        }

        public void SetShutterOpen(object para)
        {
            InvokeClient.Instance.Service.DoOperation($"PM1.SetAutoShutterOpen", para.ToString());
        }

        public void SetAutoShutterUp(object para)
        {
            InvokeClient.Instance.Service.DoOperation($"PM1.SetAutoShutterUp", para.ToString());
        }

        public void SetBoatRotate(object para)
        {
            InvokeClient.Instance.Service.DoOperation($"Boat.RAxisMove", para.ToString());
        }

        public void ClosedCmd()
        {
            (GetView() as Window).Close();
        }
    }
}