using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Aitex.Common.Util;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using System.Xml.Linq;
using System.Xml;
using Common.OP;
using Common.DataCenter;

namespace athosRT.Devices
{

    public class IoSignalTower : BaseDevice, IDevice
    {
        private IoSignalLight _red = null;

        private IoSignalLight _yellow = null;

        private IoSignalLight _green = null;

        private IoSignalLight _blue = null;

        private IoSignalLight _white = null;

        private IoSignalLight _buzzer = null;

        private IoSignalLight _buzzer1 = null;

        private IoSignalLight _buzzer2 = null;

        private IoSignalLight _buzzer3 = null;

        private IoSignalLight _buzzer4 = null;

        private IoSignalLight _buzzer5 = null;

        private bool _buzzerSwitchOff = false;

        private bool _buzzer1SwitchOff = false;

        private bool _buzzer2SwitchOff = false;

        private bool _buzzer3SwitchOff = false;

        private bool _buzzer4SwitchOff = false;

        private bool _buzzer5SwitchOff = false;

        private object _locker = new object();

        private Dictionary<string, Dictionary<IoSignalLight, TowerLightStatus>> _config = new Dictionary<string, Dictionary<IoSignalLight, TowerLightStatus>>();

        private Dictionary<IoSignalLight, TowerLightStatus> _cmdSetPoint = new Dictionary<IoSignalLight, TowerLightStatus>();

        private Dictionary<IoSignalLight, TowerLightStatus> dicState = new Dictionary<IoSignalLight, TowerLightStatus>();

        public bool HostControl
        {
            get;
            set;
        }

        public bool BuzzerSwithcOff => _buzzerSwitchOff;

        public virtual AITSignalTowerData DeviceData => new AITSignalTowerData
        {
            DeviceName = base.Name,
            DeviceSchematicId = base.DeviceID,
            DisplayName = base.Display,
            IsGreenLightOn = (_green != null && _green.Value),
            IsRedLightOn = (_red != null && _red.Value),
            IsYellowLightOn = (_yellow != null && _yellow.Value),
            IsWhiteLightOn = (_white != null && _white.Value),
            IsBlueLightOn = (_blue != null && _blue.Value),
            IsBuzzerOn = (_buzzer != null && _buzzer.Value),
            IsBuzzer1On = (_buzzer1 != null && _buzzer1.Value),
            IsBuzzer2On = (_buzzer2 != null && _buzzer2.Value),
            IsBuzzer3On = (_buzzer3 != null && _buzzer3.Value),
            IsBuzzer4On = (_buzzer4 != null && _buzzer4.Value),
            IsBuzzer5On = (_buzzer5 != null && _buzzer5.Value)
        };

        public Dictionary<IoSignalLight, TowerLightStatus> SignalTowerState => dicState;

        public IoSignalLight Red => _red;

        public IoSignalLight Yellow => _yellow;

        public IoSignalLight Green => _green;

        public IoSignalLight Blue => _blue;

        public IoSignalLight White => _white;

        public IoSignalLight Buzzer1 => _buzzer1;

        public IoSignalLight Buzzer2 => _buzzer2;

        public IoSignalLight Buzzer3 => _buzzer3;

        public IoSignalLight Buzzer4 => _buzzer4;

        public IoSignalLight Buzzer5 => _buzzer5;

