using System.Reflection;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;

namespace WIDESEAWCS_QuartzJob.QuartzNet
{
    /// <summary>
    /// 启动程序自动开启调度服务
    /// </summary>
    public class QuartzNetExtension
    {
        private readonly ISchedulerCenter _schedulerCenter;
        private readonly IDeviceInfoService _deviceInfoService;
        private readonly IDispatchInfoService _dispatchInfoService;
        private readonly IDeviceProtocolDetailService _deviceProtocolDetailService;
        private readonly Storage _storage;

        /// <summary>
        /// 启动程序自动开启调度服务
        /// </summary>
        /// <returns></returns>
        public QuartzNetExtension(IDeviceInfoService deviceInfoService, IDispatchInfoService dispatchInfoService, ISchedulerCenter schedulerCenter, IDeviceProtocolDetailService deviceProtocolDetailService, Storage storage)
        {
            _deviceInfoService = deviceInfoService;
            _dispatchInfoService = dispatchInfoService;
            _schedulerCenter = schedulerCenter;
            _deviceProtocolDetailService = deviceProtocolDetailService;
            _storage = storage;
        }

        /// <summary>
        /// 启动程序自动开启调度服务
        /// </summary>
        /// <returns></returns>
        public virtual async Task StartAsync()
        {
            try
            {
                List<DispatchInfoDTO> dispatches = _dispatchInfoService.QueryDispatchInfos();
                List<DeviceInfoDTO> deviceInfos = await _deviceInfoService.QueryDeviceProInfos();

                deviceInfos.ForEach(delegate (DeviceInfoDTO x)
                {
                    DeviceInfoDTO x2 = x;
                    if (!Storage.Devices.Exists((IDevice d) => d.DeviceCode == x2.DeviceCode) && !x.DeviceName.Contains("堆垛机"))
                    {
                        try
                        {
                            Type type = Assembly.Load("WIDESEAWCS_Communicator").GetType("WIDESEAWCS_Communicator." + x2.DevicePlcType);
                            object obj = Activator.CreateInstance(type, x2.DeviceIp, x2.DevicePort, x2.DeviceName);
                            if (new bool?((bool)type.InvokeMember("Connect", BindingFlags.InvokeMethod, null, obj, new object[0])).GetValueOrDefault())
                            {
                                (type.Name + x2.DeviceCode + "连接成功").WriteSuccessLine();
                            }
                            else
                            {
                                (type.Name + x2.DeviceCode + "连接失败").WriteErrorLine();
                            }

                            List<DeviceProDTO> list = x2.ProtocolList.Select((Dt_DeviceProtocol d) => new DeviceProDTO
                            {
                                DeviceChildCode = d.DeviceChildCode,
                                DeviceDataType = d.DeviceProDataType,
                                DeviceId = d.DeviceId,
                                DeviceProId = d.Id,
                                DeviceProDataBlock = d.DeviceProDataBlock,
                                DeviceProDataLength = d.DeviceProDataLength,
                                DeviceProOffset = d.DeviceProOffset,
                                DeviceProParamDes = d.DeviceProParamDes,
                                DeviceProParamName = d.DeviceProParamName,
                                DeviceProParamType = d.DeviceProParamType,
                                DevicePlcType = x2.DevicePlcType
                            }).ToList();
                            List<DeviceProtocolDetailDTO> deviceProtocolDetailsByDeviceType = _deviceProtocolDetailService.GetDeviceProtocolDetailsByDeviceType(x2.DeviceType);
                            object obj2 = Activator.CreateInstance(Assembly.Load("WIDESEAWCS_QuartzJob").GetType("WIDESEAWCS_QuartzJob." + x2.DeviceType), obj, list, deviceProtocolDetailsByDeviceType, x2.DeviceCode, x2.DeviceName);
                            x2.Device = (IDevice)obj2;
                            Storage.Devices.Add((IDevice)obj2);
                        }
                        catch (Exception ex2)
                        {
                            Console.WriteLine("调度服务开启异常" + ex2.ToString());
                        }
                    }
                    else
                    {
                        x2.Device = Storage.Devices.FirstOrDefault((IDevice d) => d.DeviceCode == x2.DeviceCode);
                    }
                });
                for (int i = 0; i < dispatches.Count; i++)
                {
                    var targetDevice = deviceInfos.FirstOrDefault(x => x.Id == dispatches[i].Id);

                    // 使用模式匹配
                    dispatches[i].JobParams = targetDevice switch
                    {
                        { DeviceName: var name } when name.Contains("堆垛机")
                            => new StackerCraneDevice { DeviceCode = targetDevice.DeviceCode, DeviceName = targetDevice.DeviceName, IPAddress = targetDevice.DeviceIp + ":" + targetDevice.DevicePort },
                        _ => targetDevice.Device
                    };
                    WebResponseContent responseContent = await _schedulerCenter.AddScheduleJobAsync(dispatches[i]);
                    if (responseContent.Status) ConsoleHelper.WriteSuccessLine(dispatches[i].Name + "调度服务添加成功"); else ConsoleHelper.WriteErrorLine(dispatches[i].Name + "调度服务添加失败");
                }
                //await _schedulerCenter.StartScheduleAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine("调度服务开启异常" + ex.ToString());
                throw;
            }
        }
    }
}