using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.IOAxis;
using MECF.Framework.Common.Utilities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MECF.Framework.Common.TwinCat
{
    public class BeckhoffAxisManager : Singleton<BeckhoffAxisManager>
    {
        #region 常量
        private string IO_TYPE = "axis";
        #endregion
        #region 内部变量
        private Dictionary<string, Dictionary<string, object>> _moduleVariableValueDic = new Dictionary<string, Dictionary<string, object>>();
        private Dictionary<string, BeckhoffDelegate.OnUpdateModuleVariableValue> _moduleVariableActionDic = new Dictionary<string, BeckhoffDelegate.OnUpdateModuleVariableValue>();
        private Dictionary<string, BeckhoffAxis> _moduleAxisDic = new Dictionary<string, BeckhoffAxis>();
        private int _size = 0;
        private BeckhoffCfg _cfg;
        #endregion
        #region 属性
        public int Size { get { return _size; } set { _size = value; } }
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="cfg"></param>
        public void Initialize(BeckhoffCfg cfg)
        {
            _cfg = cfg;
            foreach (BeckhoffAxis item in cfg.Controller.Axises)
            {
                string moduleName = item.Name;
                if (!_moduleVariableValueDic.ContainsKey(moduleName))
                {
                    _moduleVariableValueDic[moduleName] = new Dictionary<string, object>();
                }
                foreach (BeckhoffAxisInput input in item.Inputs)
                {
                    if (!input.Address.StartsWith("0x"))
                    {
                        string inputName = $"{moduleName}.{input.Type}";
                        _moduleVariableValueDic[moduleName][input.Type] = null;
                        int dataSize = DataTypeUtil.GetDataTypeSize(input.DataType);
                        BeckhoffItemManager.Instance.InitBeckhoffItem(inputName, input.Address, input.DataType, IO_TYPE, dataSize, false, 0,false);
                        _size += dataSize;
                    }
                    else
                    {
                        _moduleVariableValueDic[moduleName][input.Type] = null;
                    }
                }
                foreach (BeckhoffAxisOutput output in item.Outputs)
                {
                    if (!output.Address.StartsWith("0x"))
                    {
                        string outputName = $"{moduleName}.{output.Type}";
                        _moduleVariableValueDic[moduleName][output.Type] = null;
                        int dataSize = DataTypeUtil.GetDataTypeSize(output.DataType);
                        BeckhoffItemManager.Instance.InitBeckhoffItem(outputName, output.Address, output.DataType, IO_TYPE, dataSize, false, 0,false);
                        BeckhoffItemManager.Instance.InitWriteBeckoffItem(outputName, output.Address, output.DataType, IO_TYPE, dataSize, false, 0,false);
                        _size += dataSize;
                    }
                }
                DATA.Subscribe($"{moduleName}.BeckhoffAxis", () => item, SubscriptionAttribute.FLAG.IgnoreSaveDB);
                _moduleAxisDic[moduleName] = item;
            }
        }
        /// <summary>
        /// 启动coe服务
        /// </summary>
        public void StartCoeInterface()
        {
            Thread coeSthread = new Thread(new ThreadStart(StartCOEInterfaceThread));
            coeSthread.IsBackground = true;
            coeSthread.Start();
        }
        /// <summary>
        /// 启动COE接口线程
        /// </summary>
        private void StartCOEInterfaceThread()
        {
            bool isSimulatorMode = SC.GetValue<bool>("System.IsSimulatorMode");
            foreach (BeckhoffAxis item in _cfg.Controller.Axises)
            {
                if (!isSimulatorMode)
                {
                    TwincatCoeManager.Instance.Initialize(item);
                }
            }
            if (!isSimulatorMode)
            {
                TwincatCoeManager.Instance.StartReadInput();
            }
        }
        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public void SetAxisValue(string name,object value)
        {
            bool _enableRead = SC.GetValue<bool>("Twincat.EnableReadLog");
            if (_enableRead)
            {
                LOG.WriteBackgroundLog(eEvent.INFO_TWINCAT, "System", $"read {name} value {value}");
            }
            string[] strAry = name.Split('.');
            if(strAry.Length<2)
            {
                return;
            }
            string moduleName = $"{strAry[0]}.{strAry[1]}";
            string variableName = name.Replace($"{moduleName}.","");
            if(_moduleVariableValueDic.ContainsKey(moduleName))
            {
                if (_moduleVariableValueDic[moduleName].ContainsKey(variableName))
                {
                    _moduleVariableValueDic[moduleName][variableName] = value;
                    if(_moduleVariableActionDic.ContainsKey(name))
                    {
                        _moduleVariableActionDic[name].Invoke(variableName, value);
                    }
                }
            }
        }

        /// <summary>
        /// 注册变量数值发生变化回调
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="variable"></param>
        /// <param name="onUpdateModuleVariableValue"></param>
        public void SubscribeModuleVariable(string moduleName, string variable, BeckhoffDelegate.OnUpdateModuleVariableValue onUpdateModuleVariableValue)
        {
            _moduleVariableActionDic[$"{moduleName}.{variable}"] = onUpdateModuleVariableValue;
            if (_moduleVariableValueDic.ContainsKey(moduleName))
            {
                if (_moduleVariableValueDic[moduleName].ContainsKey(variable))
                {
                    _moduleVariableActionDic[$"{moduleName}.{variable}"].Invoke(variable, _moduleVariableValueDic[moduleName][variable]);
                }
            }
        }
        /// <summary>
        /// 写入变量数值
        /// </summary>
        /// <param name="name"></param>
        /// <param name="setPoint"></param>
        /// <returns></returns>
        public bool WriteVariableValue(string name,object setPoint)
        {
            return TwincatAdoManager.Instance.WriteValue(name, setPoint);
        }

        /// <summary>
        /// 获取Axis对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public BeckhoffAxis GetAxis(string name)
        {
            return _moduleAxisDic.ContainsKey(name) ? _moduleAxisDic[name]:null;
        }
    }
}