using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.WorkflowModules;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Settings;
using Hotline.Users;
using XF.Domain.Authentications;
using XF.Domain.Entities;

namespace Hotline.FlowEngine.Workflows
{
    public interface IWorkflowDomainService
    {
        /// <summary>
        /// 创建流程
        /// </summary>
        Task<Workflow> CreateWorkflowAsync(WorkflowModule wfModule, string title, string userId, string orgId,
            string? externalId = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// 进行流程的开始节点
        /// </summary>
        Task StartAsync(Workflow workflow, WorkflowStep startStep, BasicWorkflowDto dto, StepDefine firstStepDefine,
            bool isNextDynamic, FlowAssignInfo flowAssignInfo, ECounterSignType? counterSignType, DateTime? expiredTime,
            ISessionContext current, CancellationToken cancellationToken);

        /// <summary>
        /// 查询工作流
        /// </summary>
        Task<Workflow> GetWorkflowAsync(string workflowId, bool withDefine = false, bool withSteps = false,
            bool withTraces = false, bool withTracesTree = false, bool withSupplements = false,
            bool withCountersigns = false, CancellationToken cancellationToken = default);

        /// <summary>
        /// 查询工作流包含当前用户办理权限（是否可办理）
        /// </summary>
        Task<(Workflow Workflow, string? CountersignId, bool CanHandle, bool CanPrevious, WorkflowTrace? Trace)> GetWorkflowHandlePermissionAsync(
            string workflowId, string userId, string orgId, string[] roleIds, CancellationToken cancellationToken = default);

        /// <summary>
        /// 受理,接办
        /// </summary>
        Task AcceptAsync(Workflow workflow, string userId, string? userName, string orgId, string? orgName,
            string? orgAreaCode, string? orgAreaName, CancellationToken cancellationToken);

        /// <summary>
        /// 办理（流转至下一节点）
        /// </summary>
        Task NextAsync(Workflow workflow, WorkflowStep currentStep, NextWorkflowDto dto, StepDefine nextStepDefine,
            bool isNextDynamic, FlowAssignInfo flowAssignInfo, DateTime? expiredTime,
            ISessionContext current, CancellationToken cancellationToken);

        /// <summary>
        /// 退回（返回前一节点）
        /// </summary>
        /// <returns></returns>
        Task<EFlowDirection> PreviousAsync(Workflow workflow, PreviousWorkflowDto dto,
            string applicantId, string applicantName,
            string applicantOrgId, string applicantOrgName,
            string applicantOrgAreaCode, string applicantOrgAreaName,
            bool applicantIsCenter, string[] applicantRoleIds,
            CancellationToken cancellationToken);

        /// <summary>
        /// 撤回（返回到之前任意节点）
        /// </summary>
        Task RecallAsync(Workflow workflow, RecallDto dto, StepDefine targetStepDefine, FlowAssignInfo flowAssignInfo,
            DateTime? expiredTime, bool isOrderFiled, CancellationToken cancellationToken);

        /// <summary>
        /// 撤回至开始节点
        /// </summary>
        Task RecallToStartStepAsync(string workflowId, string opinion, ISessionContext current, CancellationToken cancellationToken);

        /// <summary>
        /// 特提至派单节点（无派单节点会抛异常）
        /// </summary>
        Task RecallToSendStepAsync(string workflowId, string opinion, ISessionContext current, CancellationToken cancellationToken);

        ///// <summary>
        ///// 跳转（直接将流程跳转至任意节点）
        ///// </summary>
        //Task JumpAsync(Workflow workflow, RecallDto dto, StepDefine targetStepDefine, FlowAssignInfo flowAssignInfo,
        //    CancellationToken cancellationToken);

        ///// <summary>
        ///// 重办
        ///// </summary>
        //Task RedoAsync(Workflow workflow, RecallDto dto, StepDefine targetStepDefine, FlowAssignInfo flowAssignInfo,
        //    CancellationToken cancellationToken);

        ///// <summary>
        ///// 否决（审批流程不通过）
        ///// </summary>
        ///// <returns></returns>
        //Task RejectAsync(Workflow workflow, BasicWorkflowDto dto, CancellationToken cancellationToken);

        /// <summary>
        /// 补充
        /// </summary>
        /// <returns></returns>
        Task SupplementAsync(Workflow workflow, EndWorkflowDto dto, CancellationToken cancellationToken);

        /// <summary>
        /// 终止流程
        /// </summary>
        Task TerminateAsync(TerminateDto dto, CancellationToken cancellationToken);

        /// <summary>
        /// 结束流程（流程直接流转至结束节点）
        /// </summary>
        Task<WorkflowTrace> EndAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine endStepDefine,
            WorkflowStep currentStep, ISessionContext current, DateTime? expiredTime, CancellationToken cancellationToken);

        StepDefine GetStepDefine(WorkflowDefinition workflowDefinition, string stepCode);

        /// <summary>
        /// 查询当前待办理节点
        /// </summary>
        WorkflowStep FindCurrentStepWaitForHandle(Workflow workflow, string userId, string orgId, string[] roleIds);

        /// <summary>
        /// 查询当前节点中最后一个节点
        /// </summary>
        Task<WorkflowStep?> FindLastStepAsync(string workflowId, CancellationToken cancellationToken);

        /// <summary>
        /// 查询所有办理部门及实际办理部门
        /// </summary>
        Task<(Kv, IReadOnlyList<Kv>)> GetHandleOrgsAsync(string workflowId, CancellationToken cancellationToken);

