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

namespace SeaHaven.DataServices.Implementation
{
    public class WorkOrderBoardMutationDataService : IWorkOrderBoardMutationDataService
    {
        private readonly ApplicationDbContext _context;

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

        public Task<bool> VendorExistsAsync(int vendorId, CancellationToken cancellationToken)
            => _context.Vendors.AnyAsync(v => v.Id == vendorId && v.IsDeleted != true, cancellationToken);

        public async Task<int> GetMaxWorkOrderIdAsync(CancellationToken cancellationToken)
            => await _context.workOrders.MaxAsync(w => (int?)w.Id, cancellationToken) ?? 0;

        public Task<WorkOrder?> GetTrackedWorkOrderAsync(int workOrderId, CancellationToken cancellationToken)
            => _context.workOrders.FirstOrDefaultAsync(
                w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null),
                cancellationToken);

        public Task<Dispatch?> GetTrackedDispatchAsync(int dispatchId, int workOrderId, CancellationToken cancellationToken)
            => _context.Dispatches.FirstOrDefaultAsync(
                d => d.Id == dispatchId && d.WorkOrderId == workOrderId,
                cancellationToken);

        public Task<Dispatch?> GetTrackedDispatchByIdAsync(int dispatchId, CancellationToken cancellationToken)
            => _context.Dispatches.FirstOrDefaultAsync(d => d.Id == dispatchId, cancellationToken);

        public void TrackNewWorkOrder(WorkOrder workOrder)
            => _context.workOrders.Add(workOrder);

        public void TrackNewDispatch(Dispatch dispatch)
            => _context.Dispatches.Add(dispatch);

        public void TrackWorkOrderContact(int workOrderId, int contactId, string? notes)
            => _context.WorkOrderContacts.Add(new WorkOrderContacts
            {
                WorkorderId = workOrderId,
                ContactId = contactId,
                Notes = notes
            });

        public void SetExpectedWorkOrderVersion(WorkOrder workOrder, byte[] version)
            => _context.Entry(workOrder).Property(w => w.RowVersion).OriginalValue = version;

        public void SetExpectedDispatchVersion(Dispatch dispatch, byte[] version)
            => _context.Entry(dispatch).Property(d => d.RowVersion).OriginalValue = version;

        public bool HasPendingChanges()
            => _context.ChangeTracker.HasChanges();

        public async Task ExecuteTransactionalAsync(Func<CancellationToken, Task> work, CancellationToken cancellationToken)
        {
            await using var transaction = _context.Database.IsRelational()
                ? await _context.Database.BeginTransactionAsync(cancellationToken)
                : null;

            try
            {
                await work(cancellationToken);
                if (transaction is not null)
                    await transaction.CommitAsync(cancellationToken);
            }
            catch
            {
                if (transaction is not null)
                    await transaction.RollbackAsync(cancellationToken);
                throw;
            }
        }

        public async Task<BoardSaveOutcome> SaveAsync(CancellationToken cancellationToken)
        {
            try
            {
                await _context.SaveChangesAsync(cancellationToken);
                return BoardSaveOutcome.Saved;
            }
            catch (DbUpdateConcurrencyException)
            {
                _context.ChangeTracker.Clear();
                return BoardSaveOutcome.ConcurrencyConflict;
            }
        }
    }
}