using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;

namespace Aitex.Core.RT.Device.Unit
{
    public class IoPressureSensor : BaseDevice, IDevice
    {
        [Subscription(AITPressureSensorPropertyName.Feedback)]
        public double Feedback
        {
            get
            {
                if (_aiPressureValue != null)
                    return _aiPressureValue.Value;
                return 0;
            }
        }

        [Subscription(AITPressureSensorPropertyName.IsWarning)]
        public bool IsWarning
        {
            get
            {
                return _checkWarning.Result;
            }
        }

        [Subscription(AITPressureSensorPropertyName.IsError)]
        public bool IsError
        {
            get
            {
                return _checkAlarm.Result;
            }
        }

        public new string Display
        {
            get
            {
                if (_scGasName != null)
                    return string.Format("{0} Pressure Sensor", _scGasName.Value);
                return base.Display;
            }
        }

        public double MinPressure
        {
            get
            {
                return _scMinPressure == null ? 0 : _scMinPressure.Value;
            }
        }

        public double MaxPressure
        {
            get
            {
                return _scMaxPressure == null ? 0 : _scMaxPressure.Value;
            }
        }

        public double WarningTime
        {
            get
            {
                return _scWarningTime == null ? 0 : _scWarningTime.Value;
            }
        }

        public double AlarmTime
        {
            get
            {
                return _scAlarmTime == null ? 0 : _scAlarmTime.Value;
            }
        }

        public bool IsOutOfRange
        {
            get
            {
                if (MinPressure < 0.01 && MaxPressure < 0.01)
                    return false;

                return (Feedback < MinPressure) || (Feedback > MaxPressure);
            }
        }

        public bool IsGasEnable
        {
            get
            {
                return _scGasEnable == null || _scGasEnable.Value;
            }
        }

        public string Unit { get; set; }
 
        private AIAccessor _aiPressureValue = null;

        private DOAccessor _doWarning;
        private DOAccessor _doAlarm;
        
        private SCItem<double> _scMinPressure;
        private SCItem<double> _scMaxPressure;
        private SCItem<double> _scWarningTime;
        private SCItem<double> _scAlarmTime;
        private SCString _scGasName;
        private SCItem<bool> _scGasEnable;
 
        private ToleranceChecker _checkWarning = new ToleranceChecker();
        private ToleranceChecker _checkAlarm = new ToleranceChecker();

        public IoPressureSensor(string module, XmlElement node)
        {
                        Module = module;
            Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            DeviceID = node.GetAttribute("schematicId");
            Unit = node.GetAttribute("unit");

            _aiPressureValue = ParseAiNode("aiPressureValue", node);
            _doWarning = ParseDoNode("doWarning", node);
            _doAlarm = ParseDoNode("doAlarm", node);

            _scMinPressure = ParseScNodeDouble("scMinPressure", node);
            _scMaxPressure = ParseScNodeDouble("scMaxPressure", node);
            _scWarningTime = ParseScNodeDouble("scWarningTime", node);
            _scAlarmTime = ParseScNodeDouble("scAlarmTime", node);
            _scGasName = ParseScNodeString("scGasName", node);
            _scGasEnable = ParseScNodeBool("scGasEnable", node);
        }

        public bool Initialize()
        {
            DATA.Subscribe(string.Format("Device.{0}.{1}", Module, Name), () =>
            {
                AITPressureSensorData data = new AITPressureSensorData()
                {
                    DeviceName = Name,
                    DeviceSchematicId = DeviceID,
                    DisplayName = Display,
                    FeedBack = Feedback,
                    IsWarning = IsWarning,
                    Unit = Unit,
                    IsError = IsError,
                    IsOutOfRange = IsOutOfRange,
                };

                return data;
            }, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            return true;
        }

        public void Terminate()
        {
        }

        public void Monitor()
        {
            if (IsGasEnable && ((int) WarningTime > 0))
            {
                _checkWarning.Monitor(Feedback, MinPressure, MaxPressure, WarningTime);

                if (_checkWarning.Trig)
                {
                    EV.PostMessage(Module, EventEnum.Pressure_Sensor_Warning, Display, Feedback.ToString("F1"), WarningTime,
                        Feedback > MaxPressure ? ">" : "<", Feedback > MaxPressure ? MaxPressure : MinPressure);
                }

                if (_doWarning!=null)
                {
                    _doWarning.Value = _checkWarning.Result;
                }
            }

            if (IsGasEnable && ((int) AlarmTime > 0))
            {
                _checkAlarm.Monitor(Feedback, MinPressure, MaxPressure, AlarmTime);
            
                if (_checkAlarm.Trig)
                {
                    EV.PostMessage(Module, EventEnum.Pressure_Sensor_Alarm, Display, Feedback.ToString("F1"), AlarmTime,
                        Feedback > MaxPressure ? ">" : "<", Feedback > MaxPressure ? MaxPressure : MinPressure);
                }

                if (_doAlarm != null)
                {
                    _doAlarm.Value = _checkAlarm.Result;
                }
            }
        }

        public void Reset()
        {
            _checkWarning.RST = true;
            _checkAlarm.RST = true;
        }
    }
}