Offline Negotiation Cycle

public class NegotiationService
{
    private readonly IBidRepository _bidRepository;
    private readonly INegotiationRepository _negotiationRepository;
    private readonly INegotiationItemRepository _negotiationItemRepository;
    private readonly IApprovalRepository _approvalRepository;
    private readonly INotificationService _notificationService;

    /// <summary>
    /// Initiates a new negotiation round for a given bid.
    /// Automatically increments round number from last round.
    /// </summary>
    public async Task<NegotiationRound> InitiateNegotiation(int bidId, string mode, int negotiatedBy)
    {
        var bid = await _bidRepository.GetById(bidId);
        var lastRound = await _negotiationRepository.GetLastRound(bidId);

        var round = new BidNegotiation
        {
            BidId = bidId,
            RoundNumber = (lastRound?.RoundNumber ?? 0) + 1,
            NegotiationMode = mode,
            NegotiatedBy = negotiatedBy,
            OriginalAmount = bid.TotalAmount,
            Status = NegotiationStatus.Initiated,
            NegotiatedAt = DateTime.UtcNow
        };

        await _negotiationRepository.Add(round);
        await _notificationService.NotifyVendor(bid.VendorId, "Negotiation initiated");
        return round;
    }

    /// <summary>
    /// Records a vendor's counter-offer with revised amounts and line items.
    /// </summary>
    public async Task RecordCounterOffer(int negotiationId, decimal counterAmount,
        string revisedPaymentTerms, string revisedDeliveryTerms, List<NegotiationItemDto> items)
    {
        var negotiation = await _negotiationRepository.GetById(negotiationId);
        negotiation.CounterAmount = counterAmount;
        negotiation.RevisedPaymentTerms = revisedPaymentTerms;
        negotiation.RevisedDeliveryTerms = revisedDeliveryTerms;
        negotiation.VendorResponse = "Counter-offer submitted";
        negotiation.VendorResponseDate = DateTime.UtcNow;
        negotiation.Status = NegotiationStatus.CounterOffered;

        foreach (var item in items)
        {
            await _negotiationItemRepository.Add(new NegotiationItem
            {
                NegotiationId = negotiationId,
                RfqItemId = item.RfqItemId,
                OriginalUnitPrice = item.OriginalUnitPrice,
                NegotiatedUnitPrice = item.NegotiatedUnitPrice,
                NegotiatedQuantity = item.NegotiatedQuantity,
                NegotiatedDeliveryDays = item.NegotiatedDeliveryDays
            });
        }

        await _negotiationRepository.Update(negotiation);
    }

    /// <summary>
    /// Submits an accepted negotiation for multi-level approval.
    /// Only accepted negotiations can proceed to approval workflow.
    /// </summary>
    public async Task<bool> SubmitForApproval(int negotiationId, List<int> approverIds)
    {
        var negotiation = await _negotiationRepository.GetById(negotiationId);
        if (negotiation.Status != NegotiationStatus.Accepted)
            throw new InvalidOperationException("Only accepted negotiations can be submitted for approval");

        for (int level = 1; level <= approverIds.Count; level++)
        {
            await _approvalRepository.Add(new NegotiationApproval
            {
                NegotiationId = negotiationId,
                ApprovalLevel = level,
                ApproverId = approverIds[level - 1],
                Status = level == 1 ? ApprovalStatus.Pending : ApprovalStatus.Pending
            });
        }

        await _notificationService.NotifyApprover(approverIds[0], "Negotiation approval pending");
        return true;
    }
}