using Autofac;
using System.Collections.Generic;
using System.Reflection;
using WcsMain.Business.Convey.HistoryDataHandler.HisGetData.I;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.Tcp.Entity.Convey;
using WcsMain.WcsAttribute.AutoFacAttribute;

namespace WcsMain.Business.Convey.HistoryDataHandler;


/// <summary>
/// 传统版本的箱式线数据处理
/// </summary>
/// <param name="routerMethodDao"></param>
[Component]
public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, IComponentContext componentContext)
{
    private Dictionary<string, IBaseGetData?>? _methodConfig;
    private Dictionary<string, AppRouterMethod?>? _areaBaseData;

    /// <summary>
    /// 处理 PLC 请求分拣路向逻辑
    /// </summary>
    /// <param name="displayName"></param>
    /// <param name="msg"></param>
    /// <param name="area"></param>
    public void GetData(string? displayName, string msg, string area)
    {
        LoadingMethodConfig(); // 加载配置信息，仅第一次加载
        if (_methodConfig == null || _areaBaseData == null)
        {
            ConsoleLog.Warning("路由处理参数尚未加载，可能是和数据库服务连接存在异常");
            return;
        }
        var getInstance = _methodConfig.TryGetValue(area ?? "", out var instance);
        if (!getInstance || instance == null)
        {
            ConsoleLog.Warning($"点位：{area} 未配置处理逻辑或者处理逻辑不可用");
            return;
        }
        var areaInfo = _areaBaseData.TryGetValue(area ?? "", out AppRouterMethod? routerMethodData);
        if(!areaInfo || routerMethodData == null)
        {
            ConsoleLog.Warning($"点位：{area} 无可用配置信息");
            return;
        }
        if (msg == "NoRead")
        {
            instance.ReadFail(displayName, msg, area, routerMethodData);
        }
        else
        {
            instance.ReadSuccess(displayName, msg, area, routerMethodData);
        }
    }

    /*************************/

    private static readonly object LoadLock = new();
    /// <summary>
    /// 加载获取路由的参数
    /// </summary>
    private void LoadingMethodConfig()
    {
        lock (LoadLock)
        {
            if (_methodConfig != null && _areaBaseData != null) return;
            List<AppRouterMethod>? appRouters = routerMethodDao.Query();
            if (appRouters == null) return;
            _methodConfig = [];
            _areaBaseData = [];
            // 扫描创建继承 BaseGetRouter 的类的实例
            Dictionary<string, IBaseGetData> classInstances = [];
            var assembly = Assembly.GetExecutingAssembly();
            var assTypes = assembly.GetTypes();
            foreach (var assType in assTypes)
            {
                var interfaces = assType.GetInterfaces();
                foreach (var inteface in interfaces)
                {
                    if (inteface != typeof(IBaseGetData)) continue;
                    var instance = CreateInstance(assType);
                    if (instance == null) continue;
                    classInstances.Add(assType.Name, (IBaseGetData)instance);
                }
            }
            // 将实例和请求点位绑定
            foreach (var appRouter in appRouters)
            {
                if (string.IsNullOrEmpty(appRouter.ClassName)) continue;
                var isGetInstance = classInstances.TryGetValue(appRouter.ClassName, out var inst);
                if (!isGetInstance) continue;
                _methodConfig.TryAdd(appRouter.Area ?? "", inst);
                _areaBaseData.TryAdd(appRouter.Area ?? "", appRouter);
            }
        }
    }


    /// <summary>
    /// 创建实例。自动注入参数
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private object? CreateInstance(Type type)
    {
        var constructors = type.GetConstructors();
        var constructorList = constructors.ToList();
        constructorList = [.. constructorList.OrderByDescending(s => s.GetParameters().Length)];
        foreach (var constructor in constructorList)
        {
            var parameters = constructor.GetParameters();
            if (parameters.Length == 0) return Activator.CreateInstance(type);
            List<object> arguments = [];
            foreach (var parameter in parameters)
            {
                object par = componentContext.Resolve(parameter.ParameterType);
                arguments.Add(par);
            }
            return Activator.CreateInstance(type, [.. arguments]);
        }
        return Activator.CreateInstance(type);
    }


}