using System;
using System.Collections.Generic;
using System.Linq;
using Aitex.Core.Util;
using Aitex.Core.Common.DeviceData;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using FurnaceUI.Models;
using Caliburn.Micro;
using Caliburn.Micro.Core;
using System.Windows.Controls;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using FurnaceUI.Views.Editors;
using OpenSEMI.ClientBase;
using MECF.Framework.Common.OperationCenter;
using FurnaceUI.Client;
using MECF.Framework.Common.DataCenter;

namespace FurnaceUI.Views.Operations
{
    public class DDCModel
    {
        public DDCModel(string channel)
        {
            Channel = channel;
        }
        public string Channel { get; set; }

        public string SetValue { get; set; }

        public string TargetValue { get; set; }

        public string ActValue { get; set; }

        public string DevValue { get; set; }

        public string UpRate { get; set; }

        public string DownRate { get; set; }

        public string Power { get; set; }

        public string P { get; set; }

        public string I { get; set; }

        public string D { get; set; }
        public bool IsPVBreak { get; set; }

        public bool IsTempErr { get; set; }
    }


    public class TemperatureViewModel : FurnaceUIViewModelBase
    {
        public bool IsManagerPermission { get; set; } = false;
        public bool IsLspMode { get; set; } = false;
        private TemperatureView _view;

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            _view = (TemperatureView)view;
        }

        public double URange = 9.9;
        public double DevU => HeaterUData.FeedBack - HeaterUData.SetPoint;
        public double TCDevU => HeaterUData.HeaterPV - HeaterUData.OverTemp;
        public double PositiveULength
        {
            get
            {

                if (HeaterUData.SetPoint - HeaterUData.FeedBack <= 0)
                {
                    return 0;
                }
                else if (HeaterUData.SetPoint - HeaterUData.FeedBack <= URange)
                {
                    return ((HeaterUData.SetPoint - HeaterUData.FeedBack) / URange) * 150;
                }
                return 300;
            }
        }
        public double NegativeULength
        {
            get
            {

                if (HeaterUData.SetPoint - HeaterUData.FeedBack >= 0)
                {
                    return 0;
                }
                else if (HeaterUData.SetPoint - HeaterUData.FeedBack >= -URange)
                {
                    return ((-(HeaterUData.SetPoint - HeaterUData.FeedBack)) / URange) * 150;
                }
                return 300;
            }
        }

        public double DevCU => HeaterCUData.FeedBack - HeaterCUData.SetPoint;
        public double TCDevCU => HeaterCUData.HeaterPV - HeaterCUData.OverTemp;
        public double CURange = 9.9;
        public double PositiveCULength
        {
            get
            {

                if (HeaterCUData.SetPoint - HeaterCUData.FeedBack <= 0)
                {
                    return 0;
                }
                else if (HeaterCUData.SetPoint - HeaterCUData.FeedBack <= CURange)
                {
                    return ((HeaterCUData.SetPoint - HeaterCUData.FeedBack) / CURange) * 150;
                }
                return 300;
            }
        }
        public double NegativeCULength
        {
            get
            {

                if (HeaterCUData.SetPoint - HeaterCUData.FeedBack >= 0)
                {
                    return 0;
                }
                else if (HeaterCUData.SetPoint - HeaterCUData.FeedBack >= -CURange)
                {
                    return ((-(HeaterCUData.SetPoint - HeaterCUData.FeedBack)) / CURange) * 150;
                }
                return 300;
            }
        }

        public double DevC => HeaterCData.FeedBack - HeaterCData.SetPoint;
        public double TCDevC => HeaterCData.HeaterPV - HeaterCData.OverTemp;
        public double CRange = 9.9;
        public double PositiveCLength
        {
            get
            {

                if (HeaterCData.SetPoint - HeaterCData.FeedBack <= 0)
                {
                    return 0;
                }
                else if (HeaterCData.SetPoint - HeaterCData.FeedBack <= CRange)
                {
                    return ((HeaterCData.SetPoint - HeaterCData.FeedBack) / CRange) * 150;
                }
                return 300;
            }
        }
        public double NegativeCLength
        {
            get
            {

                if (HeaterCData.SetPoint - HeaterCData.FeedBack >= 0)
                {
                    return 0;
                }
                else if (HeaterCData.SetPoint - HeaterCData.FeedBack >= -CRange)
                {
                    return ((-(HeaterCData.SetPoint - HeaterCData.FeedBack)) / CRange) * 150;
                }
                return 300;
            }
        }

        public double DevCL => HeaterCLData.FeedBack - HeaterCLData.SetPoint;
        public double TCDevCL => HeaterCLData.HeaterPV - HeaterCLData.OverTemp;
        public double CLRange = 9.9;
        public double PositiveCLLength
        {
            get
            {

                if (HeaterCLData.SetPoint - HeaterCLData.FeedBack <= 0)
                {
                    return 0;
                }
                else if (HeaterCLData.SetPoint - HeaterCLData.FeedBack <= CLRange)
                {
                    return ((HeaterCLData.SetPoint - HeaterCLData.FeedBack) / CLRange) * 150;
                }
                return 300;
            }
        }
        public double NegativeCLLength
        {
            get
            {

                if (HeaterCLData.SetPoint - HeaterCLData.FeedBack >= 0)
                {
                    return 0;
                }
                else if (HeaterCLData.SetPoint - HeaterCLData.FeedBack >= -CLRange)
                {
                    return ((-(HeaterCLData.SetPoint - HeaterCLData.FeedBack)) / CLRange) * 150;
                }
                return 300;
            }
        }

