using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XNode;
using System;
using Sirenix.OdinInspector;
using System.Linq;
using ChivaXR;

namespace ChivaVR.State
{
    /// <summary>
    /// 运行状态
    /// </summary>
    public class RunStateNode : StateNode
    {
        [Input, HideInInspector] public Empty enter;
        [Output, HideInInspector] public Empty exit;

        [ValueDropdown("GetProcedure", IsUniqueList = true)]
        [OnValueChanged("ResetCurrentProcedure")]
        [HideLabel]
        public int currentProcedureStepID;
                
        [ReadOnly]
        public string currentProcedureDescription;

        private static IEnumerable GetProcedure()
        {
            return ProcessManagement.Instance.processes.Select(x => new ValueDropdownItem(x.processBase.GetPBDescribe(), x.stepID));
        }

        private ProcessElement currentProcedure;
        public ProcessElement CurrentProcedure
        {
            get
            {
                if (currentProcedure == null)
                {
                    currentProcedure = GetCurrentProcedureByDescription();
                }
                return currentProcedure;
            }
        }

        public void ResetCurrentProcedure()
        {      
            currentProcedure = GetCurrentProcedureByStepID();

            currentProcedureDescription = currentProcedure.processBase.GetPBDescribe();
        }

        public void UpdataCurrentProcedureDescription()
        {
            if (currentProcedure == null) return;
            currentProcedureDescription = currentProcedure.processBase.GetPBDescribe();
        }

        /// <summary>
        /// 获取当前流程
        /// </summary>
        /// <returns></returns>
        public ProcessElement GetCurrentProcedureByStepID()
        {
            if (currentProcedureStepID == 0) return null;

            if (ProcessManagement.Instance.processes.Where(x => (x.stepID.Equals(currentProcedureStepID))).Count() == 0)
            {
                GetCurrentProcedureByDescription();
                return null;
            }
            return ProcessManagement.Instance.processes.Where(x => (x.stepID.Equals(currentProcedureStepID))).First();
        }

        /// <summary>
        /// 获取当前流程
        /// </summary>
        /// <returns></returns>
        public ProcessElement GetCurrentProcedureByDescription()
        {
           
            if (ProcessManagement.Instance.processes.Where(x => (x.processBase.GetPBDescribe().Equals(currentProcedureDescription))).Count() == 0)
            {
                currentProcedureDescription = "未找到对应Procedure";
                return null;
            }

            return ProcessManagement.Instance.processes.Where(x => (x.processBase.GetPBDescribe().Equals(currentProcedureDescription))).First();
        }

        public override bool IsRuning { get => base.IsRuning; set => base.IsRuning = value; }

        public override bool IsFinished
        {
            get
            {
                if (CurrentProcedure != null)
                {
                    return CurrentProcedure.finished;
                }
                return false;
            }
        }

		public override bool IsTiShi { get => base.IsTiShi; set => base.IsTiShi = value; }

		StateGraph stateGraph;
       
        [LabelText("分数:")]
        public int score = 1;

        public override void OnEnter()
        {
            base.OnEnter();

            stateGraph = graph as StateGraph;
            
            NodePort enterPort = GetInputPort("enter");
            if (enterPort.GetConnections().Count == 0) return;
            
            for (int i = 0; i < enterPort.GetConnections().Count; i++)
            {
                StateNode node = enterPort.GetConnection(i).node as StateNode;
                if (!node.IsFinished) return;
            }

            IsRuning = true;
            CurrentProcedure.SetEnterState(true);
            CurrentProcedure.Enter();
            CurrentProcedure.processElementExitHandle += FinishedProcedure;
        }

        /// <summary>
        /// 1.清空启用节点池
        /// 2.得到最新开启的节点存到池中
        /// </summary>
        public override void OnExit()
        {
            base.OnExit();

            stateGraph.OnNodeExitState(this);
            NodePort exitPort = GetOutputPort("exit");

			if (IsFinished && !IsTiShi)
			{
                //StudentExamManager.Instance.currentExammingStudentInfo.totleScore += score;
            }

            if (!exitPort.IsConnected)
            {
                Debug.LogWarning("Node isn't connected");
                return;
            }

            for (int i = 0; i < exitPort.GetConnections().Count; i++)
            {
                StateNode node = exitPort.GetConnection(i).node as StateNode;
                node.OnEnter();
            }
        }

        public void FindListenNodeState() 
        {
           StateGraph StateGraph = ProcessManagement.Instance.stateGraph;

           List<StateNode> stateNodes = new List<StateNode>();

           foreach (var item in listenStateNodes)
           {
              
           }
        }


        public void FinishedProcedure(ProcessElement currentProcess)
        {
            Debug.Log("完成" + currentProcedure.name);
            currentProcess.processElementExitHandle -= FinishedProcedure;
            OnExit();
        }

        /// <summary>
        /// 获取本节点前没有完成的Nodes
        /// </summary>
        /// <param name="runNode"></param>
        /// <returns></returns>
        public List<RunStateNode> GetEnterPortNoFinishedNode()
        {
            return ErgodicEnterPortNoFinishedNodes(this);
        }

        /// <summary>
        /// 遍历输入节点的所有没有完成的Nodes
        /// </summary>
        public List<RunStateNode> ErgodicEnterPortNoFinishedNodes(RunStateNode runNode)
        {
            List<RunStateNode> stateNodes = new List<RunStateNode>();

            NodePort enterPort = runNode.GetInputPort("enter");

            foreach (NodePort item in enterPort.GetConnections())
            {
                StateNode node = item.node as StateNode;
                if (!node.IsFinished)
                {
                    stateNodes.Add(node as RunStateNode);
                    ErgodicEnterPortNoFinishedNodes(node as RunStateNode);
                }
                else
                {
                    continue;
                }
            }
            return stateNodes;
        }
    }    
}