/***
 * writer: YKMoon
 * desc: 流程管理器
 ***/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace YKMoon.Procedure
{
    public class ProcProcessor
    {
        protected List<IProc> procedureList = new List<IProc>();
        private int index = -1;
        private IProc currentProcedure;
        public bool isRunning { get; protected set; }
        private System.Action finishedCB;
        public ProcProcessor(System.Action finishedCB)
        {
            this.finishedCB = finishedCB;
        }
        /// <summary>
        /// Add a procedure to processor.
        /// </summary>
        /// <param name="procedure"></param>
        public void AddProcedure(ABaseProc procedure)
        {
            if(procedure == null) {
                return;
            }
            procedure.Init(ToNext);
            procedureList.Add(procedure);
        }

        public void Start()
        {
            if(isRunning) {
                return;
            }
            isRunning = true;
            if(procedureList.Count == 0) {
                Finish();
            } else {
                index = -1;
                ToNext();
            }
        }

        public void Update(float deltaTime)
        {
            if(!isRunning) {
                return;
            }
            currentProcedure?.Update(deltaTime);
        }

        public void Stop()
        {
            if(!isRunning)
                return;
            currentProcedure?.Exit();
            currentProcedure = null;
            isRunning = false;
        }

        protected void ToNext()
        {
            ++index;
            currentProcedure?.Exit();
            currentProcedure = null;
            if(index >= procedureList.Count) {
                Finish();
            } else {
                currentProcedure = procedureList[index];
                currentProcedure.Enter();
            }
        }

        private void Finish()
        {
            isRunning = false;
            finishedCB?.Invoke();
        }
    }

    public class ProcProcessor<T> : ProcProcessor
    {
        private T param;
        public ProcProcessor(System.Action finishedCB, T param) : base(finishedCB)
        {
            this.param = param;
        }
        /// <summary>
        /// Add a procedure to processor.
        /// </summary>
        /// <param name="procedure"></param>
        public void AddProcedure(ABaseProc<T> procedure)
        {
            if(procedure == null) {
                return;
            }
            procedure.Init(ToNext, param);
            procedureList.Add(procedure);
        }
    }
    public class ProcProcessor<T, K> : ProcProcessor
    {
        private T param1;
        private K param2;
        public ProcProcessor(System.Action finishedCB, T param1, K param2) : base(finishedCB)
        {
            this.param1 = param1;
            this.param2 = param2;
        }
        /// <summary>
        /// Add a procedure to processor.
        /// </summary>
        /// <param name="procedure"></param>
        public void AddProcedure(ABaseProc<T, K> procedure)
        {
            if(procedure == null) {
                return;
            }
            procedure.Init(ToNext, param1, param2);
            procedureList.Add(procedure);
        }
    }
}