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

using Data.SeaHavenIndustries;
using Data.SeaHavenIndustries.Enums;
using Microsoft.EntityFrameworkCore;
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 WorkOrderCompletionService : IWorkOrderCompletionService
    {
        private readonly ApplicationDbContext _context;
        private readonly ICompletionDocTemplateDataService _templateData;
        private readonly IWorkOrderDetailDataService _detailData;
        private readonly IWorkOrderAuditService _auditService;

        public WorkOrderCompletionService(
            ApplicationDbContext context,
            ICompletionDocTemplateDataService templateData,
            IWorkOrderDetailDataService detailData,
            IWorkOrderAuditService auditService)
        {
            _context = context;
            _templateData = templateData;
            _detailData = detailData;
            _auditService = auditService;
        }

        public async Task<IReadOnlyList<CompletionDocTemplateDto>> GetTemplatesAsync(string? serviceKey, WorkOrderType? workOrderType)
        {
            var rows = await _templateData.GetActiveAsync(serviceKey, workOrderType);
            return rows.Select(WorkOrderDetailService.MapTemplate).ToList();
        }

        public async Task<CompletionDocTemplateDto?> GetTemplateByIdAsync(int id)
        {
            var row = await _templateData.GetByIdAsync(id);
            return row == null ? null : WorkOrderDetailService.MapTemplate(row);
        }

        public async Task<WorkOrderCompletionDto> UploadCompletionDocAsync(
            int workOrderId,
            WorkOrderCompletionDocUploadDto request,
            string fileUrl,
            string? actorId)
        {
            var workOrder = await _context.workOrders
                .FirstOrDefaultAsync(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));

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

            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
                throw new WorkOrderBoardValidationException("ReadOnly", "Work order is read-only in its current status.");

            var workOrderVersion = ParseRowVersion(request.WorkOrderVersion);
            if (workOrderVersion != null && workOrder.RowVersion != null && !workOrder.RowVersion.SequenceEqual(workOrderVersion))
                throw new WorkOrderBoardValidationException("ConcurrencyConflict", "Work order was modified. Refresh and retry.");

            var oldDocStatus = workOrder.DocStatus?.ToString();
            var oldAttachment = workOrder.SignOffAttachment;

            workOrder.SignOffAttachment = fileUrl;
            if (!string.IsNullOrWhiteSpace(request.SignOffName))
                workOrder.SignOffName = request.SignOffName.Trim();
            if (!string.IsNullOrWhiteSpace(request.SignOffSignature))
                workOrder.SignOffSignature = request.SignOffSignature.Trim();

            workOrder.DocStatus = DocStatus.Yes;

            _auditService.StageFieldChanged(workOrderId, "SignOffAttachment", oldAttachment, fileUrl, actorId);
            if (oldDocStatus != DocStatus.Yes.ToString())
                _auditService.StageFieldChanged(workOrderId, "DocStatus", oldDocStatus, DocStatus.Yes.ToString(), actorId);

            await _context.SaveChangesAsync();

            var extended = await _detailData.GetExtendedFieldsAsync(workOrderId);
            var template = await _templateData.ResolveForWorkOrderAsync(workOrder.Trade, workOrder.WorkOrderType);
            var signoffs = await _detailData.GetDispatchSignoffsAsync(workOrderId);

            return new WorkOrderCompletionDto
            {
                DocStatus = workOrder.DocStatus,
                Template = template == null ? null : WorkOrderDetailService.MapTemplate(template),
                SignOffName = extended?.SignOffName,
                SignOffAttachment = extended?.SignOffAttachment,
                SignOffSignature = extended?.SignOffSignature,
                DispatchSignoffs = signoffs.Select(s => new DispatchSignoffDto
                {
                    DispatchId = s.DispatchId,
                    SignoffType = s.SignoffType,
                    Name = s.Name,
                    SignedAt = s.SignedAt?.ToUniversalTime().ToString("o")
                }).ToList()
            };
        }

        public async Task<CompletionDocTemplateDto> CreateTemplateAsync(CompletionDocTemplateCreateDto request)
        {
            if (string.IsNullOrWhiteSpace(request.Name) || string.IsNullOrWhiteSpace(request.ServiceKey))
                throw new WorkOrderBoardValidationException("InvalidValue", "Name and serviceKey are required.");

            var entity = new CompletionDocTemplate
            {
                Name = request.Name.Trim(),
                ServiceKey = request.ServiceKey.Trim(),
                WorkOrderType = request.WorkOrderType,
                TemplateUrl = request.TemplateUrl.Trim(),
                IsActive = request.IsActive
            };

            var created = await _templateData.CreateAsync(entity);
            return WorkOrderDetailService.MapTemplate(new CompletionDocTemplateRow(
                created.Id, created.Name, created.ServiceKey, created.WorkOrderType, created.TemplateUrl, created.IsActive));
        }

        public async Task<CompletionDocTemplateDto> UpdateTemplateAsync(int id, CompletionDocTemplateCreateDto request)
        {
            var entity = await _context.CompletionDocTemplates.FirstOrDefaultAsync(t => t.Id == id && t.IsDeleted != true);
            if (entity == null)
                throw new WorkOrderBoardValidationException("NotFound", "Template not found.");

            entity.Name = request.Name.Trim();
            entity.ServiceKey = request.ServiceKey.Trim();
            entity.WorkOrderType = request.WorkOrderType;
            entity.TemplateUrl = request.TemplateUrl.Trim();
            entity.IsActive = request.IsActive;

            await _templateData.UpdateAsync(entity);
            return WorkOrderDetailService.MapTemplate(new CompletionDocTemplateRow(
                entity.Id, entity.Name, entity.ServiceKey, entity.WorkOrderType, entity.TemplateUrl, entity.IsActive));
        }

        public async Task DeleteTemplateAsync(int id)
        {
            if (!await _templateData.DeleteAsync(id))
                throw new WorkOrderBoardValidationException("NotFound", "Template not found.");
        }

        private static byte[]? ParseRowVersion(string? base64)
        {
            if (string.IsNullOrWhiteSpace(base64))
                return null;

            try
            {
                return Convert.FromBase64String(base64);
            }
            catch (FormatException)
            {
                throw new WorkOrderBoardValidationException("InvalidRowVersion", "Invalid workOrderVersion format.");
            }
        }
    }
}