using JY.DAL.Repository;
using JY.DAL.Service;
using System;
using System.Collections.Generic;
using System.Reflection;

namespace JY.DAL
{
    public static class ServiceLocator
    {
        private static readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();
        private static readonly Dictionary<Type, Func<object>> _serviceFactories = new Dictionary<Type, Func<object>>();
        private static bool _isInitialized = false;

        public static void Initialize()
        {
            if (_isInitialized) return;

            RegisterRepositoryAndService();

            _isInitialized = true;
        }

        private static void RegisterRepositoryAndService()
        {
            var assembly = Assembly.GetExecutingAssembly();

            foreach (var type in assembly.GetTypes())
            {
                if (type.IsClass && !type.IsAbstract)
                {
                    foreach (var iface in type.GetInterfaces())
                    {
                        if (iface.IsGenericType)
                        {
                            var genericDef = iface.GetGenericTypeDefinition();
                            if (genericDef == typeof(IRepository<>))
                            {
                                _serviceFactories[iface] = () => Activator.CreateInstance(type);
                            }
                            else if (genericDef == typeof(IService<>))
                            {
                                _serviceFactories[iface] = () =>
                                {
                                    var repoType = typeof(IRepository<>).MakeGenericType(type.GetGenericArguments()[0]);
                                    var repo = Get(repoType);
                                    return Activator.CreateInstance(type, repo);
                                };
                            }
                        }
                        else
                        {
                            if (!iface.FullName.StartsWith("System."))
                            {
                                _serviceFactories[iface] = () => CreateInstanceWithDependencies(type);
                            }
                        }
                    }
                }
            }
        }

        private static object CreateInstanceWithDependencies(Type type)
        {
            var constructor = type.GetConstructors()[0];
            var parameters = constructor.GetParameters();
            var paramValues = new object[parameters.Length];

            for (int i = 0; i < parameters.Length; i++)
            {
                paramValues[i] = Get(parameters[i].ParameterType);
            }

            return Activator.CreateInstance(type, paramValues);
        }

        public static void Register<T>(T instance)
        {
            _services[typeof(T)] = instance;
        }

        public static void Register<T>(Func<T> factory)
        {
            _serviceFactories[typeof(T)] = () => factory();
        }

        public static T Get<T>()
        {
            return (T)Get(typeof(T));
        }

        public static object Get(Type serviceType)
        {
            if (_services.TryGetValue(serviceType, out object instance))
            {
                return instance;
            }

            if (_serviceFactories.TryGetValue(serviceType, out Func<object> factory))
            {
                instance = factory();
                _services[serviceType] = instance;
                return instance;
            }

            throw new InvalidOperationException($"服务 {serviceType.Name} 未注册");
        }
    }
}