        public double DevL => HeaterLData.FeedBack - HeaterLData.SetPoint;
        public double TCDevL => HeaterLData.HeaterPV - HeaterLData.OverTemp;
        public double LRange = 9.9;
        public double PositiveLLength
        {
            get
            {

                if (HeaterLData.SetPoint - HeaterLData.FeedBack <= 0)
                {
                    return 0;
                }
                else if (HeaterLData.SetPoint - HeaterLData.FeedBack <= LRange)
                {
                    return ((HeaterLData.SetPoint - HeaterLData.FeedBack) / LRange) * 150;
                }
                return 300;
            }
        }
        public double NegativeLLength
        {
            get
            {

                if (HeaterLData.SetPoint - HeaterLData.FeedBack >= 0)
                {
                    return 0;
                }
                else if (HeaterLData.SetPoint - HeaterLData.FeedBack >= -LRange)
                {
                    return ((-(HeaterLData.SetPoint - HeaterLData.FeedBack)) / LRange) * 150;
                }
                return 300;
            }
        }

        public double ZoneDevUCU => HeaterUData.FeedBack - HeaterCUData.FeedBack;
        public double ZoneDevCUC => HeaterCUData.FeedBack - HeaterCData.FeedBack;
        public double ZoneDevCCL => HeaterCData.FeedBack - HeaterCLData.FeedBack;
        public double ZoneDevCLL => HeaterCLData.FeedBack - HeaterLData.FeedBack;


        [Subscription("System.HeaterU.DeviceData")]
        public AITHeaterData HeaterUData { get; set; }

        [Subscription("System.HeaterCU.DeviceData")]
        public AITHeaterData HeaterCUData { get; set; }
        [Subscription("System.HeaterC.DeviceData")]
        public AITHeaterData HeaterCData { get; set; }
        [Subscription("System.HeaterCL.DeviceData")]
        public AITHeaterData HeaterCLData { get; set; }
        [Subscription("System.HeaterL.DeviceData")]
        public AITHeaterData HeaterLData { get; set; }

        public AITHeaterData BottomHeaterData => HeaterLData;
        public AITHeaterData CenterBottomHeaterData => HeaterCLData;
        public AITHeaterData CenterHeaterData => HeaterCData;
        public AITHeaterData TopCenterHeaterData => HeaterCUData;
        public AITHeaterData TopHeaterData => HeaterUData;

        [Subscription("PM1.Status")]
        public string PM1Status { get; set; }

        [Subscription("PM1.RecipeHold")]
        public bool PM1RecipeHold { get; set; }

        public bool IsMannualButtonEnabled
        {
            get
            {
                return PM1Status != "Process" || (PM1Status == "Process" && PM1RecipeHold);
            }
        }

        public string ErrStateStr
        {
            get
            {
                string _isErrState = "None";

                List<string> tempList = new List<string>();

                if (TopHeaterData?.IsAlarm == true)
                {
                    tempList.Add("U");
                }
                if (TopCenterHeaterData?.IsAlarm == true)
                {
                    tempList.Add("CU");
                }
                if (CenterHeaterData?.IsAlarm == true)
                {
                    tempList.Add("C");
                }
                if (CenterBottomHeaterData?.IsAlarm == true)
                {
                    tempList.Add("CL");
                }
                if (BottomHeaterData?.IsAlarm == true)
                {
                    tempList.Add("L");
                }

                if (tempList.Count > 0)
                {
                    if (tempList.Count == 5)
                    {
                        _isErrState = "All zone Err ";
                    }
                    else
                    {
                        _isErrState = string.Join("/", tempList) + " zone Err";
                    }
                }

                return _isErrState;
            }
        }

        public bool ErrState
        {
            get
            {
                bool _isErrState = false;
                if (TopHeaterData?.IsAlarm == true || TopCenterHeaterData?.IsAlarm == true || CenterHeaterData.IsAlarm == true || CenterBottomHeaterData.IsAlarm == true || BottomHeaterData.IsAlarm == true)
                {
                    _isErrState = true;
                }
                return _isErrState;
            }
        }

        #region AnaLog
        [Subscription("PM1.HTCurrent1.DeviceData")]
        public AITWaterFlowMeterData HTCurrent1 { get; set; }
        [Subscription("PM1.HTCurrent2.DeviceData")]
        public AITWaterFlowMeterData HTCurrent2 { get; set; }
        [Subscription("PM1.HTCurrent3.DeviceData")]
        public AITWaterFlowMeterData HTCurrent3 { get; set; }
        [Subscription("PM1.HTCurrent4.DeviceData")]
        public AITWaterFlowMeterData HTCurrent4 { get; set; }
        [Subscription("PM1.HTCurrent5.DeviceData")]
        public AITWaterFlowMeterData HTCurrent5 { get; set; }
        [Subscription("PM1.HTVoltage1.DeviceData")]
        public AITWaterFlowMeterData HTVoltage1 { get; set; }
        [Subscription("PM1.HTVoltage2.DeviceData")]
        public AITWaterFlowMeterData HTVoltage2 { get; set; }
        [Subscription("PM1.HTVoltage3.DeviceData")]
        public AITWaterFlowMeterData HTVoltage3 { get; set; }
        [Subscription("PM1.HTVoltage4.DeviceData")]
        public AITWaterFlowMeterData HTVoltage4 { get; set; }
        [Subscription("PM1.HTVoltage5.DeviceData")]
        public AITWaterFlowMeterData HTVoltage5 { get; set; }

        public string HTCurrent1Feedback { get; set; }

        public string HTCurrent2Feedback { get; set; }

        public string HTCurrent3Feedback { get; set; }