        public IoSignalTower(string module, XmlElement node, string ioModule = "")
        {
            if (node != null)
            {
                base.Module = node.GetAttribute("module");
                base.Name = node.GetAttribute("id");
                base.Display = node.GetAttribute("display");
                base.DeviceID = node.GetAttribute("schematicId");
                DOAccessor dOAccessor = ParseDoNode("doRed", node, ioModule);
                if (dOAccessor != null)
                {
                    _red = new IoSignalLight(module, "SignalLightRed", "Red Light", "SignalLightRed", dOAccessor);
                }
                DOAccessor dOAccessor2 = ParseDoNode("doYellow", node, ioModule);
                if (dOAccessor2 != null)
                {
                    _yellow = new IoSignalLight(module, "SignalLightYellow", "Yellow Light", "SignalLightYellow", dOAccessor2);
                }
                DOAccessor dOAccessor3 = ParseDoNode("doGreen", node, ioModule);
                if (dOAccessor3 != null)
                {
                    _green = new IoSignalLight(module, "SignalLightGreen", "Green Light", "SignalLightGreen", dOAccessor3);
                }
                DOAccessor dOAccessor4 = ParseDoNode("doBlue", node, ioModule);
                if (dOAccessor4 != null)
                {
                    _blue = new IoSignalLight(module, "SignalLightBlue", "Blue Light", "SignalLightBlue", dOAccessor4);
                }
                DOAccessor dOAccessor5 = ParseDoNode("doWhite", node, ioModule);
                if (dOAccessor5 != null)
                {
                    _white = new IoSignalLight(module, "SignalLightWhite", "White Light", "SignalLightWhite", dOAccessor5);
                }
                DOAccessor dOAccessor6 = ParseDoNode("doBuzzer1", node, ioModule);
                if (dOAccessor6 != null)
                {
                    _buzzer1 = new IoSignalLight(module, "SignalLightBuzzer1", "Buzzer1 Light", "SignalLightBuzzer1", dOAccessor6);
                }
                DOAccessor dOAccessor7 = ParseDoNode("doBuzzer2", node, ioModule);
                if (dOAccessor7 != null)
                {
                    _buzzer2 = new IoSignalLight(module, "SignalLightBuzzer2", "Buzzer2 Light", "SignalLightBuzzer2", dOAccessor7);
                }
                DOAccessor dOAccessor8 = ParseDoNode("doBuzzer3", node, ioModule);
                if (dOAccessor8 != null)
                {
                    _buzzer3 = new IoSignalLight(module, "SignalLightBuzzer3", "Buzzer3 Light", "SignalLightBuzzer3", dOAccessor8);
                }
                DOAccessor dOAccessor9 = ParseDoNode("doBuzzer4", node, ioModule);
                if (dOAccessor9 != null)
                {
                    _buzzer4 = new IoSignalLight(module, "SignalLightBuzzer4", "Buzzer4 Light", "SignalLightBuzzer4", dOAccessor9);
                }
                DOAccessor dOAccessor10 = ParseDoNode("doBuzzer5", node, ioModule);
                if (dOAccessor10 != null)
                {
                    _buzzer5 = new IoSignalLight(module, "SignalLightBuzzer5", "Buzzer5 Light", "SignalLightBuzzer5", dOAccessor10);
                }
                IoSignalLight[] array = new IoSignalLight[5]
                {
                _buzzer1,
                _buzzer2,
                _buzzer3,
                _buzzer4,
                _buzzer5
                };
                _buzzer = Array.Find(array, (IoSignalLight x) => x != null);
            }
        }

        public virtual bool Initialize()
        {
            OP.Subscribe($"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer}", SwitchOffBuzzer);
            OP.Subscribe($"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer1}", SwitchOffBuzzer);
            OP.Subscribe($"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer2}", SwitchOffBuzzer);
            OP.Subscribe($"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer3}", SwitchOffBuzzer);
            OP.Subscribe($"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer4}", SwitchOffBuzzer);
            DATA.Subscribe(base.Module + "." + base.Name + ".DeviceData", () => DeviceData);
            return true;
        }

        public void SetLight(LightType lightType, LightState state, int blinkInterval = 500)
        {
            IoSignalLight ioSignalLight = null;
            switch (lightType)
            {
                case LightType.Red:
                    ioSignalLight = _red;
                    break;
                case LightType.Green:
                    ioSignalLight = _green;
                    break;
                case LightType.Yellow:
                    ioSignalLight = _yellow;
                    break;
                case LightType.White:
                    ioSignalLight = _white;
                    break;
                case LightType.Blue:
                    ioSignalLight = _blue;
                    break;
                case LightType.Buzzer:
                    ioSignalLight = _buzzer;
                    break;
                case LightType.Buzzer1:
                    ioSignalLight = _buzzer1;
                    break;
                case LightType.Buzzer2:
                    ioSignalLight = _buzzer2;
                    break;
                case LightType.Buzzer3:
                    ioSignalLight = _buzzer3;
                    break;
                case LightType.Buzzer4:
                    ioSignalLight = _buzzer4;
                    break;
                case LightType.Buzzer5:
                    ioSignalLight = _buzzer5;
                    break;
            }
            if (ioSignalLight == null)
            {
                LOG.Write($"Undefined light {lightType}", 2, "D:\\sorter\\trunk\\Framework\\RTEquipmentLibrary\\Unit\\IoSignalTower.cs", "SetLight", 271);
                return;
            }
            switch (state)
            {
                case LightState.On:
                    _cmdSetPoint[ioSignalLight] = TowerLightStatus.On;
                    ioSignalLight.StateSetPoint = TowerLightStatus.On;
                    break;
                case LightState.Off:
                    _cmdSetPoint[ioSignalLight] = TowerLightStatus.Off;
                    ioSignalLight.StateSetPoint = TowerLightStatus.Off;
                    break;
                case LightState.Blink:
                    _cmdSetPoint[ioSignalLight] = TowerLightStatus.Blinking;
                    ioSignalLight.Interval = blinkInterval;
                    ioSignalLight.StateSetPoint = TowerLightStatus.Blinking;
                    break;
            }
        }

