using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Reflection;
using System.Linq;

namespace YKMoon
{
    public static class YKReflectionUtility
    {
        public static Assembly GetAssembly(string assemblyName)
        {
            return AppDomain.CurrentDomain.GetAssemblies().SingleOrDefault(assembly => assembly.GetName().Name == assemblyName);
        }
        public static System.Type GetManagedReferenceFieldType(string managedReferenceFieldTypename)
        {
            var managedReferenceFieldTypenameSplit = managedReferenceFieldTypename.Split(' ').ToArray();
            var assemblyName = managedReferenceFieldTypenameSplit[0];
            var fieldTypeName = managedReferenceFieldTypenameSplit[1];
            var fieldType = GetAssembly(assemblyName).GetType(fieldTypeName);
            return fieldType;
        }
        public static List<System.Type> GetSubclassTypes(System.Type targetSuperType)
        {
            List<System.Type> result = new List<System.Type>();
            foreach(var type in targetSuperType.Assembly.GetTypes()) {
                if(!type.IsAbstract && IsBaseTypeContains(type, targetSuperType)) {
                    result.Add(type);
                }
            }
            return result;
        }
        public static List<System.Type> GetSubclassTypes<T>()
        {
            return GetSubclassTypes(typeof(T));
        }
        public static bool IsBaseTypeContains(System.Type type, System.Type targetSuperType)
        {
            if(type.BaseType == null) {
                return false;
            }
            if(type.BaseType == targetSuperType) {
                return true;
            }
            return IsBaseTypeContains(type.BaseType, targetSuperType);
        }
        private static List<System.Type> GetClassesByInterface<T>()
        {
            List<System.Type> result = new List<System.Type>();
            var types = Assembly.GetExecutingAssembly().GetTypes();
            foreach(var type in types) {
                if(type.IsAbstract || type.IsInterface) {
                    continue;
                }
                if(type.IsAssignableFrom(typeof(T))) {
                    result.Add(type);
                }
            }
            return result;
        }
    }
}