        public string HTCurrent4Feedback { get; set; }

        public string HTCurrent5Feedback { get; set; }

        public string HTVoltage1Feedback { get; set; }

        public string HTVoltage2Feedback { get; set; }

        public string HTVoltage3Feedback { get; set; }

        public string HTVoltage4Feedback { get; set; }

        public string HTVoltage5Feedback { get; set; }
        #endregion

        public Dictionary<string, double> _dicTemperatualMaxValue;

        private string _topHeaterSetPoint;
        public string TopHeaterSetPoint
        {
            get { return _topHeaterSetPoint; }
            set
            {
                _topHeaterSetPoint = value;
                NotifyOfPropertyChange("TopHeaterSetPoint");
            }
        }

        private string _topCenterHeaterSetPoint;

        public string TopCenterHeaterSetPoint
        {
            get { return _topCenterHeaterSetPoint; }
            set
            {
                _topCenterHeaterSetPoint = value;
                NotifyOfPropertyChange("TopCenterHeaterSetPoint");
            }

        }

        private string _centerHeaterSetPoint;

        public string CenterHeaterSetPoint
        {
            get { return _centerHeaterSetPoint; }
            set
            {
                _centerHeaterSetPoint = value;
                NotifyOfPropertyChange("CenterHeaterSetPoint");
            }

        }

        private string _centerBottomHeaterSetPoint;

        public string CenterBottomHeaterSetPoint
        {
            get { return _centerBottomHeaterSetPoint; }
            set
            {
                _centerBottomHeaterSetPoint = value;
                NotifyOfPropertyChange("CenterBottomHeaterSetPoint");
            }

        }

        private string _bottomHeaterSetPoint;

        public string BottomHeaterSetPoint
        {
            get { return _bottomHeaterSetPoint; }
            set
            {
                _bottomHeaterSetPoint = value;
                NotifyOfPropertyChange("BottomHeaterSetPoint");
            }

        }
        private string _topHeaterUpRateSetpoint;
        public string TopHeaterUpRateSetpoint
        {
            get { return _topHeaterUpRateSetpoint; }
            set
            {
                _topHeaterUpRateSetpoint = value;
                NotifyOfPropertyChange("TopHeaterUpRateSetpoint");
            }
        }
        private string _topCenterHeaterUpRateSetpoint;
        public string TopCenterHeaterUpRateSetpoint
        {
            get { return _topCenterHeaterUpRateSetpoint; }
            set
            {
                _topCenterHeaterUpRateSetpoint = value;
                NotifyOfPropertyChange("TopCenterHeaterUpRateSetpoint");
            }
        }
        private string _centerHeaterUpRateSetpoint;
        public string CenterHeaterUpRateSetpoint
        {
            get { return _centerHeaterUpRateSetpoint; }
            set
            {
                _centerHeaterUpRateSetpoint = value;
                NotifyOfPropertyChange("CenterHeaterUpRateSetpoint");
            }
        }
        private string _centerLowHeaterUpRateSetpoint;
        public string CenterLowHeaterUpRateSetpoint
        {
            get { return _centerLowHeaterUpRateSetpoint; }
            set
            {
                _centerLowHeaterUpRateSetpoint = value;
                NotifyOfPropertyChange("CenterLowHeaterUpRateSetpoint");
            }
        }
        private string _lowHeaterUpRateSetpoint;
        public string LowHeaterUpRateSetpoint
        {
            get { return _lowHeaterUpRateSetpoint; }
            set
            {
                _lowHeaterUpRateSetpoint = value;
                NotifyOfPropertyChange("LowHeaterUpRateSetpoint");
            }
        }

        private string _topHeaterDownRateSetpoint;
        public string TopHeaterDownRateSetpoint
        {
            get { return _topHeaterDownRateSetpoint; }
            set
            {
                _topHeaterDownRateSetpoint = value;
                NotifyOfPropertyChange("TopHeaterDownRateSetpoint");
            }
        }
        private string _topCenterHeaterDownRateSetpoint;
        public string TopCenterHeaterDownRateSetpoint
        {
            get { return _topCenterHeaterDownRateSetpoint; }
            set
            {
                _topCenterHeaterDownRateSetpoint = value;
                NotifyOfPropertyChange("TopCenterHeaterDownRateSetpoint");
            }
        }
        private string _centerHeaterDownRateSetpoint;
        public string CenterHeaterDownRateSetpoint
        {
            get { return _centerHeaterDownRateSetpoint; }
            set
            {
                _centerHeaterDownRateSetpoint = value;
                NotifyOfPropertyChange("CenterHeaterDownRateSetpoint");
            }
        }
        private string _centerLowHeaterDownRateSetpoint;
        public string CenterLowHeaterDownRateSetpoint
        {
            get { return _centerLowHeaterDownRateSetpoint; }
            set
            {
                _centerLowHeaterDownRateSetpoint = value;
                NotifyOfPropertyChange("CenterLowHeaterDownRateSetpoint");
            }
        }
        private string _lowHeaterDownRateSetpoint;
        public string LowHeaterDownRateSetpoint
        {
            get { return _lowHeaterDownRateSetpoint; }
            set
            {
                _lowHeaterDownRateSetpoint = value;
                NotifyOfPropertyChange("LowHeaterDownRateSetpoint");
            }
        }

        private bool _isEnableMannual;
        public bool IsEnableMannual
        {
            get
            {
                return IsManualButtonChecked;
            }
            set
            {
                _isEnableMannual = value;
            }
        }

        public bool IsManualButtonChecked
        {
            get;
            set;
        }

        private int _mannualSelectCount;

