using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Drawing.Printing;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using FineUIPro;
using Quartz;
using Quartz.Impl;

namespace BLL
{
    public class QuartzServices
    {

        public static async Task Init()
        {
            ErrLogInfo.WriteLog("定时任务Init！");

            //初始化计划者
            StdSchedulerFactory factory = new StdSchedulerFactory();
            IScheduler scheduler = await factory.GetScheduler();
            var jobAndTriggerMapping = new Dictionary<IJobDetail, IReadOnlyCollection<ITrigger>>();
            // 将映射关系包装成制度字典集合  
            var model = new Model.InterFaceTask();
            model.Enable = true;
            var list = InterFaceTaskService.GetInterFaceTaskByModle(model);
            if (list == null || list.Count == 0)
            {
                ErrLogInfo.WriteLog("未找到任何启用的定时任务");
                return;
            }
            foreach (var item in list)
            {
                try
                {
                    var jobDetail1 = GetJobDetailByInterFaceTaskId(item.InterFaceTaskId);
                    if (!CronExpression.IsValidExpression(item.Frequency))
                    {
                        ErrLogInfo.WriteLog($"任务ID {item.InterFaceTaskId} 的Cron表达式无效: {item.Frequency}");
                        continue;
                    }
                    var trigger1 = GetTriggerByTime(item.InterFaceTaskId, item.Frequency);
                    //给计划者添加Job和触发器
                    jobAndTriggerMapping[jobDetail1] = trigger1;
                }
                catch (Exception ex)
                {
                    ErrLogInfo.WriteLog($"处理任务ID {item.InterFaceTaskId} 时发生异常", ex);
                    jobAndTriggerMapping.Remove(GetJobDetailByInterFaceTaskId(item.InterFaceTaskId));
                    continue;
                }
            }
            var readOnlyjobAndTriggerMapping = new ReadOnlyDictionary<IJobDetail, IReadOnlyCollection<ITrigger>>(jobAndTriggerMapping);
            await scheduler.ScheduleJobs(readOnlyjobAndTriggerMapping, true);
            await scheduler.Start(); //只有启动了，里面的任务才会定时触发
            Funs.ScheduledTasks = scheduler; // 仅在启动成功后赋值
        }

        public static void ISchedulerShupDown(IScheduler scheduler)
        {
            scheduler.Shutdown();
        }

        /// <summary>
        /// 同步任务调度
        /// </summary>
        /// <param name="InterFaceTaskId"></param>
        /// <returns></returns>
        public static async Task SyncISchedulerById(string InterFaceTaskId)
        {
            try
            {
                StdSchedulerFactory factory = new StdSchedulerFactory();
                var model = InterFaceTaskService.GetInterFaceTaskById(InterFaceTaskId);
                if (Funs.ScheduledTasks == null)
                {
                    ErrLogInfo.WriteLog("调度器未初始化");
                    return;
                }
                if (Funs.ScheduledTasks == null)
                {
                    ErrLogInfo.WriteLog("调度器未初始化");
                    return;
                }
                IScheduler scheduler = Funs.ScheduledTasks;
                JobKey jk = new JobKey(InterFaceTaskId, "group1");
                if (model != null)
                {
                    if (model.Enable == true)
                    {
                        if (scheduler.GetJobDetail(jk, default) != null)
                        {
                            var jobDetail1 = GetJobDetailByInterFaceTaskId(model.InterFaceTaskId);
                            var trigger1 = GetTriggerByTime(model.InterFaceTaskId, model.Frequency);
                            await scheduler.ScheduleJob(jobDetail1, trigger1, true);
                        }
                        else
                        {
                            var jobDetail1 = GetJobDetailByInterFaceTaskId(model.InterFaceTaskId);
                            var trigger1 = GetTriggerByTime(model.InterFaceTaskId, model.Frequency);
                            await scheduler.ScheduleJob(jobDetail1, trigger1, true);
                        }
                    }
                    else
                    {
                        if (scheduler.GetJobDetail(jk, default) != null)
                        {
                            await scheduler.DeleteJob(jk, default);
                            //  SyncScheduledTasks(model.InterFaceTaskId, scheduler, 2);
                        }
                    }
                }
                Funs.ScheduledTasks = scheduler;
            }
            catch (Exception ex)
            {
                string a = ex.ToString();
                throw;
            }
        }

