using Newtonsoft.Json;
using Rhea.Common;
using Sundial;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tiger.IBusiness;
using Tiger.Model;
using Tiger.Model.Minsun;
using static System.Collections.Specialized.BitVector32;

namespace Tiger.Business
{
    public class InterfaceServiceNew: IInterfaceService
    {

        public ISchedulerFactory _schedulerFactory { get; set; }
        /// <summary>
        /// 设置计划任务工厂类
        /// </summary>
        /// <param name="schedulerFactory"></param>
        public void SetSchedulerFactory(ISchedulerFactory schedulerFactory)
        {
            _schedulerFactory = schedulerFactory;
        }

        /// <summary>
        /// 根据实体类名及作业名称添加作业
        /// </summary>
        /// <typeparam name="TJob"></typeparam>
        /// <param name="newEntity"></param>
        /// <param name="jobParam"></param>
        public ApiAction AddJob<TJob>(TJob newEntity, TskJobParam jobParam) where TJob : class, IJob
        {
            ApiAction apiAction = new();
            TriggerBuilder triggerBuilder = Triggers.Period(jobParam.Period*60*1000).LoadFrom(new
            {
                TriggerId = jobParam.JobName + "_trigger1",
            });
            _schedulerFactory.AddJob<TJob>(jobParam.JobName, triggerBuilder);
            var trigger = GetJob(jobParam.JobName).GetTrigger($"{jobParam.JobName}_trigger1");
            TSK_JOB entity = ReturnDetail(jobParam.JobName);
            entity.Remark = jobParam.Remark;
            entity.JobType = typeof(TJob).Name;
            entity.JobName = jobParam.JobName;
            entity.TriggersWithGhost = new List<TSK_TRIG> { JsonConvert.DeserializeObject<TSK_TRIG>(JsonConvert.SerializeObject(trigger)) };
            entity.Triggers[0].Args = jobParam.Period.ToString();
            apiAction = SaveJob(entity);
            apiAction.Data = entity;
            return apiAction;
        }

        /// <summary>
        /// 根据作业名称添加作业
        /// </summary>
        /// <typeparam name="TJob"></typeparam>
        /// <param name="jobname"></param>
        /// <param name="triggerBuilders"></param>
        public ApiAction AddJob<TJob>(string jobname, params TriggerBuilder[] triggerBuilders) where TJob : class, IJob
        {
            ApiAction apiAction = new();
            triggerBuilders[0].LoadFrom(new
            {
                TriggerId = jobname + "_trigger1",
            });
            _schedulerFactory.AddJob<TJob>(jobname, triggerBuilders);
            var trigger = GetJob(jobname).GetTrigger($"{jobname}_trigger1");
            TSK_JOB entity = ReturnDetail(jobname);
            entity.TriggersWithGhost = new List<TSK_TRIG> { JsonConvert.DeserializeObject<TSK_TRIG>(JsonConvert.SerializeObject(trigger)) };
            apiAction = SaveJob(entity);
            apiAction.Data = entity;
            return apiAction;
        }

        /// <summary>
        /// 更新作业
        /// </summary>
        /// <param name="job"></param>
        /// <returns></returns>
        public ApiAction UpdateJob(TSK_JOB job)
        {
            ApiAction apiAction = new ApiAction();
            IScheduler scheduler = GetJob(job.JobName);
            var trigger = scheduler.GetTrigger($"{job.JobName}_trigger1");
            if (trigger.Status == TriggerStatus.Running)
            {
                apiAction.IsSuccessed = false;
                apiAction.Message = $"作业[{job.JobName}]正在运行不能编辑";
            }
            var triggerEntity = Biz.Db.Queryable<TSK_TRIG>().Where(x => x.JobId == job.ID).First();
            if (triggerEntity != null)
            {
                triggerEntity.Status = (int)trigger.Status;
                triggerEntity.Args = job.uPeriod.ToString();
            }
            var db = Business.Biz.Db;
            //保存到数据库
            var dbTran = db.UseTran(() =>
            {
                if (job != null)
                {
                    db.Updateable(job, "system").ExecuteCommand();
                }
                if (triggerEntity != null)
                {
                    db.Updateable(triggerEntity, "system").ExecuteCommand();
                }
            });
            if (!dbTran.IsSuccess)
            {
                apiAction.GetResponse().CatchExceptionWithLog(dbTran.ErrorException, $"作业保存到数据库异常");
            }
            //更新触发器周期
            scheduler.UpdateTrigger($"{job.JobName}_trigger1", triggerBuilder =>
            {
                triggerBuilder.SetArgs(job.uPeriod * 60 * 1000);
            }); ;
            return apiAction;
        }