        private string _lspModel;
        public string LspModel
        {
            get => _lspModel;
            set
            {
                _lspModel = value;
                NotifyOfPropertyChange(nameof(LspModel));
            }
        }


        private string _topHeaterRampSetPoint;
        public string TopHeaterRampSetPoint
        {
            get => _topHeaterRampSetPoint;
            set
            {
                _topHeaterRampSetPoint = value;
                NotifyOfPropertyChange(nameof(TopHeaterRampSetPoint));
            }
        }
        private string _topCenterHeaterRampSetPoint;
        public string TopCenterHeaterRampSetPoint
        {
            get => _topCenterHeaterRampSetPoint;
            set
            {
                _topCenterHeaterRampSetPoint = value;
                NotifyOfPropertyChange(nameof(TopCenterHeaterRampSetPoint));
            }
        }
        private string _centerHeaterRampSetPoint;
        public string CenterHeaterRampSetPoint
        {
            get => _centerHeaterRampSetPoint;
            set
            {
                _centerHeaterRampSetPoint = value;
                NotifyOfPropertyChange(nameof(CenterHeaterRampSetPoint));
            }
        }
        private string _bottomCenterHeaterRampSetPoint;
        public string BottomCenterHeaterRampSetPoint
        {
            get => _bottomCenterHeaterRampSetPoint;
            set
            {
                _bottomCenterHeaterRampSetPoint = value;
                NotifyOfPropertyChange(nameof(BottomCenterHeaterRampSetPoint));
            }
        }
        private string _bottomHeaterRampSetPoint;
        public string BottomHeaterRampSetPoint
        {
            get => _bottomHeaterRampSetPoint;
            set
            {
                _bottomHeaterRampSetPoint = value;
                NotifyOfPropertyChange(nameof(BottomHeaterRampSetPoint));
            }
        }

        public string ProfileTable
        {
            get
            {
                if (!HeaterUData.IsProfiling)
                    return "OFF";

                if (string.IsNullOrEmpty(HeaterUData.ProfileTable) || HeaterUData.ProfileTable == "None")
                    return "OFF";
                var array = HeaterUData.ProfileTable.Split(',');
                if (array == null || array.Length < 2)
                {
                    return "OFF";
                }
                var fileNameAndPath = array[0];
                int.TryParse(array[1], out int index);
                var para = fileNameAndPath.Split('\\').ToList().Skip(2);//"Parameter\\TempCorrection"
                if (para == null)
                {
                    return "OFF";
                }
                var fileName = string.Join("\\", para.ToArray());
                if (array.Length < 3)
                {
                    return $"{fileName} [{index}]";
                }
                else
                    return $"{fileName} [{index}: {array[2]}]";

            }
            set
            {

            }
        }
        public string ProfileStatusDisplay
        {
            get
            {
                if (!HeaterUData.IsProfiling)
                    return "None";
                return HeaterUData.ProfileStatus;
            }
        }

        public string PIDTable
        {
            get
            {
                if (string.IsNullOrEmpty(HeaterUData.PIDTable) || HeaterUData.PIDTable == "None")
                    return "None";
                var array = HeaterUData.PIDTable.Split(',');
                if (array == null || array.Length < 2)
                {
                    return "None";
                }
                var fileNameAndPath = array[0];
                int.TryParse(array[1], out int index);
                var para = fileNameAndPath.Split('\\').ToList().Skip(2);//"Parameter\\TempCorrection"
                if (para == null)
                {
                    return "None";
                }
                var fileName = string.Join("\\", para.ToArray());
                if (array.Length < 3)
                {
                    return $"{fileName} [{index}]";
                }
                else
                    return $"{fileName} [{index}: {array[2]}]";
            }
            set
            {

            }
        }

        public string CorrectTable
        {
            get
            {
                if (string.IsNullOrEmpty(HeaterUData.CorrectTable) || HeaterUData.CorrectTable == "None")
                    return "None";
                var array = HeaterUData.CorrectTable.Split(',');
                if (array == null || array.Length < 2)
                {
                    return "None";
                }
                var fileNameAndPath = array[0];
                int.TryParse(array[1], out int index);
                var para = fileNameAndPath.Split('\\').ToList().Skip(2);//"Parameter\\TempCorrection"
                if (para == null)
                {
                    return "None";
                }
                var fileName = string.Join("\\", para.ToArray());
                if (array.Length < 3)
                {
                    return $"{fileName} [{index}]";
                }
                else
                    return $"{fileName} [{index}: {array[2]}]";
            }
            set
            {

            }
        }
        public string CheckLimitUDisplay
        {
            get
            {
                if (!HeaterUData.IsProfiling)
                    return "0.0";

                return HeaterUData.ProfileCheckLimit.ToString("f1");
            }
        }
        public string CheckLimitCUDisplay
        {
            get
            {
                if (!HeaterCUData.IsProfiling)
                    return "0.0";

                return HeaterCUData.ProfileCheckLimit.ToString("f1");
            }
        }
        public string CheckLimitCDisplay
        {
            get
            {
                if (!HeaterCData.IsProfiling)
                    return "0.0";

                return HeaterCData.ProfileCheckLimit.ToString("f1");
            }
        }
        public string CheckLimitCLDisplay
        {
            get
            {
                if (!HeaterCLData.IsProfiling)
                    return "0.0";

                return HeaterCLData.ProfileCheckLimit.ToString("f1");
            }
        }
        public string CheckLimitLDisplay
        {
            get
            {
                if (!HeaterLData.IsProfiling)
                    return "0.0";

                return HeaterLData.ProfileCheckLimit.ToString("f1");
            }
        }
        public string ProfileTotalTimeDisplay
        {
            get
            {
                var time = HeaterUData.ProfileTotalTime;
                if (!HeaterUData.IsProfiling)
                    time = 0;

                if (time < 0)
                    time = 0;

                TimeSpan span = TimeSpan.FromSeconds(time);

                return $"{span.Hours.ToString("D2")}:{span.Minutes.ToString("D2")}:{span.Seconds.ToString("D2")}";
            }
        }
        public string ProfilePreheatTimeDisplay
        {
            get
            {
                var time = HeaterUData.ProfilePreheatTime;
                if (!HeaterUData.IsProfiling)
                    time = 0;

                if (time < 0)
                    time = 0;

                TimeSpan span = TimeSpan.FromSeconds(time);

                return $"{span.Hours.ToString("D2")}:{span.Minutes.ToString("D2")}:{span.Seconds.ToString("D2")}";
            }
        }

