using Island.StandardLib.Reflection.Exception;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Island.StandardLib.Reflection
{
    public class DynamicManager
    {
        List<string> namespaces;
        List<Assembly> assemblies;
        Dictionary<string, DynamicType> cachedTypes;

        public DynamicManager()
        {
            namespaces = new List<string>();
            assemblies = new List<Assembly>();
            cachedTypes = new Dictionary<string, DynamicType>();
            namespaces.Add("");
        }

        public void LoadCurrentDomainEnvironment()
        {
            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
                AddAssembly(assembly);
        }

        public void AddNamespace(string @namespace)
        {
            if (!namespaces.Contains(@namespace + "."))
                namespaces.Add(@namespace + ".");
        }

        public void AddAssembly(Assembly assembly)
        {
            if (!assemblies.Contains(assembly))
                assemblies.Add(assembly);
        }

        public DynamicClassInstance<T>[] ScanAssembly<T>(Assembly assembly, params object[] initargs) where T : class
        {
            AddAssembly(assembly);
            Type[] types = assembly.GetTypes();
            types = (from type in types
                     where type.IsSubclassOf(typeof(T))
                     select type).ToArray();
            return types.Do(t => new DynamicClassInstance<T>(this, GetDynamicType(t), initargs));
        }

        public DynamicType GetDynamicType(Type existType)
        {
            if (cachedTypes.TryGetValue(existType.FullName, out DynamicType result)) return result;
            DynamicType dtype = new DynamicType(existType);
            cachedTypes.Add(existType.FullName, dtype);
            return dtype;
        }

        public DynamicType GetDynamicType(string className)
        {
            foreach (string @namespace in namespaces)
            {
                string trying = @namespace + className;
                if (cachedTypes.TryGetValue(trying, out DynamicType type)) return type;
            }
            for (int i = 0; i < assemblies.Count; i++)
            {
                for (int j = 0; j < namespaces.Count; j++)
                {
                    string lpfullname = namespaces[j] + className;
                    Type typed = assemblies[i].GetType(lpfullname, false);
                    if (typed != null)
                    {
                        DynamicType dtype = new DynamicType(typed);
                        cachedTypes.Add(lpfullname, dtype);
                        return dtype;
                    }
                }
            }
            throw new ClassNotFoundException(className);
        }

        public DynamicClassInstance CreateClassInstance(string className, params object[] initargs)
        {
            return new DynamicClassInstance(this, GetDynamicType(className), initargs);
        }
    }
}