using DS.Module.Core;
using DS.Module.Core.Data;
using DS.WMS.Core.Op.Dtos.TaskInteraction;
using DS.WMS.Core.Op.Entity.TaskInteraction;
using DS.WMS.Core.Op.Interface.TaskInteraction;
using DS.WMS.Core.Op.Method.TaskInteraction.ActionExecutor;
using DS.WMS.Core.TaskPlat;
using SqlSugar;

namespace DS.WMS.Core.Op.Method.TaskInteraction
{
    /// <summary>
    /// 动作执行管理
    /// </summary>
    public class ActionManagerService : ServiceBase, IActionManagerService
    {
        Dictionary<TaskActionType, IActionExecutor> ExecutorMappings;

        /// <summary>
        /// 初始化
        /// </summary>
        public ActionManagerService(IServiceProvider serviceProvider) : base(serviceProvider)
        {
            ExecutorMappings = new Dictionary<TaskActionType, IActionExecutor>();
            ExecutorMappings[TaskActionType.Mail] = new MailActionExecutor();
        }

        /// <summary>
        /// 触发任务执行动作
        /// </summary>
        /// <param name="businessTask">任务信息</param>
        /// <returns></returns>
        public async Task TriggerAction(BusinessTask businessTask)
        {
            ArgumentNullException.ThrowIfNull(businessTask, nameof(businessTask));

            //目前只限制任务完成才触发
            if (businessTask.TaskStatus != TaskStatusEnum.Complete)
                return;

            // 执行自动化操作
            TaskFlowDataContext dataContext = new(
                (TaskFlowDataNameConst.BusinessTask, businessTask)
            );

            TaskFlowRuner taskFlow = new(TenantDb, ServiceProvider);
            await taskFlow.RunWithBsno(businessTask.TaskType, businessTask.BusinessId, dataContext);
        }

        public async Task ExecuteAsync(TaskFlowDataContext dataContext)
        {
            ArgumentNullException.ThrowIfNull(dataContext, nameof(dataContext));

            TaskActionType actionType = (TaskActionType)dataContext.Get<int>("ActionType");
            if (ExecutorMappings.TryGetValue(actionType, out IActionExecutor executor))
            {
                var context = new ActionExecutionContext
                {
                    TaskInfo = dataContext.Get<BusinessTask>(TaskFlowDataNameConst.BusinessTask),
                    ServiceProvider = ServiceProvider
                };
                foreach (var key in dataContext.Keys)
                {
                    context.AdditionalData[key] = dataContext[key];
                }

                await executor.ExecuteAsync(context);
            }
        }

        public async Task TriggerTest(TaskBaseTypeEnum taskType, long? id)
        {
            var task = await TenantDb.Queryable<BusinessTask>()
                .Where(t => t.TaskType == taskType
                    //&& SqlFunc.Subqueryable<SeaExport>().Where(s => t.BusinessId == s.Id && s.BillSubmitStatus == AuditStatusEnum.Approve).Any()
                    )
                //.Where(x => x.TaskStatus == TaskStatusEnum.Complete)
                .WhereIF(id.HasValue, x => x.BusinessId == id)
                .OrderByDescending(t => SqlFunc.GetRandom()).Take(1).FirstAsync();
            if (task != null)
            {
                TaskFlowDataContext dataContext = new(
                    (TaskFlowDataNameConst.BusinessTask, task),
                    ("ActionType", 1),
                    ("Name", "订舱代理通知")
                );

                TaskFlowRuner taskFlow = new(TenantDb, ServiceProvider);
                await taskFlow.RunWithBsno(task.TaskType, task.BusinessId, dataContext);
            }
        }
    }

    /// <summary>
    /// 任务执行类型
    /// </summary>
    public enum TaskActionType
    {
        /// <summary>
        /// 后台任务
        /// </summary>
        BackgroundWorker,

        /// <summary>
        /// 邮件
        /// </summary>
        Mail,
    }
}