        public string ProfileCheckTimeDisplay
        {
            get
            {
                var time = HeaterUData.ProfileCheckTime;
                if (!HeaterUData.IsProfiling)
                    time = 0;

                if (time < 0)
                    time = 0;

                TimeSpan span = TimeSpan.FromSeconds(time);

                return $"{span.Hours.ToString("D2")}:{span.Minutes.ToString("D2")}:{span.Seconds.ToString("D2")}";
            }
        }

        public List<DDCModel> TempList
        {
            get { return _tempList; }
            set
            {
                _tempList = value;
                NotifyOfPropertyChange(() => TempList);
            }
        }
        private List<DDCModel> _tempList = new List<DDCModel>();


        [Subscription("System.HeaterU.HeaterControlModeSV")]
        public float HeaterUHeaterControlModeSV { get; set; }

        [Subscription("System.HeaterU.CascadeControlModeSV")]
        public float HeaterUCascadeControlModeSV { get; set; }

        [Subscription("System.HeaterCU.HeaterControlModeSV")]
        public float HeaterCUHeaterControlModeSV { get; set; }

        [Subscription("System.HeaterCU.CascadeControlModeSV")]
        public float HeaterCUCascadeControlModeSV { get; set; }

        [Subscription("System.HeaterC.HeaterControlModeSV")]
        public float HeaterCHeaterControlModeSV { get; set; }

        [Subscription("System.HeaterC.CascadeControlModeSV")]
        public float HeaterCCascadeControlModeSV { get; set; }

        [Subscription("System.HeaterCL.HeaterControlModeSV")]
        public float HeaterCLHeaterControlModeSV { get; set; }

        [Subscription("System.HeaterCL.CascadeControlModeSV")]
        public float HeaterCLCascadeControlModeSV { get; set; }

        [Subscription("System.HeaterL.HeaterControlModeSV")]
        public float HeaterLHeaterControlModeSV { get; set; }

        [Subscription("System.HeaterL.CascadeControlModeSV")]
        public float HeaterLCascadeControlModeSV { get; set; }


        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            if (!IsEnableMannual)
            {
                InitSetPoint();
                InitRampRate();
                InitUpDownRate();
            }
            //URange = 9.9;
            List<DDCModel> tempList = new List<DDCModel>();

