namespace ChivaXR.VR
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;

    public class CVR_ToolManager : MonoSingleton<CVR_ToolManager>
    {
        //交互工具
        public Dictionary<CVR_ToolType, List<IVR_Interactable>> dic_Tools = new Dictionary<CVR_ToolType, List<IVR_Interactable>>();
        //触发工具
        public Dictionary<CVR_ToolType, List<CVR_TriggerTool>> dic_TriggerTools = new Dictionary<CVR_ToolType, List<CVR_TriggerTool>>();
        //模拟工具辅助点
        public Dictionary<CVR_ToolType, List<CVR_SimulationPoint>> dic_SimulationPoints = new Dictionary<CVR_ToolType, List<CVR_SimulationPoint>>();

        /// <summary>
        /// 所有工器具的触发事件
        /// </summary>
        public event CVRInteractableTriggerEventHandler InteractableTrigger;

        /// <summary>
        /// 注册交互工具
        /// </summary>
        /// <param name="toolType"></param>
        /// <param name="interactable"></param>
        public void RegisterTool(CVR_ToolType toolType, IVR_Interactable interactable)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);

            foreach (var item in toolTypes)
            {
                if (!dic_Tools.ContainsKey(item))
                {
                    dic_Tools.Add(item, new List<IVR_Interactable>() { interactable });
                }
                else if (!dic_Tools[item].Contains(interactable))
                {
                    dic_Tools[item].Add(interactable);
                }
            }
        }

        /// <summary>
        /// 添加触发模块
        /// </summary>
        /// <param name="toolType"></param>
        /// <param name="triggerTool"></param>
        public void RegisterTriggerTool(CVR_ToolType toolType, CVR_TriggerTool triggerTool)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);

            foreach (var item in toolTypes)
            {
                if (!dic_TriggerTools.ContainsKey(item))
                {
                    dic_TriggerTools.Add(item, new List<CVR_TriggerTool>() { triggerTool });
                }
                else if (!dic_TriggerTools[item].Contains(triggerTool))
                {
                    dic_TriggerTools[item].Add(triggerTool);
                }
            }

            UpDateTriggerList(triggerTool);
            triggerTool.InteractableTrigger += InteractableToolTrigger;
        }

        public void UpDateTriggerList(CVR_TriggerTool triggerTool)
        {
            //如果目标工具不支持脚本检测方式,添加脚本检测
            if ((triggerTool.TriggerList.checkType & CVR_TriggerList.CheckTypes.Script) == 0)
            {
                triggerTool.TriggerList.checkType = triggerTool.TriggerList.checkType | CVR_TriggerList.CheckTypes.Script;
            }
            //如果目标工具不支持当前系统Data检测，添加Data检测
            if (!triggerTool.TriggerList.identifiers.Contains(typeof(CVR_ValueElement).Name))
            {
                triggerTool.TriggerList.identifiers.Add(typeof(CVR_ValueElement).Name);
            }
            if (!triggerTool.TriggerList.identifiers.Contains(typeof(CVR_TriggerElement).Name))
            {
                triggerTool.TriggerList.identifiers.Add(typeof(CVR_TriggerElement).Name);
            }
        }

        /// <summary>
        /// 交互工具触发(已注册所有工具的触发事件)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void InteractableToolTrigger(object sender, CVR_InteractableTriggerEventArgs e)
        {
            if (InteractableTrigger != null)
            {
                InteractableTrigger(sender, e);
            }

            CheckTriggerElementInColliders(e);
        }

        private static void CheckTriggerElementInColliders(CVR_InteractableTriggerEventArgs e)
        {
            for (int i = 0; i < e.triggerObjects.Length; i++)
            {
                IVR_OperationElement operationElement = (IVR_OperationElement)e.triggerObjects[i].GetComponentInParent<IVR_OperationElement>();

                if (operationElement == null || (operationElement.GetToolType() & e.toolType) == 0 || !operationElement.GetActive()) continue;

                operationElement.Trigger(e);
                Debug.Log(operationElement.GetToolType());
                //一个工具优先只触发一种TriggerElement
                return;
            }
        }

        /// <summary>
        /// 添加模拟模块
        /// </summary>
        /// <param name="toolType"></param>
        /// <param name="_simulationPoint"></param>
        public void RegisterToolSimulationPoint(CVR_ToolType toolType, CVR_SimulationPoint _simulationPoint)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);

            foreach (var item in toolTypes)
            {
                if (!dic_SimulationPoints.ContainsKey(item))
                {
                    dic_SimulationPoints.Add(item, new List<CVR_SimulationPoint>() { _simulationPoint });
                }
                else if (!dic_SimulationPoints[item].Contains(_simulationPoint))
                {
                    dic_SimulationPoints[item].Add(_simulationPoint);
                }
            }
        }

        /// <summary>
        /// 创建模拟操作辅助点
        /// </summary>
        /// <param name="toolType"></param>
        /// <returns></returns>
        public CVR_SimulationPoint CreatSimulationPoint(CVR_ToolType toolType)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);
            CVR_SimulationPoint point = CVR_SimulationPool.Instance.GetSimulationPoint();

            foreach (var item in toolTypes)
            {
                RegisterToolSimulationPoint(toolType, point);
            }
            return point;
        }

        /// <summary>
        /// 清除模拟操作辅助点
        /// </summary>
        /// <param name="toolType"></param>
        /// <param name="point"></param>
        public void ClearSimulationPoint(CVR_ToolType toolType, CVR_SimulationPoint point)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);

            foreach (var item in toolTypes)
            {
                if (dic_SimulationPoints.ContainsKey(toolType))
                {
                    if (dic_SimulationPoints[toolType].Contains(point))
                    {
                        dic_SimulationPoints[toolType].Remove(point);
                    }
                    if (dic_SimulationPoints[toolType].Count == 0)
                    {
                        dic_SimulationPoints.Remove(toolType);
                    }
                }
            }
            //回收至对象池
            CVR_SimulationPool.Instance.RecycleSimulationPoint(point);
        }

        /// <summary>
        /// 根据多选枚举获取对应IVR_Interactable
        /// </summary>
        /// <param name="toolType"></param>
        /// <returns></returns>
        public IVR_Interactable[] GetTools(CVR_ToolType toolType)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);
            List<IVR_Interactable> _tools = new List<IVR_Interactable>();

            foreach (var item in toolTypes)
            {
                if (dic_Tools.ContainsKey(item))
                {
                    _tools.AddRange(dic_Tools[item].ToArray());
                }
            }

            return _tools.ToArray();
        }

        /// <summary>
        /// 根据多选枚举获取对应TriggerTool
        /// </summary>
        /// <param name="toolType"></param>
        /// <returns></returns>
        public CVR_TriggerTool[] GetTool_Triggers(CVR_ToolType toolType)
        {
            var toolTypes = EnumHelper.GetEnumValuesFromFlagsEnum<CVR_ToolType>((int)toolType);
            List<CVR_TriggerTool> _triggerTools = new List<CVR_TriggerTool>();

            foreach (var item in toolTypes)
            {
                if (dic_TriggerTools.ContainsKey(item))
                {
                    _triggerTools.AddRange(dic_TriggerTools[item].ToArray());
                }
            }

            return _triggerTools.ToArray();
        }
    }
}