        private TSK_JOB ReturnDetail(string jobname)
        {
            var jobDetail = GetJob(jobname).GetJobDetail();
            return JsonConvert.DeserializeObject<TSK_JOB>(JsonConvert.SerializeObject(jobDetail));
        }

        /// <summary>
        /// 启动所有作业
        /// </summary>
        public void StartAllJob()
        {
            _schedulerFactory.StartAll();
        }

        /// <summary>
        /// 启动单个作业
        /// </summary>
        /// <param name="jobname"></param>
        public void StartJob(string jobname)
        {
            // 带返回值
            IScheduler scheduler;
            var scheduleResult = _schedulerFactory.TryRunJob(jobname, out scheduler);
        }

        /// <summary>
        /// 获取单个作业
        /// </summary>
        /// <param name="jobname"></param>
        /// <returns></returns>
        public IScheduler GetJob(string jobname)
        {
            IScheduler scheduler;
            var scheduleResult = _schedulerFactory.TryGetJob(jobname, out scheduler);
            return scheduler;
        }

        /// <summary>
        /// 获取所有作业
        /// </summary>
        /// <returns></returns>
        public List<IScheduler> GetJobs()
        {
            return _schedulerFactory.GetJobs().ToList();
        }

        /// <summary>
        /// 暂停作业
        /// </summary>
        /// <param name="jobname"></param>
        public void PauseJob(string jobname)
        {
            var scheduler = GetJob(jobname);
            if (scheduler != null)
            {
                scheduler.Pause();
            }
        }
        /// <summary>
        /// 删除作业
        /// </summary>
        /// <param name="jobname"></param>
        public void RemoveJob(string jobname)
        {
            var scheduler = GetJob(jobname);
            if (scheduler != null)
            {
                scheduler.Remove();
            }
        }

        /// <summary>
        /// 从数据库加载作业
        /// </summary>
        public void AddJobFromDB()
        {
            try
            {
	            var jobs = Biz.Db.Queryable<TSK_JOB>().IncludesAllFirstLayer().ToList();
	            foreach (var job in jobs)
	            {
	                Type type = Type.GetType($"{job.AssemblyName}.{job.JobType},{job.AssemblyName}", throwOnError: true);
	                _schedulerFactory.AddJob(type, job.JobName, Triggers.Period(Convert.ToInt32(job.Triggers?[0].Args ?? "3") * 60 * 1000));
	                if (job.Triggers[0]?.Status == 3)
	                {
	                    Work.DoAsync(() =>
	                    {
	                        Thread.Sleep(2000);
	                        PauseJob(job.JobName);
	                    });
	                }
	            }
            }
            catch (System.Exception ex)
            {
                Logger.Console.Fatal(ex, "Add Job From DB Exception");
            }
        }

        /// <summary>
        /// 作业保存到数据库
        /// </summary>
        /// <param name="entity"></param>
        private ApiAction SaveJob(TSK_JOB entity)
        {
            var action = new ApiAction();
            entity.ID = Guid.NewGuid().ToString("N");
            entity.Triggers[0].JobId = entity.ID;
            if (Biz.Db.Queryable<TSK_JOB>().Where(x => x.JobName == entity.JobName && x.JobType == entity.JobType && x.AssemblyName == entity.AssemblyName).Any())
            {
                action.IsSuccessed = false;
                action.Message = $"作业已经存在，不能保存数据";
                return action;
            }
            var db = Business.Biz.Db;
            //保存到数据库
            var dbTran = db.UseTran(() =>
            {
                if (entity != null)
                {
                    db.Insertable(entity, "system").ExecuteCommand();
                }
                if (entity.Triggers.Any())
                {
                    db.Insertable(entity.Triggers, "system").ExecuteCommand();
                }
            });
            if (!dbTran.IsSuccess)
            {
                action.GetResponse().CatchExceptionWithLog(dbTran.ErrorException, $"作业保存到数据库异常");
            }
            return action;
        }
    }
}