using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using System;
using System.Collections.Generic;

namespace MECF.Framework.Common.MultiProcess.ProcessCenter
{
    /// <summary>
    /// Rt作为客户端与服务器进行通讯，定期发送设备状态并接受服务器信息；问询服务器是否可以进行Process操作
    /// </summary>
    public class MultiProcessClient : Singleton<MultiProcessClient>
    {
        #region Service

        private IMultiProcessService _service;
        public bool InProcess { get; set; }

        public IMultiProcessService Service
        {
            get
            {
                if (_service == null)
                {
                    if (InProcess)
                    {
                        _service = new MultiProcessService();
                    }
                    else
                    {
                        _service = new MultiProcessServiceClient();
                    }
                }
                return _service;
            }
        }
        #endregion

        #region Variables

        private readonly PeriodicJob _threadMonitor;

        private bool _isConnected = true;
        protected readonly R_TRIG _connectionTrig = new();

        private bool _isPM1Installed = false;
        private bool _isPM2Installed = false;

        private string _name = "Sic08";

        private int _total = -1;
        private int _process = -1;
        private int _processidle = -1;
        private Dictionary<string, string> _allmachinestatedic = new();

        private bool PM1CanEnterProcess
        {
            get
            {
                string result;
                bool temp = Service.CanEnterProcessNow(_name, "PM1", out result);
                if (!temp)
                {
                    EV.PostWarningLog("MultiProcess", result);
                }
                return temp;

            }
        }

        private bool PM1CanEnterProcessIdle
        {
            get
            {
                string result;
                bool temp = Service.CanEnterProcessIdleNow(_name, "PM1", out result);
                if (!temp)
                {
                    EV.PostWarningLog("MultiProcess", result);
                }
                return temp;

            }
        }

        private bool PM2CanEnterProcess
        {
            get
            {
                string result;
                bool temp = Service.CanEnterProcessNow(_name, "PM2", out result);
                if (!temp)
                {
                    EV.PostWarningLog("MultiProcess", result);
                }
                return temp;

            }
        }

        private bool PM2CanEnterProcessIdle
        {
            get
            {
                string result;
                bool temp = Service.CanEnterProcessIdleNow(_name, "PM2", out result);
                if (!temp)
                {
                    EV.PostWarningLog("MultiProcess", result);
                }
                return temp;

            }
        }

        #endregion

        #region Properties

        #endregion
        #region Constructors

        public MultiProcessClient()
        {
            _threadMonitor = new PeriodicJob(10000, OnTimer, "MultiProcessHandleThread", true, true);
        }

        #endregion Constructors

        #region Methods

        /// <summary>
        /// RT作为客户端和外部服务器进行交互;注意初始化位置
        /// </summary>
        public void Initialize()
        {
            _isPM1Installed = SC.GetValue<bool>("System.SetUp.IsPM1Installed");
            _isPM2Installed = SC.GetValue<bool>("System.SetUp.IsPM2Installed");

            _name = SC.GetStringValue("System.MachineName");

            #region InitData

            DATA.Subscribe("MultiProcessClient.PM1.CanEnterProcessNow", () => PM1CanEnterProcess,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("MultiProcessClient.PM1.CanEnterProcessIdleNow", () => PM1CanEnterProcessIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe("MultiProcessClient.PM2.CanEnterProcessNow", () => PM2CanEnterProcess, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("MultiProcessClient.PM2.CanEnterProcessIdleNow", () => PM2CanEnterProcessIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            #endregion

            #region InitOp

            OP.Subscribe("MultiProcessClient.UpdateChamberState", UpdateChamberState);

            #endregion
        }

        /// <summary>
        /// 实时发送本机腔体状态
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            var ds = Service.UpdateChamberState(_name, "PM1", DateTime.Now.ToString());
            //GetMultiProcessInformation();
            //if (UpdateChamberState(null, null))
            //{
                
            //}
            return true;
        }

        /// <summary>
        /// 实时收集Process信息
        /// </summary>
        private void GetMultiProcessInformation()
        {
            var list = MultiProcessClient.Instance.Service.QueryAllProcessInformation();
            foreach (var info in list)
            {
                if (info.StartsWith("State."))
                {
                    string temp = info.Substring(6);
                    string[] temps = temp.Split('.');
                    if (temps.Length == 3)
                    {
                        _allmachinestatedic[temp[0] + "." + temp[1]] = temps[2];
                    }
                }
                else if (info.StartsWith("Total."))
                {
                    int num = -1;
                    try
                    {
                        num = Convert.ToInt16(info.Substring(6));
                    }
                    catch (Exception)
                    {
                        ;
                    }
                    _total = num;
                }
                else if (info.StartsWith("Process."))
                {
                    int num = -1;
                    try
                    {
                        num = Convert.ToInt16(info.Substring(8));
                    }
                    catch (Exception)
                    {
                        ;
                    }
                    _process = num;
                }
                else if (info.StartsWith("ProcessIdle."))
                {
                    int num = -1;
                    try
                    {
                        num = Convert.ToInt16(info.Substring(12));
                    }
                    catch (Exception)
                    {
                        ;
                    }
                    _processidle = num;
                }
            }
        }

        /// <summary>
        /// 发送腔体状态
        /// </summary>
        private bool UpdateChamberState(string arg1, object[] args)
        {
            var workenable = SC.GetValue<bool>("System.MultiProcessMode");
            if (workenable)
            {
                _isConnected = UpdateState();
            }

            _connectionTrig.CLK = _isConnected;
            if (_connectionTrig.Q)
            {
                EV.PostWarningLog("MultiProcessClient", "Failed to Connect MultiProcess Service");
            }

            return _isConnected;

        }

        private bool UpdateState()
        {
            if (_isPM1Installed)
            {
                string state = (string)DATA.Poll("PM1.Status");
                if (state != null)
                {
                    if (!Service.UpdateChamberState(_name, "PM1", state))
                    {
                        return false;
                    }

                }
            }
            if (_isPM2Installed)
            {
                string state = (string)DATA.Poll("PM2.Status");
                if (state != null)
                {
                    if (!Service.UpdateChamberState(_name, "PM2", state))
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        #endregion

    }
}