        public static async Task DeleteISchedulerById(string InterFaceTaskId)
        {
            try
            {
                StdSchedulerFactory factory = new StdSchedulerFactory();
                var model = InterFaceTaskService.GetInterFaceTaskById(InterFaceTaskId);
                // var item = Funs.ScheduledTasks.Where(x => x.Key == InterFaceTaskId).FirstOrDefault();
                if (Funs.ScheduledTasks == null)
                {
                    ErrLogInfo.WriteLog("调度器未初始化");
                    return;
                }
                if (Funs.ScheduledTasks == null)
                {
                    ErrLogInfo.WriteLog("调度器未初始化");
                    return;
                }
                IScheduler scheduler = Funs.ScheduledTasks;
                JobKey jk = new JobKey(InterFaceTaskId, "group1");
                if (model != null)
                {
                    if (scheduler.GetJobDetail(jk, default) != null)
                    {
                        await scheduler.DeleteJob(jk, default);
                        //  SyncScheduledTasks(model.InterFaceTaskId, scheduler, 2);
                    }
                }
                Funs.ScheduledTasks = scheduler;
            }
            catch (Exception ex)
            {
                string a = ex.ToString();
                throw;
            }
        }

        /// <summary>
        /// 同步任务列表
        /// </summary>
        /// <param name="InterFaceTaskId"></param>
        /// <param name="scheduler"></param>
        /// <param name="type">0 增 1 修改 2删除</param>
        public static void SyncScheduledTasks(string InterFaceTaskId, IScheduler scheduler, int type)
        {
            if (type == 0)
            {
                //  Funs.ScheduledTasks.Add(InterFaceTaskId, scheduler);
            }
            else if (type == 1)
            {
                //   Funs.ScheduledTasks.Remove(InterFaceTaskId);
                // Funs.ScheduledTasks.Add(InterFaceTaskId, scheduler);
            }
            else if (type == 2)
            {
                // Funs.ScheduledTasks.Remove(InterFaceTaskId);
            }
        }
        public static IJobDetail GetJobDetailByInterFaceTaskId(string InterFaceTaskId)
        { //创建Job
            IJobDetail jobDetail1 = JobBuilder.Create<MyJob>()
                 .WithIdentity(InterFaceTaskId, "group1")//给Job身份
                 .WithDescription("任务的描述，方便查找")
                 .UsingJobData("InterFaceTaskId", InterFaceTaskId)
                 .Build();
            return jobDetail1;
        }
        public static ReadOnlyCollection<ITrigger> GetTriggerByTime(string InterFaceTaskId, string time)
        {
            // 参数校验
            if (string.IsNullOrWhiteSpace(InterFaceTaskId))
            {
                throw new ArgumentNullException(nameof(InterFaceTaskId), "任务ID不能为空");
            }

            if (string.IsNullOrWhiteSpace(time))
            {
                throw new ArgumentNullException(nameof(time), "时间表达式不能为空");
            }

            try
            {
                // 验证是否为有效的Cron表达式
                CronExpression.ValidateExpression(time);
                // 创建触发器
                var trigger = TriggerBuilder.Create()
                    .WithIdentity(InterFaceTaskId, "group1") // 给触发器身份
                    .WithDescription("触发器的描述，方便查找")
                    .StartAt(new DateTimeOffset(DateTime.Now.AddSeconds(10))) // 10秒后开始
                    .WithCronSchedule(time) // 使用传入的Cron表达式
                    .Build();

                return new ReadOnlyCollection<ITrigger>(new List<ITrigger> { trigger });
            }
            catch (FormatException ex)
            {
                throw new ArgumentException("无效的Cron时间表达式", nameof(time), ex);
            }
            catch (Exception ex)
            {
                throw new Exception("创建触发器时发生错误", ex);
            }
        }
    }
}