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

namespace SeaHaven.DataServices.Implementation
{
    public class WorkOrderDetailDataService : IWorkOrderDetailDataService
    {
        private readonly ApplicationDbContext _context;

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

        public Task<bool> ExistsAsync(
            int workOrderId,
            CancellationToken cancellationToken = default,
            int? accountId = null)
        {
            var query = WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking());
            if (accountId.HasValue)
                query = WorkOrderBoardQueryFilters.ApplyAccountScope(query, accountId.Value);

            return query.AnyAsync(w => w.Id == workOrderId, cancellationToken);
        }

        public async Task<WorkOrderDetailExtendedFields?> GetExtendedFieldsAsync(int workOrderId)
        {
            return await WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking())
                .Where(w => w.Id == workOrderId)
                .Select(w => new WorkOrderDetailExtendedFields(
                    w.Description,
                    w.Trade,
                    w.Problem,
                    w.SubTrade,
                    w.OriginalWeek,
                    w.OriginalDate,
                    w.CompletedDate,
                    w.SignOffName,
                    w.SignOffAttachment,
                    w.SignOffSignature,
                    w.ExtraServices,
                    w.ServiceNotes,
                    w.PrimaryDispatch != null && w.PrimaryDispatch.VendorNotes != null
                        ? w.PrimaryDispatch.VendorNotes
                        : w.VendorNotes))
                .FirstOrDefaultAsync();
        }

        public async Task<IReadOnlyList<Comments>> GetCommentsAsync(int workOrderId)
        {
            return await _context.Comments
                .AsNoTracking()
                .Where(c => c.WorkerOrderId == workOrderId && c.IsDeleted != true)
                .OrderByDescending(c => c.CreatedDate)
                .ToListAsync();
        }

        public async Task<IReadOnlyList<WorkOrderAuditLog>> GetAuditLogsAsync(int workOrderId, int? limit = null)
        {
            var query = _context.WorkOrderAuditLogs
                .AsNoTracking()
                .Where(a => a.WorkOrderId == workOrderId)
                .OrderByDescending(a => a.CreatedAt);

            if (limit.HasValue)
                return await query.Take(limit.Value).ToListAsync();

            return await query.ToListAsync();
        }

        public async Task<IReadOnlyList<WorkOrderAttachments>> GetAttachmentsAsync(
            int workOrderId,
            CancellationToken cancellationToken = default)
        {
            return await _context.workOrderAttachments
                .AsNoTracking()
                .Where(a => a.WorkorderId == workOrderId && a.IsDeleted != true)
                .OrderByDescending(a => a.CreatedDate)
                .ToListAsync(cancellationToken);
        }

        public async Task<IReadOnlyList<DispatchSignoffRow>> GetDispatchSignoffsAsync(int workOrderId)
        {
            return await _context.DispatchSignoffs
                .AsNoTracking()
                .Where(s => s.Dispatch != null && s.Dispatch.WorkOrderId == workOrderId && s.IsDeleted != true)
                .OrderByDescending(s => s.SignedAt)
                .Select(s => new DispatchSignoffRow(
                    s.DispatchId,
                    s.SignoffType,
                    s.Name,
                    s.SignedAt))
                .ToListAsync();
        }

        public async Task<WorkOrder?> GetWorkOrderForMediaAsync(
            int workOrderId,
            CancellationToken cancellationToken = default,
            int? accountId = null)
        {
            var query = WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking());
            if (accountId.HasValue)
                query = WorkOrderBoardQueryFilters.ApplyAccountScope(query, accountId.Value);

            return await query.FirstOrDefaultAsync(w => w.Id == workOrderId, cancellationToken);
        }
    }
}