using System;
using Cysharp.Threading.Tasks;

namespace BITKit
{
    public interface IOptional
    {
        bool Allow { get; }
        object Value { get; }
    }
    public interface IOptional<T>
    {
        bool Allow { get; set; }
        T Value { get; set; }
        T IfNotAllow(T value);
    }
    public class ReadOnlyOptional<T> : IOptional<T>
    {
        private readonly T value;
        private readonly bool allow;

        public ReadOnlyOptional(bool allow,T value )
        {
            this.value = value;
            this.allow = allow;
        }
        public bool Allow
        {
            get => allow;
            set => throw new NotSupportedException();
        }
        public T Value { get => value; set => throw new NotSupportedException(); }
        public T IfNotAllow(T _value)
        {
            return allow ? Value : _value;
        }
    }
    [System.Serializable]
    public class Optional<T> : IOptional<T>
    {
        public Optional(){}
        public Optional(T value, bool allow=false)
        {
            this.allow = allow;
            this.value = value;
        }
#if NET5_0_OR_GREATER
        bool allow;
        T value;
#else
        [UnityEngine.SerializeField]
        private bool allow;
        [UnityEngine.SerializeField]
        private T value;
        [UnityEngine.SerializeField] 
#endif
        private bool debug;
        public bool Allow { get => allow; set => allow = value;}
        public T Value
        {
            get => value;
            set=>this.value=value;
        }

        public T IfNotAllow(T other)
        {
            return Allow ? Value : other;
        }
        public T IfNotAllow(Func<T> other)
        {
            return Allow ? Value : other.Invoke();
        }

        public async UniTask<T> IfNotAllowAsync(Func<UniTask<T>> func)
        {
            return Allow ? Value : await func.Invoke();
        }

        public async UniTask<T> SetValueThenAllowAsync(Func<UniTask<T>> func)
        {
            if (Allow)
            {
                return value;
            }
            value = await func.Invoke();
            allow = true;
            return value;
        }

        public void SetValueThenAllow(T newValue)
        {
            value = newValue;
            allow = true;
        }

        public void Clear()
        {
            Allow = false;
            value = default;
        }
        
        public static implicit operator T(Optional<T> self)
        {
            return self.value;
        }
    }
}