shoc-backend/SeaHaven.DataServices/Interfaces/IWorkOrderDataService.cs

using Data.SeaHavenIndustries;
using SeaHaven.DataServices.Models;

namespace SeaHaven.DataServices.Interfaces
{
    public interface IWorkOrderDataService
    {
        // Query operations
        Task<WorkOrder?> GetByIdAsync(int id);
        Task<WorkOrder?> GetByIdWithDetailsAsync(int id);
        Task<WorkOrder?> GetByInternalNumberAsync(string internalNumber);
        Task<IEnumerable<WorkOrder>> GetAllAsync();
        Task<IEnumerable<WorkOrder>> GetByLocationIdAsync(int locationId);
        Task<IEnumerable<WorkOrder>> GetByAssigneeAsync(string assigneeId);
        Task<IEnumerable<WorkOrder>> GetByStatusAsync(string status);
        Task<IEnumerable<WorkOrder>> GetByPriorityAsync(string priority);

        // Paged results
        Task<(IEnumerable<WorkOrder> Items, int TotalCount)> GetPagedAsync(
            int page,
            int pageSize,
            string? search = null,
            string? status = null,
            string? priority = null);

        // Paged list with detailed information (for GetWorkOrderList endpoint)
        Task<(IEnumerable<WorkOrderListItemReadModel> Items, int TotalCount)> GetWorkOrderListPagedAsync(
            int page,
            int pageSize,
            string? search = null,
            string? status = null,
            string? assignee = null,
            int? locationId = null,
            string? sortBy = "lastUpdated",
            string? sortDir = "desc",
            int? accountId = null);

        // Command operations
        Task<WorkOrder> AddAsync(WorkOrder workOrder);
        Task UpdateAsync(WorkOrder workOrder);
        Task DeleteAsync(int id);
        // Runs a read-modify-write on one work order under the shared per-work-order gate,
        // transaction and row lock (WorkOrderMutationLock).
        Task<T> ExecuteWorkOrderMutationAsync<T>(
            int workOrderId,
            Func<CancellationToken, Task<T>> work,
            CancellationToken cancellationToken);

        // Related entities - Read
        Task<IEnumerable<WorkOrderContacts>> GetWorkOrderContactsAsync(int workOrderId);
        Task<IEnumerable<WorkOrderCategories>> GetWorkOrderCategoriesAsync(int workOrderId);
        Task<IEnumerable<WorkOrderAttachments>> GetWorkOrderAttachmentsAsync(int workOrderId);
        Task<IEnumerable<Comments>> GetWorkOrderCommentsAsync(int workOrderId);
        Task<IEnumerable<WorkOrderAuditLog>> GetWorkOrderAuditLogsAsync(int workOrderId);

        // Related entities - Write
        Task AddWorkOrderContactsAsync(int workOrderId, IEnumerable<int> contactIds);
        Task AddWorkOrderCategoriesAsync(int workOrderId, IEnumerable<int> categoryIds);
        Task AddWorkOrderAttachmentAsync(WorkOrderAttachments attachment);
        /// <summary>Adds every attachment in one commit (no per-row round trip).</summary>
        Task AddWorkOrderAttachmentsAsync(IReadOnlyCollection<WorkOrderAttachments> attachments);
        Task AddAuditLogAsync(WorkOrderAuditLog auditLog);
        Task AddAuditLogsAsync(IReadOnlyCollection<WorkOrderAuditLog> auditLogs);

        // Related entities - Delete
        Task DeleteWorkOrderContactsAsync(int workOrderId);
        Task DeleteWorkOrderCategoriesAsync(int workOrderId);
        Task DeleteWorkOrderAttachmentsAsync(int workOrderId);

        // Validation
        Task<bool> ExistsAsync(int id);
        Task<bool> InternalNumberExistsAsync(string internalNumber, int? excludeId = null);

        // Internal number generation
        Task<string> GenerateNextInternalWONumberAsync();

        // Statistics
        Task<int> CountAsync();
        Task<int> CountByStatusAsync(string status);
        Task<int> CountByPriorityAsync(string priority);
        Task<int> CountByLocationAsync(int locationId);
        Task<IEnumerable<WorkOrder>> GetAllWithDetailsAsync(int? accountId = null);

        // Batched lookup: server-filters the distinct requested ids, excludes templates,
        // eagerly loads the location detail, deduplicates, and returns results in input order.
        Task<IReadOnlyList<WorkOrder>> GetByRequestedIdsWithDetailsAsync(
            IReadOnlyCollection<int> ids,
            CancellationToken cancellationToken);

        // Complex read models
        Task<WorkOrderDetailReadModel?> GetWorkOrderDetailAsync(int id, int? accountId = null);
        Task<List<WorkOrder>> GetNonTemplateWorkOrdersWithLocationsAsync(int? accountId = null);
    }
}