BITKit/Packages/Core/Utility/ValidHandle.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace BITKit
{
    public class ValidHandle
    {
        public ValidHandle() { Init(); }
        public ValidHandle(Action<bool> boolDelegate)
        {
            AddListener(boolDelegate);
            Init();
            EventOnEnableChanged?.Invoke(enableHandle);
        }
        void Init()
        {
          AddListener(OnInoke);
        }
        public static implicit operator bool(ValidHandle validHandle)
        {
            return validHandle.enableHandle;
        }
        private bool enableHandle;
        private int enableElementCount;
        private int disableElementCount;
        List<object> objs = new List<object>();
        List<object> disableObjs = new List<object>();
        [System.NonSerialized]
        bool tempEnable;
        public Action<bool> EventOnEnableChanged;
        public virtual void AddElement(object obj)
        {
            if (objs.Contains(obj))
            {

            }
            else
            {
                objs.Add(obj);
            }
            CheckEnable();
        }
        protected virtual void CheckEnable()
        {
            tempEnable = objs.Count > 0 && disableObjs.Count == 0;
            if (tempEnable != enableHandle)
            {
                enableHandle = tempEnable;
                if (EventOnEnableChanged is not null)
                    EventOnEnableChanged.Invoke(enableHandle);
                OnEnable(enableHandle);

            }
            enableElementCount = objs.Count;
            disableElementCount = disableObjs.Count;
        }
        protected virtual void OnEnable(bool enable) { }
        public virtual void RemoveElement(object obj)
        {
            if (objs.Contains(obj))
            {
                objs.Remove(obj);
            }
            else
            {

            }
            CheckEnable();
        }
        public virtual int lenght => objs.Count;
        public virtual string[] GetElements()
        {
            List<string> elementNames = new List<string>();
            for (int i = 0; i < objs.Count; i++)
            {
                elementNames.Add(objs[i].ToString());
            }
            return elementNames.ToArray();
        }
        public virtual bool Contains(object obj) => objs.Contains(obj);
        public virtual void AddDisableElements(object obj)
        {
            if (disableObjs.Contains(obj))
            {

            }
            else
            {
                disableObjs.Add(obj);
            }
            CheckEnable();
        }
        public virtual void RemoveDisableElements(object obj)
        {
            if (disableObjs.Contains(obj))
            {
                disableObjs.Remove(obj);
            }
            else
            {
            }
            CheckEnable();
        }
        public virtual void SetElements(object obj, bool add = true)
        {
            if (add)
            {
                AddElement(obj);
            }
            else
            {
                RemoveElement(obj);
            }
        }
        public virtual void SetDisableElements(object obj, bool add = true)
        {
            if (add)
            {
                AddDisableElements(obj);
            }
            else
            {
                RemoveDisableElements(obj);
            }
        }
        public virtual void Invoke()
        {
            bool enable = disableObjs.Count == 0 && objs.Count > 0;
            EventOnEnableChanged.Invoke(enable);
        }
        public virtual void Invoke(bool value)
        {
            EventOnEnableChanged.Invoke(value);
        }
        public virtual void OnInoke(bool value)
        {

        }
        public virtual void AddListener(Action<bool> action)
        {
            EventOnEnableChanged+= action;
        }
        public virtual void RemoveListener(Action<bool> action)
        {
            if(EventOnEnableChanged is not null && action is not  null)
            {
                EventOnEnableChanged -= action;
            }
        }
    }
}