shoc-backend/SeaHaven.Services/Implementation/WorkOrderMediaService.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 WorkOrderMediaService : IWorkOrderMediaService
    {
        private readonly ApplicationDbContext _context;
        private readonly IWorkOrderDetailDataService _detailData;

        public WorkOrderMediaService(ApplicationDbContext context, IWorkOrderDetailDataService detailData)
        {
            _context = context;
            _detailData = detailData;
        }

        public async Task<IReadOnlyList<WorkOrderMediaFileDto>?> GetMediaAsync(int workOrderId)
        {
            if (!await _detailData.ExistsAsync(workOrderId))
                return null;

            var workOrder = await _detailData.GetWorkOrderForMediaAsync(workOrderId);
            if (workOrder == null)
                return null;

            var attachments = await _detailData.GetAttachmentsAsync(workOrderId);
            return WorkOrderMediaProjection.ProjectAll(workOrder, attachments);
        }

        public async Task EnsureCanAddMediaAsync(int workOrderId, WorkOrderMediaCategory category)
        {
            await LoadMutableWorkOrderForMediaAsync(workOrderId, category);
        }

        public async Task<string?> GetMediaStoredPathAsync(int workOrderId, int mediaId)
        {
            if (!await _detailData.ExistsAsync(workOrderId))
                return null;

            if (mediaId == -1)
            {
                var wo = await _context.workOrders.AsNoTracking().FirstOrDefaultAsync(w => w.Id == workOrderId);
                return wo?.BeforPhotoAttachment;
            }

            if (mediaId == -2)
            {
                var wo = await _context.workOrders.AsNoTracking().FirstOrDefaultAsync(w => w.Id == workOrderId);
                return wo?.AfterPhotoAttachment;
            }

            if (mediaId <= 0)
                return null;

            var attachment = await _context.workOrderAttachments
                .AsNoTracking()
                .FirstOrDefaultAsync(a => a.Id == mediaId && a.WorkorderId == workOrderId && a.IsDeleted != true);
            return attachment?.Attachments;
        }

        public async Task<WorkOrderMediaFileDto> AddMediaAsync(
            int workOrderId,
            WorkOrderMediaCategory category,
            string fileUrl,
            string? actorId)
        {
            var workOrder = await LoadMutableWorkOrderForMediaAsync(workOrderId, category);

            if (category == WorkOrderMediaCategory.Before)
            {
                workOrder.BeforPhotoAttachment = fileUrl;
                await _context.SaveChangesAsync();
                return new WorkOrderMediaFileDto
                {
                    Id = -1,
                    Category = category,
                    Url = fileUrl,
                    IsLegacy = true
                };
            }

            if (category == WorkOrderMediaCategory.After)
            {
                workOrder.AfterPhotoAttachment = fileUrl;
                await _context.SaveChangesAsync();
                return new WorkOrderMediaFileDto
                {
                    Id = -2,
                    Category = category,
                    Url = fileUrl,
                    IsLegacy = true
                };
            }

            var attachment = new WorkOrderAttachments
            {
                WorkorderId = workOrderId,
                Attachments = fileUrl,
                Category = category,
                CreatedDate = DateTime.UtcNow,
                createdby = actorId
            };

            _context.workOrderAttachments.Add(attachment);
            await _context.SaveChangesAsync();

            return new WorkOrderMediaFileDto
            {
                Id = attachment.Id,
                Category = category,
                Url = fileUrl,
                UploadedAt = attachment.CreatedDate?.ToUniversalTime().ToString("o"),
                IsLegacy = false
            };
        }

        public async Task DeleteMediaAsync(int workOrderId, int mediaId, string? actorId)
        {
            if (mediaId <= 0)
                throw new WorkOrderBoardValidationException("InvalidMedia", "Legacy media cannot be deleted via this endpoint.");

            if (!await _detailData.ExistsAsync(workOrderId))
                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");

            var workOrder = await _context.workOrders.FirstOrDefaultAsync(w => w.Id == workOrderId);
            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 attachment = await _context.workOrderAttachments
                .FirstOrDefaultAsync(a => a.Id == mediaId && a.WorkorderId == workOrderId && a.IsDeleted != true);

            if (attachment == null)
                throw new WorkOrderBoardValidationException("NotFound", "Media not found.");

            attachment.IsDeleted = true;
            attachment.DeletionTime = DateTime.UtcNow;
            attachment.DeleterUserId = actorId;
            await _context.SaveChangesAsync();
        }

        private async Task<WorkOrder> LoadMutableWorkOrderForMediaAsync(int workOrderId, WorkOrderMediaCategory category)
        {
            if (!await _detailData.ExistsAsync(workOrderId))
                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");

            var workOrder = await _context.workOrders.FirstOrDefaultAsync(w => w.Id == workOrderId);
            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.");

            if (category == WorkOrderMediaCategory.Completion)
            {
                throw new WorkOrderBoardValidationException(
                    "UseCompletionDocEndpoint",
                    "Completion documents must be uploaded via POST /api/workorders/{id}/completion-doc.");
            }

            return workOrder;
        }
    }
}