using FASS.Scheduler.Lite.Services.CronTasks.Jobs;
using FASS.Scheduler.Models;
using Quartz;

namespace FASS.Scheduler.Services.CronTasks
{
    public class CronTaskService
    {
        public ILogger<CronTaskService> Logger { get; }
        public AppSettings AppSettings { get; }
        public IServiceProvider ServiceProvider { get; }

        public CronTaskService(
            ILogger<CronTaskService> logger,
            AppSettings appSettings,
            IServiceProvider serviceProvider)
        {
            Logger = logger;
            AppSettings = appSettings;
            ServiceProvider = serviceProvider;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            try
            {
                if (AppSettings.Frame.CronTask.IsEnable)
                {
                    var factory = ServiceProvider.GetRequiredService<ISchedulerFactory>();

                    var scheduler = await factory.GetScheduler();
                    #region [5]基础数据同步以及订单组单Job
                    //零件主数据同步Job
                    var job1 = JobBuilder.Create<MaterialUpdataJob>()
                        .WithIdentity("materialUpdateJob", "dataSyncGroup")
                        .Build();

                    var trigger1 = TriggerBuilder.Create()
                        .WithIdentity("materialUpdataTrigger", "dataSyncGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.MaterialUpdateDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job1, trigger1);

                    //零件库位关系数据同步Job
                    var job2 = JobBuilder.Create<MaterialStorageUpdataJob>()
                        .WithIdentity("materialStorageUpdataJob", "dataSyncGroup")
                        .Build();

                    var trigger2 = TriggerBuilder.Create()
                        .WithIdentity("materialStorageUpdataTrigger", "dataSyncGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.MaterialRelationDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job2, trigger2);

                    //订单组单Job
                    var job3 = JobBuilder.Create<OrderPackagingJob>()
                        .WithIdentity("orderPackagingJob", "dataSyncGroup")
                        .Build();

                    var trigger3 = TriggerBuilder.Create()
                        .WithIdentity("orderPackagingTrigger", "dataSyncGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.OrderPackagingDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job3, trigger3);

                    //拣配单打印服务
                    var job4 = JobBuilder.Create<OrderPrintJob>()
                        .WithIdentity("orderPrintJob", "dataSyncGroup")
                        .Build();

                    var trigger4 = TriggerBuilder.Create()
                        .WithIdentity("orderPrintJobTrigger", "dataSyncGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.PrintedDueTime))
                        .RepeatForever())
                        .Build();

                    await scheduler.ScheduleJob(job4, trigger4);

                    //回传拣配完成状态到LES
                    if (AppSettings.Scheduler.EnableOrderReport)
                    {                      
                        var job5 = JobBuilder.Create<OrderReportJob>()
                            .WithIdentity("orderReportJob", "dataSyncGroup")
                            .Build();

                        var trigger5 = TriggerBuilder.Create()
                            .WithIdentity("orderReportJobTrigger", "dataSyncGroup")
                            .StartNow()
                            .WithSimpleSchedule(x => x
                            .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.OrderReportDueTime))
                            .RepeatForever())
                            .Build();

                        await scheduler.ScheduleJob(job5, trigger5);
                    }
                    #endregion

                    #region [5]开始灯/结束灯/物料灯亮灯job
                    //区域开始灯job
                    var job10 = JobBuilder.Create<CheckAreaFirstLightJob>()
                        .WithIdentity("checkAreaFirstLightJob", "lightGroup")
                        .Build();

                    var trigger10 = TriggerBuilder.Create()
                        .WithIdentity("checkAreaFirstLightJobTrigger", "lightGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.FirstLightDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job10, trigger10);

                    //物料灯点亮job
                    var job11 = JobBuilder.Create<CheckMaterialLightJob>()
                        .WithIdentity("checkMaterialLightJob", "lightGroup")
                        .Build();

                    var trigger11 = TriggerBuilder.Create()
                        .WithIdentity("checkMaterialLightJobTrigger", "lightGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.MaterialLightDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job11, trigger11);

                    //结束灯点亮job
                    var job12 = JobBuilder.Create<CheckEndLightJob>()
                        .WithIdentity("checkEndLightJob", "lightGroup")
                        .Build();

                    var trigger12 = TriggerBuilder.Create()
                        .WithIdentity("checkEndLightJobTrigger", "lightGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.EndLightDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job12, trigger12);

                    //切换区域job[包括结束任务]
                    var job13 = JobBuilder.Create<CheckSwitchSegmentJob>()
                        .WithIdentity("checkSwitchSegmentJob", "lightGroup")
                        .Build();

                    var trigger13 = TriggerBuilder.Create()
                        .WithIdentity("checkSwitchSegmentJobTrigger", "lightGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.SwitchSegmentDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job13, trigger13);

                    //分段开始灯点亮job
                    var job14 = JobBuilder.Create<CheckStartLightJob>()
                        .WithIdentity("checkStartLightJob", "lightGroup")
                        .Build();

                    var trigger14 = TriggerBuilder.Create()
                        .WithIdentity("checkStartLightJobTrigger", "lightGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.SegmentStartLightDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job14, trigger14);

                    #endregion

                    #region [4]异常判定/消息推送job
                    //配载单超时未接收判定服务
                    if (AppSettings.Scheduler.EnableBomInfoWarning)
                    {
                        var job20 = JobBuilder.Create<BomInfoWarningJob>()
                        .WithIdentity("bomInfoWarningJob", "warningGroup")
                        .Build();

                        var trigger20 = TriggerBuilder.Create()
                            .WithIdentity("bomInfoWarningJobTrigger", "warningGroup")
                            .StartNow()
                            .WithSimpleSchedule(x => x
                            .WithIntervalInSeconds(AppSettings.Scheduler.BomInfoWarningDueTime)
                            .RepeatForever())
                            .Build();
                        await scheduler.ScheduleJob(job20, trigger20);
                    }

                    //控制器/灯离线判定服务
                    if (AppSettings.Scheduler.EnableLightOfflineWarning)
                    {
                        var job21 = JobBuilder.Create<LightOfflineWarningJob>()
                        .WithIdentity("lightOfflineJob", "warningGroup")
                        .Build();

                        var trigger21 = TriggerBuilder.Create()
                            .WithIdentity("lightOfflineJobTrigger", "warningGroup")
                            .StartNow()
                            .WithSimpleSchedule(x => x
                            .WithIntervalInMinutes(AppSettings.Scheduler.LightOfflineDueTime)
                            .RepeatForever())
                            .Build();

                        await scheduler.ScheduleJob(job21, trigger21);
                    }

                    //打印机离线判定服务
                    if (AppSettings.Scheduler.EnablePrinterOfflineWarning)
                    {
                        var job22 = JobBuilder.Create<PrinterOfflineWarningJob>()
                        .WithIdentity("printerOfflineJob", "warningGroup")
                        .Build();

                        var trigger22 = TriggerBuilder.Create()
                            .WithIdentity("printerOfflineJobTrigger", "warningGroup")
                            .StartNow()
                            .WithSimpleSchedule(x => x
                            .WithIntervalInMinutes(AppSettings.Scheduler.PrinterOfflineDueTime)
                            .RepeatForever())
                            .Build();

                        await scheduler.ScheduleJob(job22, trigger22);
                    }

                    //钉钉推送服务（默认启动，在job中判定推送）
                    var job23 = JobBuilder.Create<AlarmPushJob>()
                        .WithIdentity("alarmPushJob", "warningGroup")
                        .Build();

                    var trigger23 = TriggerBuilder.Create()
                        .WithIdentity("alarmPushJobTrigger", "warningGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.AlarmPushDueTime))
                        .RepeatForever())
                        .Build();
                    await scheduler.ScheduleJob(job23, trigger23);

                    #endregion

                    #region [3]数据/文件归档job
                    //任务完成后从实时表归档到历史表
                    var job30 = JobBuilder.Create<TaskArchivingJob>()
                        .WithIdentity("taskArchivingJob", "archivingGroup")
                        .Build();

                    var trigger30 = TriggerBuilder.Create()
                        .WithIdentity("taskArchivingJob", "archivingGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithIntervalInMinutes(AppSettings.Scheduler.TaskArchivingDueTime)
                        .RepeatForever())
                        .Build();

                    await scheduler.ScheduleJob(job30, trigger30);

                    //其他数据表归档服务
                    var job31 = JobBuilder.Create<DataArchivingJob>()
                        .WithIdentity("dataArchivingJob", "archivingGroup")
                        .Build();

                    var trigger31 = TriggerBuilder.Create()
                        .WithIdentity("dataArchivingJobTrigger", "archivingGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithIntervalInMinutes(AppSettings.Scheduler.DataArchivingDueTime)
                        .RepeatForever())
                        .Build();

                    await scheduler.ScheduleJob(job31, trigger31);

                    //文件清理服务(12h清理一次)
                    var job32 = JobBuilder.Create<PrintedFilesArchivingJob>()
                        .WithIdentity("printedFilesArchivingJob", "archivingGroup")
                        .Build();

                    var trigger32 = TriggerBuilder.Create()
                        .WithIdentity("printedFilesArchivingJobTrigger", "archivingGroup")
                        .StartNow()
                        .WithSimpleSchedule(x => x
                        .WithIntervalInHours(AppSettings.Scheduler.PrintedFileClearDueTime)
                        .RepeatForever())
                        .Build();

                    await scheduler.ScheduleJob(job32, trigger32);

                    #endregion

                    #region [1]BOM解析生成车辆物料清单job
                    //BOM解析服务
                    if (AppSettings.Scheduler.EnableMaterialResolver)
                    {
                        var job40 = JobBuilder.Create<ProductionMaterialResolverJob>()
                            .WithIdentity("productionMaterialResolverJob", "bomResolverGroup")
                            .Build();

                        var trigger40 = TriggerBuilder.Create()
                            .WithIdentity("ProductionMaterialResolverJobTrigger", "bomResolverGroup")
                            .StartNow()
                            .WithSimpleSchedule(x => x
                            .WithInterval(TimeSpan.FromMilliseconds(AppSettings.Scheduler.MaterialResolverDueTime))
                            .RepeatForever())
                            .Build();
                        await scheduler.ScheduleJob(job40, trigger40);
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.ToString());
            }
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            try
            {
                if (AppSettings.Frame.CronTask.IsEnable)
                {

                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.ToString());
            }
            return Task.CompletedTask;
        }
    }
}