        /// <summary>
        /// 依据配置过滤下一节点
        /// </summary>
        List<StepDefine> NextStepDefineFilter(EPathPolicy pathPolicy, List<StepDefine> nextStepDefines);

        /// <summary>
        /// 撤销流程
        /// </summary>
        Task CancelAsync(CancelDto dto, DateTime? expiredTime, ISessionContext current, CancellationToken cancellationToken);

        ///// <summary>
        ///// 更新期满时间
        ///// </summary>
        //Task UpdateExpiredTimeAsync(Workflow workflow, DateTime expiredTime, string timelimit, int? timelimiteCount,
        //    ETimeType? timelimitUnit, DateTime nearlyExpiredTime, CancellationToken cancellationToken);

        /// <summary>
        /// 新增流程流转记录
        /// </summary>
        Task AddTracesAsync(string workflowId, List<WorkflowTrace> traces, CancellationToken cancellationToken);

        /// <summary>
        /// 创建开始节点
        /// </summary>
        WorkflowStep CreateStartStep(Workflow workflow, StepDefine startStepDefine, BasicWorkflowDto dto,
            FlowStepHandler handler, DateTime? expiredTime, EFlowAssignType? flowAssignType = EFlowAssignType.User);

        /// <summary>
        /// 查询未完成节点
        /// </summary>
        /// <param name="steps"></param>
        /// <param name="orgId"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        WorkflowStep GetUnHandleStep(List<WorkflowStep> steps, string orgId, string userId, string[] roleIds);

        /// <summary>
        /// 检查当前办理节点是否为开始节点
        /// </summary>
        /// <param name="workflowId"></param>
        /// <param name="userId">当前办理人Id</param>
        /// <param name="orgId">当前办理人orgId</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        Task<bool> CheckCurrentIsStartStepAsync(string workflowId, string userId, string orgId,
            CancellationToken cancellationToken);

        /// <summary>
        /// 检查动态节点是否该终止
        /// </summary>
        bool DynamicShouldTerminal(StepDefine currentStepDefine, int currentOrgLevel);

        /// <summary>
        /// 终止会签
        /// </summary>
        /// <param name="countersignId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        Task<Workflow> TerminalCountersignAsync(string countersignId, CancellationToken cancellationToken);

        /// <summary>
        /// 办理节点
        /// </summary>
        Task HandleStepAsync(ISessionContext current, WorkflowStep step, Workflow workflow, BasicWorkflowDto dto,
            EFlowAssignType? flowAssignType, ECounterSignType? counterSignType, DateTime? expiredTime,
            CancellationToken cancellationToken);

        /// <summary>
        /// 获取会签类型
        /// </summary>
        //ECounterSignType? GetCounterSignType(EBusinessType businessType);
        ECounterSignType? GetCounterSignType(bool isStartCountersign);

        /// <summary>
        /// 查询退回节点信息
        /// </summary>
        (WorkflowStep currentStep, WorkflowStep prevStep, WorkflowStep? countersignStartStep) GetPreviousStep(
            Workflow workflow, string operaterId, string operaterOrgId, string[] roleIds);

        /// <summary>
        /// 查询派单池中流程节点id
        /// </summary>
        Task<IReadOnlyList<string>> GetUnhandleStepIdsFromSendPoolAsync(string sendPoolId, CancellationToken cancellationToken);

        /// <summary>
        /// 查询归属某用户的所有流程节点
        /// </summary>
        Task<List<WorkflowStep>> GetStepsBelongsToAsync(string userId, CancellationToken cancellationToken);

        ///// <summary>
        ///// 批量改派工单至指定用户
        ///// </summary>
        //Task<ICollection<string>> ChangeHandlerRangeAsync(string sendPoolId,
        //    IReadOnlyList<(string userId, string username, string orgId, string orgName, IReadOnlyList<string> stepIds)> handlers,
        //    CancellationToken cancellationToken);

        /// <summary>
        /// 批量修改工单办理对象
        /// </summary>
        Task ChangeHandlerBatchAsync(
            IReadOnlyList<(string userId, string username, string orgId, string orgName, string? roleId, string? roleName, ICollection<WorkflowStep> steps)> handlers,
            CancellationToken cancellationToken);

        /// <summary>
        /// 查询工单办理中的一级部门
        /// </summary>
        Task<ICollection<Kv>> GetLevelOneOrgsAsync(string workflowId, CancellationToken cancellation);

        /// <summary>
        /// 更新未办理节点的期满时间
        /// </summary>
        Task UpdateUnhandleExpiredTimeAsync(string workflowId, DateTime expiredTime, CancellationToken cancellation);

        /// <summary>
        /// 查询该部门最后办理节点
        /// </summary>
        /// <returns></returns>
        Task<WorkflowStep> FindLastHandleStepAsync(string workflowId, string orgId, CancellationToken cancellation);

        /// <summary>
        /// 查询流转方向
        /// </summary>
        EFlowDirection GetFlowDirection(EBusinessType sourceStepBusinessType, EBusinessType directionStepBusinessType);

        /// <summary>
        /// 流程被签收至某个用户（更新流转对象，办理对象，节点办理对象以及stepHandlers）
        /// </summary>
        Task<Workflow> SignToSomebodyAsync(string workflowId, string userId, string username, string orgId, string orgName, CancellationToken cancellationToken);

        /// <summary>
        /// 非节点办理人员查询待办节点
        /// </summary>
        /// <returns></returns>
        Task<ICollection<WorkflowStep>> GetUnhandleStepsByOthersAsync(string workflowId, CancellationToken cancellationToken);
    }
}