            DDCModel HTU = new DDCModel("HT.U")
            {
                SetValue = HeaterUData.SetPoint.ToString("F1"),
                ActValue = HeaterUData.HeaterPV.ToString("F1"),
                TargetValue = HeaterUHeaterControlModeSV.ToString("F1"),
                Power = HeaterUData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterUData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterUData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterUData.SetPoint - HeaterUData.FeedBack).ToString("F1"),
                P = HeaterUData.HeaterPID_P.ToString("F1"),
                I= HeaterUData.HeaterPID_I.ToString("F1"),
                D= HeaterUData.HeaterPID_D.ToString("F1"),
                IsPVBreak = HeaterUData.IsHeaterPVBreak,
                IsTempErr = HeaterUData.HeaterPV > HeaterUData.Scale
            };
            DDCModel HTCU = new DDCModel("HT.CU")
            {
                SetValue = HeaterCUData.SetPoint.ToString("F1"),
                ActValue = HeaterCUData.HeaterPV.ToString("F1"),
                TargetValue = HeaterCUHeaterControlModeSV.ToString("F1"),
                Power = HeaterCUData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCUData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCUData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCUData.SetPoint - HeaterCUData.FeedBack).ToString("F1"),
                P = HeaterCUData.HeaterPID_P.ToString("F1"),
                I = HeaterCUData.HeaterPID_I.ToString("F1"),
                D = HeaterCUData.HeaterPID_D.ToString("F1"),
                IsPVBreak = HeaterCUData.IsHeaterPVBreak,
                IsTempErr = HeaterCUData.HeaterPV > HeaterCUData.Scale
            };
            DDCModel HTC = new DDCModel("HT.C")
            {
                SetValue = HeaterCData.SetPoint.ToString("F1"),
                ActValue = HeaterCData.HeaterPV.ToString("F1"),
                TargetValue = HeaterCHeaterControlModeSV.ToString("F1"),
                Power = HeaterCData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCData.SetPoint - HeaterCData.FeedBack).ToString("F1"),
                P = HeaterCData.HeaterPID_P.ToString("F1"),
                I = HeaterCData.HeaterPID_I.ToString("F1"),
                D = HeaterCData.HeaterPID_D.ToString("F1"),
                IsPVBreak = HeaterCData.IsHeaterPVBreak,
                IsTempErr = HeaterCData.HeaterPV > HeaterCData.Scale
            };
            DDCModel HTCL = new DDCModel("HT.CL")
            {
                SetValue = HeaterCLData.SetPoint.ToString("F1"),
                ActValue = HeaterCLData.HeaterPV.ToString("F1"),
                TargetValue = HeaterCLHeaterControlModeSV.ToString("F1"),
                Power = HeaterCLData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCLData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCLData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCLData.SetPoint - HeaterCLData.FeedBack).ToString("F1"),
                P = HeaterCLData.HeaterPID_P.ToString("F1"),
                I = HeaterCLData.HeaterPID_I.ToString("F1"),
                D = HeaterCLData.HeaterPID_D.ToString("F1"),
                IsPVBreak = HeaterCLData.IsHeaterPVBreak,
                IsTempErr = HeaterCLData.HeaterPV > HeaterCLData.Scale
            };
            DDCModel HTL = new DDCModel("HT.L")
            {
                SetValue = HeaterLData.SetPoint.ToString("F1"),
                ActValue = HeaterLData.HeaterPV.ToString("F1"),
                TargetValue = HeaterLHeaterControlModeSV.ToString("F1"),
                Power = HeaterLData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterLData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterLData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterLData.SetPoint - HeaterLData.FeedBack).ToString("F1"),
                P = HeaterLData.HeaterPID_P.ToString("F1"),
                I = HeaterLData.HeaterPID_I.ToString("F1"),
                D = HeaterLData.HeaterPID_D.ToString("F1"),
                IsPVBreak = HeaterLData.IsHeaterPVBreak,
                IsTempErr = HeaterLData.HeaterPV > HeaterLData.Scale
            };

            DDCModel PRU = new DDCModel("PR.U")
            {
                SetValue = HeaterUData.SetPoint.ToString("F1"),
                ActValue = HeaterUData.CascadePV.ToString("F1"),
                TargetValue = HeaterUCascadeControlModeSV.ToString("F1"),
                Power = HeaterUData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterUData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterUData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterUData.SetPoint - HeaterUData.FeedBack).ToString("F1"),
                P = HeaterUData.CascadePID_P.ToString("F1"),
                I = HeaterUData.CascadePID_I.ToString("F1"),
                D = HeaterUData.CascadePID_D.ToString("F1"),
                IsPVBreak = HeaterUData.IsCascadePVBreak,
                IsTempErr = HeaterUData.HeaterPV > HeaterUData.Scale
            };

            DDCModel PRCU = new DDCModel("PR.CU")
            {
                SetValue = HeaterCUData.SetPoint.ToString("F1"),
                ActValue = HeaterCUData.CascadePV.ToString("F1"),
                TargetValue = HeaterCUCascadeControlModeSV.ToString("F1"),
                Power = HeaterCUData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCUData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCUData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCUData.SetPoint - HeaterCUData.FeedBack).ToString("F1"),
                P = HeaterCUData.CascadePID_P.ToString("F1"),
                I = HeaterCUData.CascadePID_I.ToString("F1"),
                D = HeaterCUData.CascadePID_D.ToString("F1"),
                IsPVBreak = HeaterCUData.IsCascadePVBreak,
                IsTempErr = HeaterCUData.CascadePV > HeaterCUData.Scale
            };
            DDCModel PRC = new DDCModel("PR.C")
            {
                SetValue = HeaterCData.SetPoint.ToString("F1"),
                ActValue = HeaterCData.CascadePV.ToString("F1"),
                TargetValue = HeaterCCascadeControlModeSV.ToString("F1"),
                Power = HeaterCData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCData.SetPoint - HeaterCData.FeedBack).ToString("F1"),
                P = HeaterCData.CascadePID_P.ToString("F1"),
                I = HeaterCData.CascadePID_I.ToString("F1"),
                D = HeaterCData.CascadePID_D.ToString("F1"),
                IsPVBreak = HeaterCData.IsCascadePVBreak,
                IsTempErr = HeaterCData.CascadePV > HeaterCData.Scale
            };
            DDCModel PRCL = new DDCModel("PR.CL")
            {
                SetValue = HeaterCLData.SetPoint.ToString("F1"),
                ActValue = HeaterCLData.CascadePV.ToString("F1"),
                TargetValue = HeaterCLCascadeControlModeSV.ToString("F1"),
                Power = HeaterCLData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterCLData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterCLData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterCLData.SetPoint - HeaterCLData.FeedBack).ToString("F1"),
                P = HeaterCLData.CascadePID_P.ToString("F1"),
                I = HeaterCLData.CascadePID_I.ToString("F1"),
                D = HeaterCLData.CascadePID_D.ToString("F1"),
                IsPVBreak = HeaterCLData.IsCascadePVBreak,
                IsTempErr = HeaterCLData.CascadePV > HeaterCLData.Scale
            };
            DDCModel PRL = new DDCModel("PR.L")
            {
                SetValue = HeaterLData.SetPoint.ToString("F1"),
                ActValue = HeaterLData.CascadePV.ToString("F1"),
                TargetValue = HeaterLCascadeControlModeSV.ToString("F1"),
                Power = HeaterLData.ManipulatedVariable.ToString("F1"),
                UpRate = HeaterLData.UpRateSetPoint.ToString("F1"),
                DownRate = HeaterLData.DownRateSetPoint.ToString("F1"),
                DevValue = (HeaterLData.SetPoint - HeaterLData.FeedBack).ToString("F1"),
                P = HeaterLData.CascadePID_P.ToString("F1"),
                I = HeaterLData.CascadePID_I.ToString("F1"),
                D = HeaterLData.CascadePID_D.ToString("F1"),
                IsPVBreak = HeaterLData.IsCascadePVBreak,
                IsTempErr = HeaterLData.CascadePV > HeaterLData.Scale
            };
            tempList.Add(HTU);
            tempList.Add(HTCU);
            tempList.Add(HTC);
            tempList.Add(HTCL);
            tempList.Add(HTL);
            tempList.Add(PRU);
            tempList.Add(PRCU);
            tempList.Add(PRC);
            tempList.Add(PRCL);
            tempList.Add(PRL);
            TempList = tempList;
            NotifyOfPropertyChange(nameof(PositiveULength));
            NotifyOfPropertyChange(nameof(NegativeULength));

            NotifyOfPropertyChange(nameof(PositiveCULength));
            NotifyOfPropertyChange(nameof(NegativeCULength));

            NotifyOfPropertyChange(nameof(PositiveCLength));
            NotifyOfPropertyChange(nameof(NegativeCLength));

            NotifyOfPropertyChange(nameof(PositiveCLLength));
            NotifyOfPropertyChange(nameof(NegativeCLLength));

            NotifyOfPropertyChange(nameof(PositiveLLength));
            NotifyOfPropertyChange(nameof(NegativeLLength));

            if (_view != null)
            {
                _view.UpdateLayout();

            }
        }

        public void InitSetPoint()
        {
            TopHeaterSetPoint = TopHeaterData.SetPoint.ToString("F1");
            TopCenterHeaterSetPoint = TopCenterHeaterData.SetPoint.ToString("F1");
            CenterHeaterSetPoint = CenterHeaterData.SetPoint.ToString("F1");
            CenterBottomHeaterSetPoint = CenterBottomHeaterData.SetPoint.ToString("F1");
            BottomHeaterSetPoint = BottomHeaterData.SetPoint.ToString("F1");

            //HTCurrent1Feedback = HTCurrent1 == null ? "0.0" : HTCurrent1.FeedBack.ToString("F3");
            //HTCurrent2Feedback = HTCurrent2 == null ? "0.0" : HTCurrent2.FeedBack.ToString("F3");
            //HTCurrent3Feedback = HTCurrent3 == null ? "0.0" : HTCurrent3.FeedBack.ToString("F3");
            //HTCurrent4Feedback = HTCurrent4 == null ? "0.0" : HTCurrent4.FeedBack.ToString("F3");
            //HTCurrent5Feedback = HTCurrent5 == null ? "0.0" : HTCurrent5.FeedBack.ToString("F3");

            //HTVoltage1Feedback = HTVoltage1 == null ? "0.0" : HTVoltage1.FeedBack.ToString("F3");
            //HTVoltage2Feedback = HTVoltage2 == null ? "0.0" : HTVoltage2.FeedBack.ToString("F3");
            //HTVoltage3Feedback = HTVoltage3 == null ? "0.0" : HTVoltage3.FeedBack.ToString("F3");
            //HTVoltage4Feedback = HTVoltage4 == null ? "0.0" : HTVoltage4.FeedBack.ToString("F3");
            //HTVoltage5Feedback = HTVoltage5 == null ? "0.0" : HTVoltage5.FeedBack.ToString("F3");

        }
        public void InitUpDownRate()
        {
            TopHeaterUpRateSetpoint = TopHeaterData.UpRateSetPoint.ToString("F1");
            TopCenterHeaterUpRateSetpoint = TopCenterHeaterData.UpRateSetPoint.ToString("F1"); ;
            CenterHeaterUpRateSetpoint = CenterHeaterData.UpRateSetPoint.ToString("F1"); ;
            CenterLowHeaterUpRateSetpoint = CenterBottomHeaterData.UpRateSetPoint.ToString("F1"); ;
            LowHeaterUpRateSetpoint = BottomHeaterData.UpRateSetPoint.ToString("F1"); ;

            TopHeaterDownRateSetpoint = TopHeaterData.DownRateSetPoint.ToString("F1");
            TopCenterHeaterDownRateSetpoint = TopCenterHeaterData.DownRateSetPoint.ToString("F1"); ;
            CenterHeaterDownRateSetpoint = CenterHeaterData.DownRateSetPoint.ToString("F1"); ;
            CenterLowHeaterDownRateSetpoint = CenterBottomHeaterData.DownRateSetPoint.ToString("F1"); ;
            LowHeaterDownRateSetpoint = BottomHeaterData.DownRateSetPoint.ToString("F1"); ;
        }
        public void InitRampRate()
        {
            TopHeaterRampSetPoint = CompterRampPoint(TopHeaterData).ToString("F1");
            TopCenterHeaterRampSetPoint = CompterRampPoint(TopCenterHeaterData).ToString("F1");
            CenterHeaterRampSetPoint = CompterRampPoint(CenterHeaterData).ToString("F1");
            BottomCenterHeaterRampSetPoint = CompterRampPoint(CenterBottomHeaterData).ToString("F1");
            BottomHeaterRampSetPoint = CompterRampPoint(BottomHeaterData).ToString("F1");
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();
            string[] strTempsNames = { "Heater1", "Heater2", "Heater3", "Heater4", "Heater5" };
            _dicTemperatualMaxValue = new Dictionary<string, double>();

            //获取温度限制配置信息
            for (int i = 0; i < strTempsNames.Length; i++)
            {
                object obj = QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.{strTempsNames[i]}.Range");
                _dicTemperatualMaxValue.Add(strTempsNames[i], Convert.ToDouble(obj));
            }

        }



        public double CompterRampPoint(AITHeaterData data)
        {
            if (data.IsLspModeFeedBack)
            {
                return data.FeedBack >= data.SetPoint ? data.LspDecreaseRampRateFeedBack : data.LspIncreaseRampRateFeedBack;
            }
            else
            {
                return data.FeedBack >= data.SetPoint ? data.RspDecreaseRampRateFeedBack : data.RspIncreaseRampRateFeedBack;
            }
        }

        public void ManualCmd()
        {
            //((Window)GetView()).DialogResult = true; 

            var wm = IoC.Get<IWindowManager>();
            SetTemperatureViewModel setTemperatureViewModel = new SetTemperatureViewModel();
            (wm as WindowManager)?.ShowDialogWithTitle(setTemperatureViewModel, null, "Set Temperature");
        }

        public void SetCmd(object senderName, object sender, object typeName)
        {
            double temval = 0;
            string name = senderName.ToString();
            switch (typeName.ToString())
            {
                case "setpoint":
                    double maxvalue = 0;
                    string tName = GetTempratualMaxValue(name);
                    if (!string.IsNullOrEmpty(tName))
                    {
                        maxvalue = _dicTemperatualMaxValue[tName];
                    }

                    string strRetValue = ShowNumberKeyboard(sender as Button, "", true, maxvalue);
                    if (strRetValue != "Cancel")
                    {

                        //if (double.TryParse(strRetValue, out temval))
                        {
                            SelectPostionSetPoint(name, strRetValue);
                        }
                    }
                    break;
                case "ramp":
                    strRetValue = ShowNumberKeyboard(sender as Button, "", false, 0);
                    if (strRetValue != "Cancel")
                    {
                        //if (double.TryParse(strRetValue, out temval))
                        {
                            SelectPositionRamp(name, strRetValue);
                        }
                    }
                    break;
            }
        }

        private string GetTempratualMaxValue(string typeName)
        {
            string dicName = string.Empty;
            bool isLspMode = LspModel != "Outer Control";
            switch (typeName)
            {
                case "TopHeater":
                    dicName = isLspMode ? "Heater1" : "Heater2";
                    break;
                case "TopCenterHeater":
                    dicName = isLspMode ? "Heater3" : "Heater4";
                    break;
                case "CenterHeater":
                    dicName = isLspMode ? "Heater5" : "Heater6";
                    break;
                case "CenterBottomHeater":
                    dicName = isLspMode ? "Heater7" : "Heater8";
                    break;
                case "BottomHeater":
                    dicName = isLspMode ? "Heater9" : "Heater10";
                    break;
            }

            return dicName;
        }

        private void SelectPostionSetPoint(string name, string value)
        {
            switch (name)
            {
                case "TopHeater":
                    TopHeaterSetPoint = value;
                    break;
                case "TopCenterHeater":
                    TopCenterHeaterSetPoint = value;
                    break;
                case "CenterHeater":
                    CenterHeaterSetPoint = value;
                    break;
                case "CenterBottomHeater":
                    CenterBottomHeaterSetPoint = value;
                    break;
                case "BottomHeater":
                    BottomHeaterSetPoint = value;
                    break;
            }
        }

        private void SelectPositionRamp(string name, string value)
        {
            switch (name)
            {
                case "TopHeater":
                    TopHeaterRampSetPoint = value;
                    break;
                case "TopCenterHeater":
                    TopCenterHeaterRampSetPoint = value;
                    break;
                case "CenterHeater":
                    CenterHeaterRampSetPoint = value;
                    break;
                case "CenterBottomHeater":
                    BottomCenterHeaterRampSetPoint = value;
                    break;
                case "BottomHeater":
                    BottomHeaterRampSetPoint = value;
                    break;
            }
        }

        private string ShowNumberKeyboard(Control control, string defaultValue, bool isValidate, double maxValue = double.MaxValue)
        {
            NumberKeyboard numberKeyboard = new NumberKeyboard("", defaultValue);
            var point = control.PointFromScreen(new Point(0, 0));
            double wx = SystemParameters.WorkArea.Width;
            double hy = SystemParameters.WorkArea.Height;
            if (-point.Y + control.ActualHeight + 5 + numberKeyboard.Height < hy)
            {
                numberKeyboard.Top = -point.Y + control.ActualHeight + 5;
            }
            else
            {
                numberKeyboard.Top = -point.Y - numberKeyboard.Height - 5;
            }
            if (-point.X + numberKeyboard.Width < wx)
            {
                numberKeyboard.Left = -point.X;
            }
            else
            {
                numberKeyboard.Left = -point.X - (numberKeyboard.Width - control.ActualWidth);
            }
            if ((bool)numberKeyboard.ShowDialog())
                return numberKeyboard.ValueString;
            else
                return "Cancel";
        }

        public void AllZone(string obj)
        {
            var windowManager = IoC.Get<IWindowManager>();
            TemperatureDetailAllZoneViewModel temperatureDetailAllZoneViewModel = new TemperatureDetailAllZoneViewModel();
            switch (obj)
            {
                case "Set":
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(temperatureDetailAllZoneViewModel, null, "Temperature Value Set"))
                    {
                        TopHeaterSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        TopCenterHeaterSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        CenterHeaterSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        CenterBottomHeaterSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        BottomHeaterSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                    }
                    break;
                case "Ramp":
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(temperatureDetailAllZoneViewModel, null, "Temperature Ramp Set"))
                    {
                        TopHeaterRampSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        TopCenterHeaterRampSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        CenterHeaterRampSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        BottomCenterHeaterRampSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                        BottomHeaterRampSetPoint = temperatureDetailAllZoneViewModel.TempSetValue;
                    }
                    break;
                default:
                    break;
            }
        }

        public void CloseCmd()
        {
            ClientApp.Instance.SwitchPage("status", "main", null);
        }
    }
}