using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Server
{
    /// <summary>
    /// 服务任务
    /// </summary>
    [DisallowConcurrentExecution]//此特性标识 必须等待这次任务执行完成后，才能执行下次任务
    internal class DataDockingServiceJob : IJob 
    {
        private static List<DataDockingSingleJobHelper> _jobHelpers = new List<DataDockingSingleJobHelper>();
        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(async () =>
            {
                try
                {
                    //客户标识列表
                    var corpIds = CorpHelper.GetDataDockingCorpIds();
                    if (corpIds == null || corpIds.Count < 1)
                    {
                        LogHelper.Info($"数据对接问题任务管理器中,未检索到需要对接的客户标识信息！");
                        CancelJobs();
                        return;
                    }

                    //数据对接问题列表
                    var serviceProblem = new Service.DataDockingProblem();
                    var problemList = serviceProblem.GetByCorpIds(corpIds);
                    if (problemList == null || problemList.Count < 1)
                    {
                        LogHelper.Info($"数据对接问题任务管理器中,未检索到数据对接问题配置！");
                        CancelJobs();
                        return;
                    }
                    problemList = problemList.Where(x => x.UseStatus == Model.eUseStatus.Enable).ToList();
                    if (problemList == null || problemList.Count < 1)
                    {
                        LogHelper.Info($"数据对接问题任务管理器中,未检索到有效的数据对接问题配置！");
                        CancelJobs();
                        return;
                    }

                    //循环开启任务
                    foreach (var problem in problemList)
                    {
                        var jobHelper = _jobHelpers.Find(t => t.Problem.ID == problem.ID
                                                                                    && t.Problem.UpdateTime == problem.UpdateTime);
                        if (jobHelper == null)
                        {
                            jobHelper = new DataDockingSingleJobHelper();
                            await jobHelper.StartJob(problem);
                            _jobHelpers.Add(jobHelper);
                            LogHelper.Info($"问题配置名称：{problem.Name}，数据对接问题任务开启！");
                        }
                    }

                    //循环关闭任务
                    foreach (var jobHelper in _jobHelpers.ToList())
                    {
                        var configure = problemList.Find(t => t.ID == jobHelper.Problem.ID
                                                                                          && t.UpdateTime == jobHelper.Problem.UpdateTime);
                        if (configure == null)
                        {
                            await jobHelper.CancelJob();
                            _jobHelpers.Remove(jobHelper);
                            LogHelper.Info($"问题配置名称：{jobHelper.Problem.Name}，数据对接问题任务关闭！");
                        }
                    }
                    LogHelper.Info($"数据对接问题任务，开启数量为{_jobHelpers.Count}！");
                }
                catch (Exception ex)
                {
                    LogHelper.Error("数据对接问题任务管理器中，任务执行出错！", ex);
                    var e = new JobExecutionException(ex);
                    throw e;
                }
            });
        }

        public static void CancelJobs()
        {
            if (_jobHelpers != null && _jobHelpers.Count > 0)
            {
                _jobHelpers.ForEach(async x => await x.CancelJob());
                _jobHelpers.Clear();
            }
        }

    }
}