#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEAWCS_QuartzJob
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：调度服务实现类
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>

using Quartz.Impl.Triggers;
using Quartz.Impl;
using Quartz.Spi;
using Quartz;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.CustomException;

namespace WIDESEAWCS_QuartzJob
{
    public class SchedulerCenterServer : ISchedulerCenter
    {
        private Task<IScheduler> _scheduler;
        private readonly IJobFactory _iocjobFactory;
        public SchedulerCenterServer(IJobFactory jobFactory)
        {
            _iocjobFactory = jobFactory;
            _scheduler = GetSchedulerAsync();
        }
        private Task<IScheduler> GetSchedulerAsync()
        {
            if (_scheduler != null)
                return this._scheduler;
            else
            {
                try
                {
                    // 从Factory中获取Scheduler实例
                    NameValueCollection collection = new NameValueCollection
                    {
                        { "quartz.serializer.type", "binary" },
                    };
                    StdSchedulerFactory factory = new StdSchedulerFactory(collection);
                    return _scheduler = factory.GetScheduler();
                }
                catch (Exception ex)
                {
                    throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.JobFactoryInstanceException, ex.Message), innerException: ex);
                }

            }
        }

        /// <summary>
        /// 开启任务调度
        /// </summary>
        /// <returns></returns>
        public async Task<WebResponseContent> StartScheduleAsync()
        {
            WebResponseContent result = new WebResponseContent();
            try
            {
                this._scheduler.Result.JobFactory = this._iocjobFactory;
                if (!this._scheduler.Result.IsStarted)
                {
                    //等待任务运行完成
                    await this._scheduler.Result.Start();
                    await Console.Out.WriteLineAsync(QuartzJobInfoMessage.StartJobSuccess);
                    result = WebResponseContent.Instance.OK(QuartzJobInfoMessage.StartJobSuccess);
                    return result;
                }
                else
                {
                    result = WebResponseContent.Instance.Error(QuartzJobInfoMessage.JobHasStart);
                    return result;
                }
            }
            catch (Exception ex)
            {
                throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.StartJobException, ex.Message), innerException: ex);
            }
        }

        /// <summary>
        /// 停止任务调度
        /// </summary>
        /// <returns></returns>
        public async Task<WebResponseContent> StopScheduleAsync()
        {
            WebResponseContent result = new WebResponseContent();
            try
            {
                if (!this._scheduler.Result.IsShutdown)
                {
                    //等待任务运行完成
                    await this._scheduler.Result.Shutdown();
                    await Console.Out.WriteLineAsync(QuartzJobInfoMessage.StopJobSuccess);
                    result = WebResponseContent.Instance.OK(QuartzJobInfoMessage.StopJobSuccess);
                    return result;
                }
                else
                {
                    result = WebResponseContent.Instance.Error(QuartzJobInfoMessage.JobHasStop);
                    return result;
                }
            }
            catch (Exception ex)
            {
                throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.StopJobException, ex.Message), innerException: ex);
            }
        }

        /// <summary>
        /// 添加一个计划任务（映射程序集指定IJob实现类）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tasksQz"></param>
        /// <returns></returns>
        public async Task<WebResponseContent> AddScheduleJobAsync(DispatchInfoDTO tasksQz)
        {
            WebResponseContent result = new WebResponseContent();

            if (tasksQz != null)
            {
                try
                {
                    JobKey jobKey = new JobKey(tasksQz.Id.ToString(), tasksQz.JobGroup);
                    if (await _scheduler.Result.CheckExists(jobKey))
                    {
                        result = WebResponseContent.Instance.Error(string.Format(QuartzJobInfoMessage.JobHasAdd, tasksQz.Name));
                        return result;
                    }
                    #region 设置开始时间和结束时间

                    if (tasksQz.BeginTime == null)
                    {
                        tasksQz.BeginTime = DateTime.Now;
                    }
                    DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(tasksQz.BeginTime, 1);//设置开始时间
                    if (tasksQz.EndTime == null)
                    {
                        tasksQz.EndTime = DateTime.MaxValue.AddDays(-1);
                    }
                    DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(tasksQz.EndTime, 1);//设置暂停时间

                    #endregion

                    #region 通过反射获取程序集类型和类   

                    var basePath = AppContext.BaseDirectory;
                    var dllFile = Path.Combine(basePath, $"{tasksQz.AssemblyName}.dll");

                    if (!File.Exists(dllFile))
                    {
                        var msg = $"{tasksQz.AssemblyName}.dll未找到，请检查数据或文件";
                        //log.Error(msg);
                        throw new Exception(msg);
                    }

                    Assembly assembly = Assembly.Load(new AssemblyName(tasksQz.AssemblyName));
                    Type jobType = assembly.GetType(tasksQz.AssemblyName + "." + tasksQz.ClassName);

                    #endregion

                    //传入反射出来的执行程序集
                    //IJobDetail jobDetail = JobBuilder.Create(jobType)
                    //   .WithIdentity(tasksQz.Id.ToString(), tasksQz.JobGroup)
                    //   .Build();
                    //jobDetail.JobDataMap.Add("JobParams", tasksQz.JobParams);

                    IJobDetail job = new JobDetailImpl(tasksQz.Id.ToString(), tasksQz.JobGroup, jobType);
                    job.JobDataMap.Add("JobParams", tasksQz.JobParams);

                    ITrigger trigger = CreateSimpleTrigger(tasksQz);

                    // 告诉Quartz使用我们的触发器来安排作业
                    await _scheduler.Result.ScheduleJob(job, trigger);
                    //await _scheduler.Result.ScheduleJob(jobDetail, trigger);

                    result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.JobAddSuccess, tasksQz.Name));
                    return result;
                }
                catch (Exception ex)
                {
                    throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.AddJobException, tasksQz.Name, ex.Message), innerException: ex);
                }
            }
            else
            {
                result = WebResponseContent.Instance.Error(string.Format(QuartzJobInfoMessage.JobNotExist, tasksQz?.Name));
                return result;
            }
        }

        /// <summary>
        /// 任务是否存在?
        /// </summary>
        /// <returns></returns>
        public async Task<bool> IsExistScheduleJobAsync(DispatchInfoDTO sysSchedule)
        {
            JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
            if (await _scheduler.Result.CheckExists(jobKey))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 停止一个指定的计划任务
        /// </summary>
        /// <returns></returns>
        public async Task<WebResponseContent> StopScheduleJobAsync(DispatchInfoDTO sysSchedule)
        {
            WebResponseContent result = new WebResponseContent();
            try
            {
                JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    result = WebResponseContent.Instance.Error(string.Format(QuartzJobInfoMessage.JobNotExist, sysSchedule.Name));
                    return result;
                }
                else
                {
                    await this._scheduler.Result.DeleteJob(jobKey);
                    result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.StopAJobSuccess, sysSchedule.Name));
                    return result;
                }
            }
            catch (Exception ex)
            {
                throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.StopAJobException, sysSchedule.Name, ex.Message), innerException: ex);
            }
        }

        /// <summary>
        /// 恢复指定的计划任务
        /// </summary>
        /// <param name="sysSchedule"></param>
        /// <returns></returns>
        public async Task<WebResponseContent> ResumeJob(DispatchInfoDTO sysSchedule)
        {
            WebResponseContent result = new WebResponseContent();
            try
            {
                JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    result = WebResponseContent.Instance.Error(string.Format(QuartzJobInfoMessage.ResumeJobNotExist, sysSchedule.Name));
                    return result;
                }
                await this._scheduler.Result.ResumeJob(jobKey);
                result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.ResumeJobSuccess, sysSchedule.Name));
                return result;
            }
            catch (Exception ex)
            {
                throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.ResumeJobException, sysSchedule.Name, ex.Message), innerException: ex);
            }
        }

        /// <summary>
        /// 暂停指定的计划任务
        /// </summary>
        /// <param name="sysSchedule"></param>
        /// <returns></returns>
        public async Task<WebResponseContent> PauseJob(DispatchInfoDTO sysSchedule)
        {
            WebResponseContent result = new WebResponseContent();
            try
            {
                JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    result = WebResponseContent.Instance.Error(string.Format(QuartzJobInfoMessage.PauseJobNotExist, sysSchedule.Name));
                    return result;
                }
                await this._scheduler.Result.PauseJob(jobKey);
                result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.PauseJobSuccess, sysSchedule.Name));
                return result;
            }
            catch (Exception)
            {
                throw;
            }
        }

        #region 状态状态帮助方法
        //public async Task<List<DispatchInfoDTO>> GetTaskStaus(DispatchInfoDTO sysSchedule)
        //{

        //    var ls = new List<TaskInfoDto>();
        //    var noTask = new List<TaskInfoDto>{ new TaskInfoDto {
        //        jobId = sysSchedule.Id.ObjToString(),
        //        jobGroup = sysSchedule.JobGroup,
        //        triggerId = "",
        //        triggerGroup = "",
        //        triggerStatus = "不存在"
        //    } };
        //    JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
        //    IJobDetail job = await this._scheduler.Result.GetJobDetail(jobKey);
        //    if (job == null)
        //    {
        //        return noTask;
        //    }
        //    //info.Append(string.Format("任务ID:{0}\r\n任务名称:{1}\r\n", job.Key.Name, job.Description)); 
        //    var triggers = await this._scheduler.Result.GetTriggersOfJob(jobKey);
        //    if (triggers == null || triggers.Count == 0)
        //    {
        //        return noTask;
        //    }
        //    foreach (var trigger in triggers)
        //    {
        //        var triggerStaus = await this._scheduler.Result.GetTriggerState(trigger.Key);
        //        string state = GetTriggerState(triggerStaus.ObjToString());
        //        ls.Add(new TaskInfoDto
        //        {
        //            jobId = job.Key.Name,
        //            jobGroup = job.Key.Group,
        //            triggerId = trigger.Key.Name,
        //            triggerGroup = trigger.Key.Group,
        //            triggerStatus = state
        //        });
        //        //info.Append(string.Format("触发器ID:{0}\r\n触发器名称:{1}\r\n状态:{2}\r\n", item.Key.Name, item.Description, state));

        //    }
        //    return ls;
        //}
        public string GetTriggerState(string key)
        {
            string state = null;
            if (key != null)
                key = key.ToUpper();
            switch (key)
            {
                case "1":
                    state = "暂停";
                    break;
                case "2":
                    state = "完成";
                    break;
                case "3":
                    state = "出错";
                    break;
                case "4":
                    state = "阻塞";
                    break;
                case "0":
                    state = "正常";
                    break;
                case "-1":
                    state = "不存在";
                    break;
                case "BLOCKED":
                    state = "阻塞";
                    break;
                case "COMPLETE":
                    state = "完成";
                    break;
                case "ERROR":
                    state = "出错";
                    break;
                case "NONE":
                    state = "不存在";
                    break;
                case "NORMAL":
                    state = "正常";
                    break;
                case "PAUSED":
                    state = "暂停";
                    break;
            }
            return state;
        }
        #endregion

        #region 创建触发器帮助方法

        /// <summary>
        /// 创建SimpleTrigger触发器（简单触发器）
        /// </summary>
        /// <param name="sysSchedule"></param>
        /// <returns></returns>
        private ITrigger CreateSimpleTrigger(DispatchInfoDTO sysSchedule)
        {
            ITrigger trigger = TriggerBuilder.Create()
            .WithIdentity(sysSchedule.Id.ToString(), sysSchedule.JobGroup)
            .StartAt(sysSchedule.BeginTime.GetValueOrDefault())
            .WithSimpleSchedule(x => x
                .WithIntervalInSeconds(sysSchedule.IntervalSecond)
                .RepeatForever()
            )
            .EndAt(sysSchedule.EndTime.GetValueOrDefault())
            .Build();
            return trigger;
        }
        #endregion

        /// <summary>
        /// 立即执行 一个任务 执行一次
        /// </summary>
        /// <param name="tasksQz"></param>
        /// <returns></returns>
        public async Task<WebResponseContent> ExecuteJobAsync(DispatchInfoDTO tasksQz)
        {
            var result = new WebResponseContent();
            try
            {
                JobKey jobKey = new JobKey(tasksQz.Id.ToString(), tasksQz.JobGroup);

                //判断任务是否存在，存在则 触发一次，不存在则先添加一个任务，触发以后再 停止任务
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    //不存在 则 添加一个计划任务
                    await AddScheduleJobAsync(tasksQz);

                    //触发执行一次
                    await _scheduler.Result.TriggerJob(jobKey);

                    //停止任务
                    await StopScheduleJobAsync(tasksQz);

                    result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.ExecuteJobSuccess, tasksQz.Name));
                }
                else
                {
                    await _scheduler.Result.TriggerJob(jobKey);
                    result = WebResponseContent.Instance.OK(string.Format(QuartzJobInfoMessage.ExecuteJobSuccess, tasksQz.Name));
                }
            }
            catch (Exception ex)
            {
                throw new QuartzJobException(string.Format(QuartzJobExceptionMessage.ResumeJobException, tasksQz.Name, ex.Message), innerException: ex);
            }

            return result;
        }
    }
}