using System;
using System.Collections;
using System.Collections.Generic;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using UnityEngine;
using UnityEngine.UIElements;

namespace BITKit.UX
{
    public class UIToolkitSubPanel<T> :IUXPanel where T : IUXPanel 
    {
        private readonly IServiceProvider _serviceProvider;
        protected readonly T Panel;

        protected readonly ValidHandle IsVisible=new();
        private readonly ValidHandle _busy = new();
        
        public UIToolkitSubPanel(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;

            Panel = serviceProvider.GetRequiredService<T>();

            Panel.OnInitiated += OnInitiated;
            Panel.OnInitiatedAsync += OnInitiatedAsync;

            if (Panel is UIToolKitPanel uiToolKitPanel)
            {
                if (uiToolKitPanel.WaitUtilInitialized.Task.Status is UniTaskStatus.Succeeded)
                {
                    OnInitiatedAsync().Forget();
                    OnInitiated();
                }
            }

            Panel.OnEntry +=()=> IsVisible.RemoveDisableElements(this);
            Panel.OnExit +=()=> IsVisible.AddDisableElements(this);
            
            IsVisible.AddListener(IsVisibleCallback);
        }

        private async void IsVisibleCallback(bool x)
        {
            await _busy;
            using var busy = _busy.GetHandle();
            if (x)
            {
                OnEntry?.Invoke();
                OnEntryAsync?.Invoke();
                OnEntryCompleted?.Invoke();
            }
            else
            {
                OnExit?.Invoke();
                OnExitAsync?.Invoke();
                OnExitCompleted?.Invoke();
            }
        }

        protected virtual UniTask OnInitiatedAsync()
        {
            UXUtils.Inject(this,Panel.Root as VisualElement);
            return UniTask.CompletedTask;
        }
        protected virtual void OnInitiated()
        {  UXUtils.Inject(this,Panel.Root as VisualElement);
  
        }
        bool IUXPanel.IsWindow => Panel.IsWindow;

        string IUXPanel.Index => Panel.Index;

        bool IUXPanel.AllowCursor => Panel.AllowCursor;

        bool IUXPanel.AllowInput => Panel.AllowInput;

        object IUXPanel.Root => Panel.Root;
        public event Action OnEntry;
        public event Func<UniTask> OnEntryAsync;
        public event Action OnEntryCompleted;
        public event Action OnExit;
        public event Func<UniTask> OnExitAsync;
        public event Action OnExitCompleted;

        event Action IUXPanel.OnInitiated
        {
            add => Panel.OnInitiated += value;
            remove => Panel.OnInitiated -= value;
        }

        event Func<UniTask> IUXPanel.OnInitiatedAsync
        {
            add => Panel.OnInitiatedAsync += value;
            remove => Panel.OnInitiatedAsync -= value;
        }

        void IUXPanel.OnTick(float deltaTime)
        {
            Panel.OnTick(deltaTime);
        }

        public bool Enabled
        {
            get => Panel.Enabled;
            set => Panel.Enabled = value;
        }

        public void Initialize()
        {
            Panel.Initialize();
        }

        public void OnStateEntry(IState old)
        {
            Panel.OnStateEntry(old);
        }

        public void OnStateUpdate(float deltaTime)
        {
            Panel.OnStateUpdate(deltaTime);
        }

        public void OnStateExit(IState old, IState newState)
        {
            Panel.OnStateExit(old, newState);
        }

        public int Identifier
        {
            get => Panel.Identifier;
            set => Panel.Identifier = value;
        }

        public UniTask InitializeAsync()
        {
            return Panel.InitializeAsync();
        }

        public UniTask OnStateEntryAsync(IState old)
        {
            return Panel.OnStateEntryAsync(old);
        }

        public UniTask OnStateUpdateAsync(float deltaTime)
        {
            return Panel.OnStateUpdateAsync(deltaTime);
        }

        public UniTask OnStateExitAsync(IState old, IState newState)
        {
            return Panel.OnStateExitAsync(old, newState);
        }
    }

}