using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using athosRT.tool;
using Common.DataCenter;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace athosRT.Devices.PA
{
    public abstract class PreAligner : BaseDevice, IDevice, IConnection
    {
        public enum PAStatus
        {
            Init,
            Idle,
            Error,
            Home,
            Align,
            Reset
        }
        public const string delimiter = "\r";

        private static object _locker = new object();

        private AsyncSocket _socket;

        private IHandler _eventHandler = null;

        private IHandler _backgroundHandler = null;

        private IHandler _foregroundHandler = null;

        private IAlignerHandlerFactory _factory = null;

        private bool _commErr = false;

        private string _addr;

        private DeviceTimer _timerQuery = new DeviceTimer();

        private string AlarmAlignerMotionError = "AlignerMotionError";

        public string Address => _addr;

        public virtual bool IsConnected => _socket.IsConnected;

        public int LastErrorCode { get; set; }

        public virtual PAStatus Status { get; set; }

        public int ErrorCode { get; set; }

        public int ElapseTime { get; set; }

        public int Notch { get; set; }

        public bool Initalized { get; set; }

        public bool Communication => !_commErr;

        public virtual bool Busy => _backgroundHandler != null || _foregroundHandler != null;

        public virtual bool Moving => _backgroundHandler != null;

        public virtual bool Error => ErrorCode >= Convert.ToInt32("2EB0", 16) || _commErr;

        public virtual int Feedback4Inch => 1;
        public virtual int Feedback3Inch => 1;
        public virtual int SetPoint4Inch => 1;
        public virtual int SetPoint3Inch => 1;
        public virtual bool SetPointLift => false;

        public DeviceState State
        {
            get
            {
                if (!Initalized)
                {
                    return DeviceState.Unknown;
                }
                if (Error)
                {
                    return DeviceState.Error;
                }
                if (Busy)
                {
                    return DeviceState.Busy;
                }
                return DeviceState.Idle;
            }
        }

        public bool StateWaferHold { get; set; }

        public virtual bool Disconnect()
        {
            return true;
        }

        public virtual bool Connect()
        {
            return true;
        }

        public PreAligner(string module, string name, string display, string deviceId, string address)
            : base(module, name, display, deviceId)
        {
            _addr = address;
            if (!string.IsNullOrEmpty(_addr))
            {
                _socket = new AsyncSocket(address);
                _socket.OnDataChanged += OnDataChanged;
                //_socket.OnErrorHappened += OnErrorHandler;
            }
            Initalized = false;
            _commErr = false;
            Singleton<WaferManager>.Instance.SubscribeLocation(name, 1);
        }

        public virtual bool Initialize()
        {
            _eventHandler = _factory.Event();
            Singleton<ConnectionManager>.Instance.Subscribe(base.Name, this);
            if (!string.IsNullOrEmpty(_addr))
            {
                _socket.Connect(_addr);
            }
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Init"), delegate (out string reason, int time, object[] param)
            {
                if (Init(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Init");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerInit"), delegate (out string reason, int time, object[] param)
            {
                if (Init(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Init");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Home"), delegate (out string reason, int time, object[] param)
            {
                if (Home(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Home");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerHome"), delegate (out string reason, int time, object[] param)
            {
                if (Home(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Home");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Reset"), delegate (out string reason, int time, object[] param)
            {
                if (Clear(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Reset Error");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerReset"), delegate (out string reason, int time, object[] param)
            {
                if (Clear(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Reset Error");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Grip"), delegate (out string reason, int time, object[] param)
            {
                if (Grip(Hand.Blade1, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Hold Wafer");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerGrip"), delegate (out string reason, int time, object[] param)
            {
                if (Grip(Hand.Blade1, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Hold Wafer");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Release"), delegate (out string reason, int time, object[] param)
            {
                if (Release(Hand.Blade1, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Release Wafer");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerRelease"), delegate (out string reason, int time, object[] param)
            {
                if (Release(Hand.Blade1, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Release Wafer");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "LiftUp"), delegate (out string reason, int time, object[] param)
            {
                if (LiftUp(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Lifter Up");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerLiftUp"), delegate (out string reason, int time, object[] param)
            {
                if (LiftUp(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Lifter Up");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "LiftDown"), delegate (out string reason, int time, object[] param)
            {
                if (LiftDown(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Lifter Down");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerLiftDown"), delegate (out string reason, int time, object[] param)
            {
                if (LiftDown(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Lifter Down");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Stop"), delegate (out string reason, int time, object[] param)
            {
                if (Stop(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Stop Align");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerStop"), delegate (out string reason, int time, object[] param)
            {
                if (Stop(out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "Stop Align");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "Align"), delegate (out string reason, int time, object[] param)
            {
                double angle2 = double.Parse((string)param[0]);
                if (Align(angle2, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "PreAlign");
                    return true;
                }
                return false;
            });
            DEVICE.Register(string.Format("{0}.{1}", base.Name, "AlignerAlign"), delegate (out string reason, int time, object[] param)
            {
                double angle = double.Parse((string)param[0]);
                if (Align(angle, out reason))
                {
                    reason = string.Format("{0} {1}", base.Name, "PreAlign");
                    return true;
                }
                return false;
            });
            DATA.Subscribe(base.Name + ".State", () => State);
            DATA.Subscribe(base.Name + ".AlignerState", () => State.ToString());
            DATA.Subscribe(base.Name + ".Busy", () => Busy);
            DATA.Subscribe(base.Name + ".ErrorCode", () => ErrorCode);
            DATA.Subscribe(base.Name + ".Error", () => Error);
            DATA.Subscribe(base.Name + ".ElapseTime", () => ElapseTime);
            DATA.Subscribe(base.Name + ".Notch", () => Notch);
            //EV.Subscribe(new EventItem(0, "Event", AlarmAlignerMotionError, "Aligner error", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            return true;
        }

        public virtual void Terminate()
        {
            _socket.Dispose();
        }

        public virtual void Monitor()
        {
        }

        public virtual void Reset()
        {
            lock (_locker)
            {
                _foregroundHandler = null;
                _backgroundHandler = null;
            }
            if (_commErr)
            {
                _commErr = false;
                _socket.Connect(_addr);
            }
        }

        public virtual bool Init(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool Home(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool Clear(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool Grip(Hand hand, out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool Release(Hand hand, out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool LiftUp(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool LiftDown(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool MoveToReady(out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool Align(double angle, out string reason)
        {
            reason = string.Empty;
            return true;
        }

        public virtual bool QueryState(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.QueryState(), out reason);
        }

        public virtual bool Stop(out string reason)
        {
            reason = string.Empty;
            lock (_locker)
            {
                _foregroundHandler = null;
                _backgroundHandler = null;
            }
            return execute(_factory.Stop(), out reason);
        }

        private bool execute(IHandler handler, out string reason)
        {
            reason = string.Empty;
            lock (_locker)
            {
                if (_foregroundHandler != null)
                {
                    reason = "System busy, please wait or reset system.";
                    //EV.PostMessage(base.Name, EventEnum.DefaultWarning, $"{base.DeviceID} {handler.ToString()} {reason}");
                    return false;
                }
                if (_backgroundHandler != null && handler.IsBackground)
                {
                    reason = "System busy，one background command is running, please wait or reset system.";
                    //EV.PostMessage(base.Name, EventEnum.DefaultWarning, $"{base.DeviceID} {handler.ToString()} {reason}");
                    return false;
                }
                handler.Unit = 2;
                if (!handler.Execute(ref _socket))
                {
                    reason = "Communication error,please check it.";
                    return false;
                }
                if (handler.IsBackground)
                {
                    _backgroundHandler = handler;
                }
                else
                {
                    _foregroundHandler = handler;
                }
            }
            return true;
        }

        private void OnDataChanged(string package)
        {
            try
            {
                package = package.ToUpper();
                string[] array = Regex.Split(package, "\r");
                string[] array2 = array;
                foreach (string text in array2)
                {
                    if (text.Length <= 0)
                    {
                        continue;
                    }
                    bool completed = false;
                    string msg = text;
                    lock (_locker)
                    {
                        if (_foregroundHandler != null && _foregroundHandler.OnMessage(ref _socket, msg, out completed))
                        {
                            _foregroundHandler = null;
                        }
                        else if (_backgroundHandler != null && _backgroundHandler.OnMessage(ref _socket, msg, out completed))
                        {
                            if (completed)
                            {
                                string reason = string.Empty;
                                QueryState(out reason);
                                _backgroundHandler = null;
                            }
                        }
                        else if (_eventHandler != null && _eventHandler.OnMessage(ref _socket, msg, out completed) && completed)
                        {
                            //EV.PostMessage("Aligner", EventEnum.DefaultWarning, $" has error. {ErrorCode:X}");
                            OnError($" has error. {ErrorCode:X}");
                        }
                    }
                }
            }
            catch (ExcuteFailedException ex)
            {
                //EV.PostMessage("Aligner", EventEnum.DefaultWarning, $"executed failed. {ex.Message}");
                OnError($"executed failed. {ex.Message}");
            }
            catch (InvalidPackageException ex2)
            {
                //EV.PostMessage("Aligner", EventEnum.DefaultWarning, $"receive invalid package. {ex2.Message}");
                OnError($"receive invalid package. {ex2.Message}");
            }
            catch (Exception ex3)
            {
                _commErr = true;
                //LOG.Write("Aligner failed：" + ex3.ToString(), 2, "D:\\sorter\\trunk\\Framework\\RTEquipmentLibrary\\HardwareUnits\\Robots\\Aligner.cs", "OnDataChanged", 604);
            }
        }

        private void OnErrorHandler(ErrorEventArgs args)
        {
            Initalized = false;
            _commErr = true;
            //EV.PostMessage(base.Module, EventEnum.CommunicationError, base.Display, args.Reason);
            OnError("Communciation Error");
        }

        private void OnError(string errortext)
        {
            //EV.Notify(AlarmAlignerMotionError, new SerializableDictionary<string, object> { { "AlarmText", errortext } });
        }
    }
}