shoc-backend/SeaHaven.DataServices/Implementation/SyncDataService.cs

using Data.SeaHavenIndustries;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation
{
    public class SyncDataService : ISyncDataService
    {
        private readonly ApplicationDbContext _context;

        public SyncDataService(ApplicationDbContext context)
        {
            _context = context;
        }

        public async Task<string?> GetLastInternalWONumberAsync(CancellationToken cancellationToken)
        {
            return await _context.workOrders
                .Where(w => w.InternalWONumber != null && w.InternalWONumber != "")
                .OrderByDescending(w => w.InternalWONumber)
                .Select(w => w.InternalWONumber)
                .FirstOrDefaultAsync(cancellationToken);
        }

        public async Task<WorkOrder?> GetWorkOrderByExternalIdAsync(string externalId, CancellationToken cancellationToken)
        {
            return await _context.workOrders
                .FirstOrDefaultAsync(w => w.ExternalWorkOrderId == externalId, cancellationToken);
        }

        public void EnqueueWorkOrder(WorkOrder workOrder)
        {
            _context.workOrders.Add(workOrder);
        }

        public void EnqueueComment(Comments comment)
        {
            _context.Comments.Add(comment);
        }

        public async Task SaveChangesAsync(CancellationToken cancellationToken)
        {
            await _context.SaveChangesAsync(cancellationToken);
        }

        public async Task<int?> ResolveLocationAsync(string? siteCode, string? building, string? address, CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(siteCode) && string.IsNullOrWhiteSpace(building))
                return null;

            var matchCode = siteCode ?? building;
            var existing = await _context.Locations
                .FirstOrDefaultAsync(l => l.Name == matchCode || l.Title == matchCode, cancellationToken);

            if (existing != null)
                return existing.Id;

            var location = new Locations
            {
                Name = matchCode,
                Title = building,
                Address1 = address,
                Status = "Active"
            };

            _context.Locations.Add(location);
            await _context.SaveChangesAsync(cancellationToken);

            return location.Id;
        }

        public async Task<int> GetLocationCountAsync(CancellationToken cancellationToken)
        {
            return await _context.Locations.CountAsync(cancellationToken);
        }

        public async Task<bool> CommentExistsByExternalIdAsync(string externalId, CancellationToken cancellationToken)
        {
            return await _context.Comments
                .AnyAsync(c => c.ExternalCommentId == externalId, cancellationToken);
        }

        public async Task<WorkOrder?> GetWorkOrderByInternalNumberAsync(string internalNumber, CancellationToken cancellationToken)
        {
            return await _context.workOrders
                .FirstOrDefaultAsync(w => w.InternalWONumber == internalNumber, cancellationToken);
        }

        public async Task<Dispatch?> GetDispatchByNumberAndWorkOrderIdAsync(string dispatchNumber, int workOrderId, CancellationToken cancellationToken)
        {
            return await _context.Dispatches
                .FirstOrDefaultAsync(d => d.DispatchNumber == dispatchNumber && d.WorkOrderId == workOrderId, cancellationToken);
        }

        public async Task<List<WorkOrder>> GetWorkOrdersMissingInternalNumberAsync(CancellationToken cancellationToken)
        {
            return await _context.workOrders
                .Where(w => w.InternalWONumber == null || w.InternalWONumber == "")
                .OrderBy(w => w.Id)
                .ToListAsync(cancellationToken);
        }

        public async Task<List<Dispatch>> GetDispatchesMissingNumberAsync(CancellationToken cancellationToken)
        {
            return await _context.Dispatches
                .Where(d => d.DispatchNumber == null || d.DispatchNumber == "")
                .OrderBy(d => d.Id)
                .ToListAsync(cancellationToken);
        }

        public async Task<int> ExecuteBackfillCommentTypesAsync(CancellationToken cancellationToken)
        {
            return await _context.Database.ExecuteSqlRawAsync(
                "UPDATE Comments SET CommentType = 'customer' WHERE ExternalCommentId IS NOT NULL AND (CommentType IS NULL OR CommentType = '')",
                cancellationToken);
        }

        public async Task<string?> GetLastDispatchNumberAsync(CancellationToken cancellationToken)
        {
            return await _context.Dispatches
                .Where(d => d.DispatchNumber != null && d.DispatchNumber != "")
                .OrderByDescending(d => d.DispatchNumber)
                .Select(d => d.DispatchNumber)
                .FirstOrDefaultAsync(cancellationToken);
        }
    }
}