shoc-backend/SeaHaven.Services/Implementation/WorkOrderBoardCancelService.cs

using System.Security.Claims;
using Data.SeaHavenIndustries.Enums;
using SeaHaven.DataServices.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Exceptions;
using SeaHaven.Services.Helpers;
using SeaHaven.Services.Interfaces;

namespace SeaHaven.Services.Implementation
{
    public class WorkOrderBoardCancelService : IWorkOrderBoardCancelService
    {
        private readonly IWorkOrderBoardMutationDataService _mutationData;
        private readonly IWorkOrderBoardService _boardService;
        private readonly IWorkOrderAuditService _auditService;
        private readonly IWorkOrderUpliftService _upliftService;
        private readonly IUpliftDataService _upliftData;

        public WorkOrderBoardCancelService(
            IWorkOrderBoardMutationDataService mutationData,
            IWorkOrderBoardService boardService,
            IWorkOrderAuditService auditService,
            IWorkOrderUpliftService upliftService,
            IUpliftDataService upliftData)
        {
            _mutationData = mutationData;
            _boardService = boardService;
            _auditService = auditService;
            _upliftService = upliftService;
            _upliftData = upliftData;
        }

        public async Task<WorkOrderBoardRowDto> CancelAsync(
            int workOrderId,
            ClaimsPrincipal user,
            string? actorId)
        {
            return await _upliftData.ExecuteWorkOrderMutationAsync(
                workOrderId,
                ct => CancelLockedAsync(workOrderId, user, actorId, ct),
                CancellationToken.None);
        }

        private async Task<WorkOrderBoardRowDto> CancelLockedAsync(
            int workOrderId,
            ClaimsPrincipal user,
            string? actorId,
            CancellationToken cancellationToken)
        {
            var workOrder = await _mutationData.GetTrackedWorkOrderAsync(workOrderId, cancellationToken);

            if (workOrder == null)
                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");

            if (workOrder.LifecycleStatus == LifecycleStatus.Canceled)
            {
                var existing = await _boardService.GetBoardRowAsync(workOrderId, user);
                return existing ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
            }

            if (workOrder.LifecycleStatus == LifecycleStatus.Completed)
                throw new WorkOrderBoardValidationException("CancelNotAllowed", "Work order cannot be canceled in its current status.");

            var oldStatus = workOrder.LifecycleStatus?.ToString() ?? workOrder.Status ?? "";
            workOrder.LifecycleStatus = LifecycleStatus.Canceled;
            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(LifecycleStatus.Canceled);
            if (workOrder.LegacyStatus == null && workOrder.Status != null)
                workOrder.LegacyStatus = workOrder.Status;

            await _upliftService.WithdrawPendingForWorkOrderAsync(workOrderId, actorId, cancellationToken);
            await _auditService.StageStatusChangedAsync(workOrderId, oldStatus, LifecycleStatus.Canceled.ToString(), actorId);
            await _mutationData.SaveAsync(cancellationToken);

            var row = await _boardService.GetBoardRowAsync(workOrderId, user);
            return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
        }
    }
}