ERP_Distribution/Distribution/Features/DriverProfile/DriverProfileService.cs

using Distribution.Features.Stock;
using Distribution.Features.User;
using Distribution.Infra.UoW;

namespace Distribution.Features.DriverProfile;

public class DriverProfileService(IDriverProfileRepository repo, IUnitOfWork uow, IUserRepository userRepo)
{
    public async Task<PagedResponse<DriverProfileResponse>> GetAllAsync(int page, int pageSize)
    {
        var total = await repo.GetCountAsync();
        var items = await repo.GetAllAsync(page, pageSize);
        return new PagedResponse<DriverProfileResponse>(page, pageSize, total,
            items.Select(ToResponse).ToList());
    }

    public async Task<DriverProfileResponse?> GetByIdAsync(Guid id)
    {
        var profile = await repo.GetByIdAsync(id);
        return profile is null || !profile.IsActive ? null : ToResponse(profile);
    }

    public async Task<DriverProfileResponse> CreateAsync(CreateDriverProfileRequest request, CancellationToken ct = default)
    {
        var user = await userRepo.GetByIdAsync(request.UserId);
        if (user is null)
            throw new KeyNotFoundException($"User {request.UserId} not found");

        var existing = await repo.GetByUserIdAsync(request.UserId);
        if (existing is not null && existing.IsActive)
            throw new InvalidOperationException("An active driver profile already exists for this user");

        var profile = new global::Distribution.Models.DriverProfile
        {
            FK_UserId = request.UserId,
            LicenseNumber = request.LicenseNumber,
            LicenseExpiry = request.LicenseExpiry,
            MedicalClearanceExpiry = request.MedicalClearanceExpiry
        };

        await uow.BeginAsync(ct);
        try
        {
            await repo.AddAsync(profile);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }

        var saved = await repo.GetByIdAsync(profile.Id);
        return ToResponse(saved!);
    }

    public async Task<DriverProfileResponse?> UpdateAsync(Guid id, UpdateDriverProfileRequest request, CancellationToken ct = default)
    {
        var profile = await repo.GetByIdAsync(id);
        if (profile is null || !profile.IsActive) return null;

        profile.LicenseNumber = request.LicenseNumber;
        profile.LicenseExpiry = request.LicenseExpiry;
        profile.MedicalClearanceExpiry = request.MedicalClearanceExpiry;

        await uow.BeginAsync(ct);
        try
        {
            repo.Update(profile);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }

        return ToResponse(profile);
    }

    public async Task<bool> DeactivateAsync(Guid id, CancellationToken ct = default)
    {
        var profile = await repo.GetByIdAsync(id);
        if (profile is null || !profile.IsActive) return false;

        await uow.BeginAsync(ct);
        try
        {
            repo.Deactivate(profile);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }

        return true;
    }

    public async Task<DriverComplianceConfigResponse?> GetComplianceConfigAsync()
    {
        var config = await repo.GetComplianceConfigAsync();
        return config is null ? null
            : new DriverComplianceConfigResponse(
                config.Id, config.EnforceLicenseExpiry, config.EnforceMedicalClearance,
                config.UpdatedAt, config.UpdatedBy);
    }

    public async Task<DriverComplianceConfigResponse> UpsertComplianceConfigAsync(
        UpdateDriverComplianceConfigRequest request, Guid updatedBy, CancellationToken ct = default)
    {
        var config = await repo.GetComplianceConfigAsync();

        await uow.BeginAsync(ct);
        try
        {
            if (config is null)
            {
                config = new global::Distribution.Models.DriverComplianceConfig
                {
                    EnforceLicenseExpiry = request.EnforceLicenseExpiry,
                    EnforceMedicalClearance = request.EnforceMedicalClearance,
                    UpdatedBy = updatedBy,
                    UpdatedAt = DateTime.Now
                };
                await repo.AddComplianceConfigAsync(config);
            }
            else
            {
                config.EnforceLicenseExpiry = request.EnforceLicenseExpiry;
                config.EnforceMedicalClearance = request.EnforceMedicalClearance;
                config.UpdatedBy = updatedBy;
                config.UpdatedAt = DateTime.Now;
                repo.UpdateComplianceConfig(config);
            }

            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }

        return new DriverComplianceConfigResponse(
            config.Id, config.EnforceLicenseExpiry, config.EnforceMedicalClearance,
            config.UpdatedAt, config.UpdatedBy);
    }

    private static DriverProfileResponse ToResponse(global::Distribution.Models.DriverProfile p) =>
        new(p.Id, p.FK_UserId, p.User?.FullName ?? string.Empty,
            p.LicenseNumber, p.LicenseExpiry, p.MedicalClearanceExpiry,
            p.IsActive, p.CreatedAt);
}