using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using Object = UnityEngine.Object;

namespace AlicizaX.UI.Runtime
{
    public abstract partial class UIBase : IDisposable
    {
        protected UIBase()
        {
            _state = UIState.CreatedUI;
        }

        ~UIBase() => Dispose(false);
        private bool _disposed;

        internal Canvas _canvas;

        internal GraphicRaycaster _raycaster;

        internal UIState _state = UIState.Uninitialized;
        internal UIState State => _state;


        private System.Object[] _userDatas;
        protected System.Object UserData => _userDatas != null && _userDatas.Length >= 1 ? _userDatas[0] : null;
        protected System.Object[] UserDatas => _userDatas;


        protected virtual void OnInitlize()
        {
        }

        protected virtual void OnDestroy()
        {
        }

        protected virtual void OnOpen()
        {
        }

        protected virtual void OnClose()
        {
        }

        protected virtual void OnUpdate()
        {
        }


        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (_disposed) return;

            if (disposing)
            {
                // 托管资源释放
                _canvas = null;
                _raycaster = null;
            }

            _userDatas = null;

            // 非托管资源释放
            if (Holder != null)
            {
                if (Application.isPlaying)
                    Object.Destroy(Holder.gameObject);
                else
                    Object.DestroyImmediate(Holder.gameObject);
            }

            _disposed = true;
        }

        internal bool Visible
        {
            get => _canvas != null && _canvas.gameObject.layer == UIComponent.UIShowLayer;

            set
            {
                if (_canvas != null)
                {
                    int setLayer = value ? UIComponent.UIShowLayer : UIComponent.UIHideLayer;
                    if (_canvas.gameObject.layer == setLayer)
                        return;

                    _canvas.gameObject.layer = setLayer;
                    ChildVisible(value);

                    Interactable = value;
                }
            }
        }

        private bool Interactable
        {
            get => _raycaster.enabled && _raycaster != null;

            set
            {
                if (_raycaster != null && _raycaster.enabled != value)
                {
                    _raycaster.enabled = value;
                }
            }
        }

        /// <summary>
        /// 窗口深度值。
        /// </summary>
        internal int Depth
        {
            get => _canvas != null ? _canvas.sortingOrder : 0;

            set
            {
                if (_canvas != null && _canvas.sortingOrder != value)
                {
                    // 设置父类
                    _canvas.sortingOrder = value;

                    // 设置子类
                    int depth = value;
                    // for (int i = 0; i < _childCanvas.Length; i++)
                    // {
                    //     var canvas = _childCanvas[i];
                    //     if (canvas != _canvas)
                    //     {
                    //         depth += 5; //注意递增值
                    //         canvas.sortingOrder = depth;
                    //     }
                    // }
                }
            }
        }

        #region 管理器内部调用

        internal UIHolderObjectBase Holder;
        internal abstract Type UIHolderType { get; }

        internal void InternalInitlized()
        {
            _state = UIState.Initialized;
            OnInitlize();
        }

        internal void InternalOpen()
        {
            _state = UIState.Opened;
            Visible = true;
            OnOpen();
        }

        internal void InternalClose()
        {
            if (_state == UIState.Opened)
                OnClose();
            _state = UIState.Closed;
            Visible = false;
        }

        internal void InternalUpdate()
        {
            if (_state != UIState.Opened) return;
            OnUpdate();
            UpdateChildren();
        }

        internal void InternalDestroy()
        {
            DestroyAllChildren();
            OnDestroy();
            Dispose();
            _state = UIState.Destroyed;
        }

        internal void RefreshParams(params System.Object[] userDatas)
        {
            this._userDatas = userDatas;
        }

        #endregion
    }
}