namespace SimpleAdmin.Application;

/// <summary>
/// 实现入职任务生命周期业务能力。
/// </summary>
public class OnboardingTaskLifecycleService : IOnboardingTaskLifecycleService
{
    private readonly SqlSugarScope _db;
    private readonly IOnboardingDataPermissionService _dataPermission;

    public OnboardingTaskLifecycleService(IOnboardingDataPermissionService dataPermission)
    {
        _db = DbContext.DB;
        _dataPermission = dataPermission;
    }

    /// <summary>
    /// 归档已审核通过的入职任务。
    /// </summary>
    public async Task Archive(OnboardingAuditActionInput input)
    {
        await OnboardingConcurrency.RunTask(_db, input.TaskId, () => ArchiveCore(input));
    }

    private async Task ArchiveCore(OnboardingAuditActionInput input)
    {
        var task = await Authorize(input.TaskId);
        if (task.TaskStatus != OnboardingTaskStatus.Approved)
        {
            throw Oops.Bah("仅审核通过任务可归档");
        }

        await _db.Ado.BeginTranAsync();
        try
        {
            var archivedAt = DateTime.Now;
            var updatedRows = await _db.Updateable<ObOnboardingTask>()
                .SetColumns(item => new ObOnboardingTask
                {
                    TaskStatus = OnboardingTaskStatus.Archived,
                    ArchivedAt = archivedAt
                })
                .Where(item => item.Id == task.Id
                               && item.TaskStatus == OnboardingTaskStatus.Approved)
                .ExecuteCommandAsync();
            if (updatedRows != 1)
                throw Oops.Bah("该入职任务状态已变化，请刷新后重试");

            task.TaskStatus = OnboardingTaskStatus.Archived;
            task.ArchivedAt = archivedAt;
            await Log(task, OnboardingAuditAction.Archive, input.AuditOpinion);
            await _db.Ado.CommitTranAsync();
        }
        catch
        {
            await _db.Ado.RollbackTranAsync();
            throw;
        }
    }

    /// <summary>
    /// 撤销入职任务并同步撤销仍然有效的员工填写链接。
    /// </summary>
    public async Task Revoke(OnboardingAuditActionInput input)
    {
        await OnboardingConcurrency.RunTask(_db, input.TaskId, () => RevokeCore(input));
    }

    private async Task RevokeCore(OnboardingAuditActionInput input)
    {
        var task = await Authorize(input.TaskId);
        if (task.TaskStatus == OnboardingTaskStatus.Approved
            || task.TaskStatus == OnboardingTaskStatus.Archived
            || task.TaskStatus == OnboardingTaskStatus.Revoked)
        {
            throw Oops.Bah("已通过、已归档或已撤销任务不能再次撤销");
        }

        await _db.Ado.BeginTranAsync();
        try
        {
            var originalStatus = task.TaskStatus;
            var revokedAt = DateTime.Now;
            var updatedRows = await _db.Updateable<ObOnboardingTask>()
                .SetColumns(item => item.TaskStatus == OnboardingTaskStatus.Revoked)
                .Where(item => item.Id == task.Id && item.TaskStatus == originalStatus)
                .ExecuteCommandAsync();
            if (updatedRows != 1)
                throw Oops.Bah("该入职任务状态已变化，请刷新后重试");

            await _db.Updateable<ObTaskLink>()
                .SetColumns(item => new ObTaskLink
                {
                    LinkStatus = OnboardingLinkStatus.Revoked,
                    RevokedAt = revokedAt
                })
                .Where(item => item.TaskId == task.Id
                               && item.LinkStatus == OnboardingLinkStatus.Active)
                .ExecuteCommandAsync();
            task.TaskStatus = OnboardingTaskStatus.Revoked;
            await Log(task, OnboardingAuditAction.Revoke, input.AuditOpinion);
            await _db.Ado.CommitTranAsync();
        }
        catch
        {
            await _db.Ado.RollbackTranAsync();
            throw;
        }
    }

    /// <summary>
    /// 删除已撤销的入职任务及其全部关联快照数据。
    /// </summary>
    public async Task Delete(BaseIdInput input)
    {
        await OnboardingConcurrency.RunTask(_db, input.Id, () => DeleteCore(input));
    }

    private async Task DeleteCore(BaseIdInput input)
    {
        var task = await Authorize(input.Id);
        if (task.TaskStatus != OnboardingTaskStatus.Revoked)
        {
            throw Oops.Bah("仅已撤销的任务可以删除");
        }

        await _db.Ado.BeginTranAsync();
        try
        {
            var taskContractIds = await _db.Queryable<ObTaskContract>()
                .Where(x => x.TaskId == task.Id)
                .Select(x => x.Id)
                .ToListAsync();

            var signProcessIds = await _db.Queryable<ObElectronicSignProcess>()
                .Where(x => x.TaskId == task.Id)
                .Select(x => x.Id)
                .ToListAsync();

            if (signProcessIds.Count > 0)
            {
                await _db.Deleteable<ObElectronicSignEvent>()
                    .Where(x => x.SignProcessId.HasValue
                                && signProcessIds.Contains(x.SignProcessId.Value))
                    .ExecuteCommandAsync();
                await _db.Deleteable<ObElectronicSignDocument>()
                    .Where(x => signProcessIds.Contains(x.SignProcessId))
                    .ExecuteCommandAsync();
                await _db.Deleteable<ObElectronicSignProcess>()
                    .Where(x => signProcessIds.Contains(x.Id))
                    .ExecuteCommandAsync();
            }

            await _db.Deleteable<ObEmployeeContractSnapshot>()
                .Where(x => x.TaskId == task.Id)
                .ExecuteCommandAsync();
            if (taskContractIds.Count > 0)
            {
                await _db.Deleteable<ObTaskContractVariable>()
                    .Where(x => taskContractIds.Contains(x.TaskContractId))
                    .ExecuteCommandAsync();
            }

            await _db.Deleteable<ObTaskContract>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskLink>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskMaterialRequirement>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskMaterial>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskEmployeeInfo>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskFormRequirement>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskOperationLog>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObTaskAudit>().Where(x => x.TaskId == task.Id).ExecuteCommandAsync();
            await _db.Deleteable<ObOnboardingTask>().In(task.Id).ExecuteCommandAsync();
            await _db.Ado.CommitTranAsync();
        }
        catch
        {
            await _db.Ado.RollbackTranAsync();
            throw;
        }
    }

    private async Task<ObOnboardingTask> Authorize(long taskId)
    {
        var task = await _db.Queryable<ObOnboardingTask>().InSingleAsync(taskId)
            ?? throw Oops.Bah("入职任务不存在");
        await _dataPermission.EnsureCanManage(
            task.CreateUserId,
            OnboardingPermissionCodes.TaskManageAll,
            "入职任务");

        return task;
    }

    private Task Log(ObOnboardingTask task, string action, string opinion)
    {
        return _db.Insertable(new ObTaskAudit
        {
            Id = global::SimpleAdmin.Core.Utils.CommonUtils.GetSingleId(),
            TaskId = task.Id,
            AuditRound = task.SubmitCount,
            AuditAction = action,
            AuditorUserId = UserManager.UserId,
            AuditOpinion = opinion,
            AuditedAt = DateTime.Now
        }).ExecuteCommandAsync();
    }
}