using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UIElements;
using System.Reflection;
using UnityEngine.AddressableAssets;
#if UNITY_EDITOR
using System;
using UnityEditor;
using Editor = UnityEditor.Editor;
using UnityEditor.UIElements;
#else
using Editor=BITKit.Constant.EmetyClass;
#endif
namespace BITKit
{
    public class BITAttribute : System.Attribute
    {

    }
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true, Inherited = true)]
    public class CustomTypeAttribute : System.Attribute
    {
        public readonly Type Type;
        public CustomTypeAttribute(Type type)
        {
            
            Type = type;
        }
    }
    public class BITEditorUtils
    {
        public const string InspectorPath = "Assets/BITKit/Unity/UX/BITInspector.uss";
        public const string StylePath = "Assets/BITKit/Unity/UX/Common/Common.uss";
        #if UNITY_EDITOR
        public static StyleSheet Style => AssetDatabase.LoadAssetAtPath<StyleSheet>(StylePath);
        public static StyleSheet InspectorStyleSheet => AssetDatabase.LoadAssetAtPath<StyleSheet>(InspectorPath);
        #endif
    }
    public class ServerRpcAttribute : System.Attribute
    {

    }
    public class ClientRpcAttribute : System.Attribute
    {

    }
    
#if UNITY_EDITOR
    public static class BITInspectorExtensions
    {
        public static T Get<T>(this SerializedProperty self)
        {
            var obj = self.serializedObject.targetObject;
            var type = obj.GetType();
            var field = type.GetField(self.propertyPath);
            return (T)field.GetValue(obj);
        }
    }
    public class BITInspector<T> : Editor
    {
        const string ussName = "BITInspector";
        public class VisualElementCreator
        {
            public static implicit operator VisualElement(VisualElementCreator self)
            {
                return self.root;
            }
            public VisualElement root;
            public VE Create<VE>() where VE : VisualElement, new()
            {
                root = root ?? new();
                var ve = new VE();
                root.Add(ve);
                return ve;
            }
        }
        protected VisualElementCreator root = new();
        protected T agent;
        public override VisualElement CreateInspectorGUI()
        {
            if (serializedObject.targetObject is ICustomInspector inspector && inspector.GetVisualElement() is not null)
            {
                return inspector.GetVisualElement();
            }
            else
            {
                FillDefaultInspector();
                return root;
            }
        }
        protected Label CreateSubTitle(string value)
        {
            var label = root.Create<Label>();
            label.text = value;
            label.AddToClassList("subTitle");
            return label;
        }
         void Awake()
        {
            root.root = new();

            if (serializedObject.targetObject is T value)
            {
                agent = value;
            }
        }
        protected virtual void OnAwake(){}
        void OnEnable()
        {
            //StyleSheet css = Addressables.LoadAssetAsync<StyleSheet>(ussName).WaitForCompletion();
            StyleSheet css = AssetDatabase.LoadAssetAtPath<StyleSheet>(BITEditorUtils.InspectorPath);
            
            root.root.styleSheets.Add(css);

            EditorApplication.update += OnUpdate;
        }
        protected virtual void OnEnabled(){}
        void OnDisable()
        {
            EditorApplication.update -= OnUpdate;
        }
        protected virtual void OnDisabled(){}
        protected virtual void OnUpdate()
        {

        }
        protected void FillDefaultInspector()
        {
            FillDefaultInspector(root, serializedObject, true);
        }

        protected static void FillDefaultInspector(VisualElement container, SerializedObject serializedObject, bool hideScript)
        {
            var property = serializedObject.GetIterator();
            if (!property.NextVisible(true)) return; // Expand first child.
            do
            {
                if (property.propertyPath == "m_Script" && hideScript)
                {
                    continue;
                }
                var type = serializedObject.targetObject.GetType().GetField(property.name);
                if ( type is not null && Attribute.IsDefined(type.FieldType, typeof(ReadOnlyAttribute)))
                {
                    container.Create<Label>().bindingPath = property.propertyPath;
                }
                else
                {
                    var field = new PropertyField(property)
                    {
                        name = "PropertyField:" + property.propertyPath
                    };
                    if (property.propertyPath == "m_Script" && serializedObject.targetObject != null)
                    {
                        field.SetEnabled(false);
                    }
                    container.Add(field);
                }
                // try
                // {
                //     var header = type?.GetCustomAttribute<HeaderAttribute>();
                //     if (header != null)
                //     {
                //         var label = new Label(header.header);
                //         label.AddToClassList("subTitle");
                //         container.Add(label);
                //     }
                // }
                // catch (System.Exception e)
                // {
                //     Debug.LogException(e);
                // }


              
            }
            while (property.NextVisible(false));

            foreach (var method in serializedObject.targetObject.GetType().GetMethods())
            {
                if (method.GetCustomAttribute<BITAttribute>() is null) continue;
                if (method.GetParameters().Length is not 0) continue;
                var button = new Button(() => method.Invoke(serializedObject.targetObject, null))
                {
                    text = method.Name
                };

                container.Add(button);
            }
        }
    }
    public class BITProperty : PropertyDrawer
    {
        public override VisualElement CreatePropertyGUI(SerializedProperty property)
        {
            PropertyField propertyField = new(property);
            return propertyField;
        }
    }
#endif
}