        public virtual bool CustomSignalTower(string configPathFile)
        {
            try
            {
                STEvents sTEvents = CustomXmlSerializer.Deserialize<STEvents>(new FileInfo(configPathFile));
                lock (_locker)
                {
                    foreach (STEvent @event in sTEvents.Events)
                    {
                        if (!_config.ContainsKey(@event.Name))
                        {
                            _config[@event.Name] = new Dictionary<IoSignalLight, TowerLightStatus>();
                        }
                        if (_red != null)
                        {
                            _config[@event.Name][_red] = ParseLight(@event.Red);
                        }
                        if (_yellow != null)
                        {
                            _config[@event.Name][_yellow] = ParseLight(@event.Yellow);
                        }
                        if (_green != null)
                        {
                            _config[@event.Name][_green] = ParseLight(@event.Green);
                        }
                        if (_blue != null)
                        {
                            _config[@event.Name][_blue] = ParseLight(@event.Blue);
                        }
                        if (_white != null)
                        {
                            _config[@event.Name][_white] = ParseLight(@event.White);
                        }
                        if (_buzzer != null)
                        {
                            _config[@event.Name][_buzzer] = ParseLight(@event.Buzzer);
                        }
                        if (_buzzer1 != null)
                        {
                            _config[@event.Name][_buzzer1] = ParseLight(@event.Buzzer1);
                        }
                        if (_buzzer2 != null)
                        {
                            _config[@event.Name][_buzzer2] = ParseLight(@event.Buzzer2);
                        }
                        if (_buzzer3 != null)
                        {
                            _config[@event.Name][_buzzer3] = ParseLight(@event.Buzzer3);
                        }
                        if (_buzzer4 != null)
                        {
                            _config[@event.Name][_buzzer4] = ParseLight(@event.Buzzer4);
                        }
                        if (_buzzer5 != null)
                        {
                            _config[@event.Name][_buzzer5] = ParseLight(@event.Buzzer5);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //EV.PostWarningLog(base.Module, "Signal tower config file is invalid, " + ex.Message);
                return false;
            }
            return true;
        }

        public virtual void Monitor()
        {
            if (_red != null)
            {
                dicState[_red] = TowerLightStatus.Off;
            }
            if (_yellow != null)
            {
                dicState[_yellow] = TowerLightStatus.Off;
            }
            if (_green != null)
            {
                dicState[_green] = TowerLightStatus.Off;
            }
            if (_blue != null)
            {
                dicState[_blue] = TowerLightStatus.Off;
            }
            if (_white != null)
            {
                dicState[_white] = TowerLightStatus.Off;
            }
            if (_buzzer != null)
            {
                dicState[_buzzer] = TowerLightStatus.Off;
            }
            if (_buzzer1 != null)
            {
                dicState[_buzzer1] = TowerLightStatus.Off;
            }
            if (_buzzer2 != null)
            {
                dicState[_buzzer2] = TowerLightStatus.Off;
            }
            if (_buzzer3 != null)
            {
                dicState[_buzzer3] = TowerLightStatus.Off;
            }
            if (_buzzer4 != null)
            {
                dicState[_buzzer4] = TowerLightStatus.Off;
            }
            if (_buzzer5 != null)
            {
                dicState[_buzzer5] = TowerLightStatus.Off;
            }
            foreach (KeyValuePair<string, Dictionary<IoSignalLight, TowerLightStatus>> item in _config)
            {
                object obj = DATA.Poll(item.Key);
                if (obj != null && (bool)obj)
                {
                    if (_red != null)
                    {
                        dicState[_red] = MergeCondition(dicState[_red], item.Value[_red]);
                    }
                    if (_yellow != null)
                    {
                        dicState[_yellow] = MergeCondition(dicState[_yellow], item.Value[_yellow]);
                    }
                    if (_green != null)
                    {
                        dicState[_green] = MergeCondition(dicState[_green], item.Value[_green]);
                    }
                    if (_white != null)
                    {
                        dicState[_white] = MergeCondition(dicState[_white], item.Value[_white]);
                    }
                    if (_blue != null)
                    {
                        dicState[_blue] = MergeCondition(dicState[_blue], item.Value[_blue]);
                    }
                    if (_buzzer != null)
                    {
                        dicState[_buzzer] = ((!_buzzerSwitchOff) ? MergeCondition(dicState[_buzzer], item.Value[_buzzer]) : TowerLightStatus.Off);
                    }
                    if (_buzzer1 != null)
                    {
                        dicState[_buzzer1] = ((!_buzzer1SwitchOff) ? MergeCondition(dicState[_buzzer1], item.Value[_buzzer1]) : TowerLightStatus.Off);
                    }
                    if (_buzzer2 != null)
                    {
                        dicState[_buzzer2] = ((!_buzzer2SwitchOff) ? MergeCondition(dicState[_buzzer2], item.Value[_buzzer2]) : TowerLightStatus.Off);
                    }
                    if (_buzzer3 != null)
                    {
                        dicState[_buzzer3] = ((!_buzzer3SwitchOff) ? MergeCondition(dicState[_buzzer3], item.Value[_buzzer3]) : TowerLightStatus.Off);
                    }
                    if (_buzzer4 != null)
                    {
                        dicState[_buzzer4] = ((!_buzzer4SwitchOff) ? MergeCondition(dicState[_buzzer4], item.Value[_buzzer4]) : TowerLightStatus.Off);
                    }
                    if (_buzzer5 != null)
                    {
                        dicState[_buzzer5] = ((!_buzzer5SwitchOff) ? MergeCondition(dicState[_buzzer5], item.Value[_buzzer5]) : TowerLightStatus.Off);
                    }
                }
            }
            if (_config.Count > 0 && !HostControl)
            {
                SetLight(_red, dicState);
                SetLight(_blue, dicState);
                SetLight(_yellow, dicState);
                SetLight(_green, dicState);
                SetLight(_white, dicState);
                SetLight(_buzzer, dicState);
                SetLight(_buzzer1, dicState);
                SetLight(_buzzer2, dicState);
                SetLight(_buzzer3, dicState);
                SetLight(_buzzer4, dicState);
                SetLight(_buzzer5, dicState);
            }
            MonitorLight(_red);
            MonitorLight(_blue);
            MonitorLight(_yellow);
            MonitorLight(_green);
            MonitorLight(_white);
            MonitorLight(_buzzer);
            MonitorLight(_buzzer1);
            MonitorLight(_buzzer2);
            MonitorLight(_buzzer3);
            MonitorLight(_buzzer4);
            MonitorLight(_buzzer5);
        }

        public virtual void Reset()
        {
            ResetLight(_red);
            ResetLight(_blue);
            ResetLight(_yellow);
            ResetLight(_green);
            ResetLight(_white);
            ResetLight(_buzzer);
            _buzzerSwitchOff = false;
            _buzzer1SwitchOff = false;
            _buzzer2SwitchOff = false;
            _buzzer3SwitchOff = false;
            _buzzer4SwitchOff = false;
            _buzzer5SwitchOff = false;
        }

        public virtual bool SwitchOffBuzzer(string cmd, object[] objs)
        {
            if (cmd == $"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer}" && _buzzer != null && _buzzer.StateSetPoint != 0)
            {
                _buzzerSwitchOff = true;
                _buzzer1SwitchOff = true;
            }
            if (cmd == $"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer1}" && _buzzer1 != null && _buzzer1.StateSetPoint != 0)
            {
                _buzzer1SwitchOff = true;
            }
            if (cmd == $"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer2}" && _buzzer2 != null && _buzzer2.StateSetPoint != 0)
            {
                _buzzer2SwitchOff = true;
            }
            if (cmd == $"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer3}" && _buzzer3 != null && _buzzer3.StateSetPoint != 0)
            {
                _buzzer3SwitchOff = true;
            }
            if (cmd == $"{base.Module}.{base.Name}.{AITSignalTowerOperation.SwitchOffBuzzer4}" && _buzzer4 != null && _buzzer4.StateSetPoint != 0)
            {
                _buzzer4SwitchOff = true;
            }
            return true;
        }

        private void SetLight(IoSignalLight light, Dictionary<IoSignalLight, TowerLightStatus> state)
        {
            if (light != null)
            {
                light.StateSetPoint = state[light];
            }
        }

        private void ResetLight(IoSignalLight light)
        {
            light?.Reset();
        }

        private void MonitorLight(IoSignalLight light)
        {
            light?.Monitor();
        }

        public void Terminate()
        {
        }

        protected TowerLightStatus MergeCondition(TowerLightStatus newValue, TowerLightStatus oldValue)
        {
            if (newValue == TowerLightStatus.Blinking || oldValue == TowerLightStatus.Blinking)
            {
                return TowerLightStatus.Blinking;
            }
            if (newValue == TowerLightStatus.On || oldValue == TowerLightStatus.On)
            {
                return TowerLightStatus.On;
            }
            return TowerLightStatus.Off;
        }

        protected TowerLightStatus ParseLight(string light)
        {
            if (string.IsNullOrEmpty(light))
            {
                return TowerLightStatus.Off;
            }
            TowerLightStatus result = TowerLightStatus.Unknown;
            light = light.Trim().ToLower();
            switch (light)
            {
                case "on":
                    result = TowerLightStatus.On;
                    break;
                case "off":
                    result = TowerLightStatus.Off;
                    break;
                case "blinking":
                    result = TowerLightStatus.Blinking;
                    break;
                default:
                    LOG.Write("signal tower config file has invalid set, " + light, 2, "D:\\sorter\\trunk\\Framework\\RTEquipmentLibrary\\Unit\\IoSignalTower.cs", "ParseLight", 569);
                    break;
            }
            return result;
        }
    }
}