#define MS_CLASS "RTC::BWE::LossBasedController"
// #define MS_LOG_DEV_LEVEL 3

#include "RTC/BWE/LossBasedController.hpp"
#include "Logger.hpp"
#include "RTC/BWE/Utils.hpp"
#include <cmath>
#include <limits>

namespace RTC
{
	namespace BWE
	{
		/* Static. */

		// How long the first hold lasts, each following one lasting longer.
		static constexpr int64_t InitHoldDurationUs{ 300 * 1000 };
		// How long a hold may last no matter how many have piled up.
		static constexpr int64_t MaxHoldDurationUs{ 60 * 1000 * 1000 };
		// Lowest bitrate any congestion controller may produce.
		static constexpr int64_t CongestionControllerMinBitrate{ 5000 };

		/**
		 * Loss to expect from a link described by the given pair of values while
		 * sending at the given rate: its inherent loss, plus the share of the traffic
		 * that doesn't fit while sending above its capacity.
		 */
		static double getLossProbability(double inherentLoss, int64_t lossLimitedBitrate, int64_t sendingRate)
		{
			MS_TRACE();

			// NOTE: Clamped rather than asserted because a candidate refined by
			// Newton's method can land outside before being brought back.
			inherentLoss = std::clamp(inherentLoss, 0.0, 1.0);

			double lossProbability{ inherentLoss };

			if (sendingRate > 0 && lossLimitedBitrate > 0 && sendingRate > lossLimitedBitrate)
			{
				lossProbability += (1 - inherentLoss) *
				                   static_cast<double>(sendingRate - lossLimitedBitrate) /
				                   static_cast<double>(sendingRate);
			}

			// Leave room on both ends, since the likelihood takes the logarithm of
			// this value and of its complement.
			return std::clamp(lossProbability, 1.0e-6, 1.0 - 1.0e-6);
		}

		/**
		 * Size in kilobytes, which is the unit the likelihood is computed in so that
		 * its terms stay in a sane range.
		 */
		static double toKiloBytes(int64_t bytes)
		{
			MS_TRACE();

			return static_cast<double>(bytes) / 1000.0;
		}

		/* Instance methods. */

		LossBasedController::LossBasedController() : LossBasedController(LossBasedControllerOptions{})
		{
			MS_TRACE();
		}

		LossBasedController::LossBasedController(LossBasedControllerOptions options)
		  : options(std::move(options))
		{
			MS_TRACE();

			// NOTE: The window is what every observation is indexed modulo, so an
			// empty one would divide by zero. These options are ours, so this can only
			// fail out of a programming error.
			MS_ASSERT(this->options.observationWindowSize > 0, "observation window size must be positive");

			this->currentBestEstimate.inherentLoss = this->options.initialInherentLossEstimate;

			this->observations.resize(this->options.observationWindowSize);
			this->temporalWeights.resize(this->options.observationWindowSize);
			this->immediateUpperBoundTemporalWeights.resize(this->options.observationWindowSize);

			CalculateTemporalWeights();

			this->lastHoldInfo.durationUs = InitHoldDurationUs;
		}

		bool LossBasedController::IsReady() const
		{
			MS_TRACE();

			return this->currentBestEstimate.lossLimitedBitrate > 0 &&
			       this->numObservations >= this->options.minNumObservations;
		}

		bool LossBasedController::IsReadyToUseInStartPhase() const
		{
			MS_TRACE();

			return IsReady() && this->options.useInStartPhase;
		}

		void LossBasedController::Reset()
		{
			MS_TRACE();

			// Everything the constructor leaves behind, since what was observed
			// describes a link that is not the one being used anymore. The temporal
			// weights are left alone because they only depend on the options.
			this->observations.assign(this->options.observationWindowSize, Observation{});
			this->partialObservation = {};

			this->currentBestEstimate              = {};
			this->currentBestEstimate.inherentLoss = this->options.initialInherentLossEstimate;

			this->lastHoldInfo            = {};
			this->lastHoldInfo.durationUs = InitHoldDurationUs;

			this->result          = {};
			this->numObservations = 0;
			this->lastSendTimeOfLatestObservationUs.reset();
			this->averageReportedLossRatio = 0.0;
			this->acknowledgedBitrate      = Types::BitrateInfinite;
			this->delayBasedEstimate       = Types::BitrateInfinite;
			this->minBitrate               = 0;
			this->maxBitrate               = Types::BitrateInfinite;
			this->immediateUpperBoundBitrate.reset();
			this->immediateLowerBoundBitrate.reset();
			this->bitrateLimitInCurrentWindow = Types::BitrateInfinite;
			this->recoveringAfterLossAtUs.reset();
			this->lastBitrateReducedAtUs.reset();
		}

		LossBasedController::Result LossBasedController::GetResult() const
		{
			MS_TRACE();

			if (!IsReady())
			{
				return { .bitrate = this->delayBasedEstimate, .state = State::DELAY_BASED_ESTIMATE };
			}

			return this->result;
		}

		void LossBasedController::SetAcknowledgedBitrate(int64_t acknowledgedBitrate)
		{
			MS_TRACE();

			this->acknowledgedBitrate = acknowledgedBitrate;

			CalculateImmediateLowerBoundBitrate();
		}

		void LossBasedController::SetBitrateLimits(int64_t minBitrate, int64_t maxBitrate)
		{
			MS_TRACE();

			this->minBitrate = minBitrate;
			this->maxBitrate = maxBitrate;

			CalculateImmediateLowerBoundBitrate();
		}

		void LossBasedController::SetBitrateEstimate(int64_t bitrate)
		{
			MS_TRACE();

			this->currentBestEstimate.lossLimitedBitrate = bitrate;
			this->result = { .bitrate = bitrate, .state = State::DELAY_BASED_ESTIMATE };
		}

		void LossBasedController::UpdateBitrateEstimate(
		  const std::vector<Types::PacketResult>& packetResults, int64_t delayBasedEstimate, bool inAlr)
		{
			MS_TRACE();

			this->delayBasedEstimate = delayBasedEstimate;

			if (!PushBackObservation(packetResults) || !this->lastSendTimeOfLatestObservationUs.has_value())
			{
				return;
			}

			const int64_t lastSendTimeUs = this->lastSendTimeOfLatestObservationUs.value();

			// Nothing has been estimated yet, so the delay based path is the only
			// thing that can say where to start from.
			if (this->currentBestEstimate.lossLimitedBitrate == 0)
			{
				if (delayBasedEstimate == Types::BitrateInfinite)
				{
					MS_WARN_TAG(bwe, "no delay based estimate to start the loss based one from");

					return;
				}

				this->currentBestEstimate.lossLimitedBitrate = delayBasedEstimate;
				this->result = { .bitrate = delayBasedEstimate, .state = State::DELAY_BASED_ESTIMATE };
			}

			// Take the candidate whose pair of values makes the observed losses most
			// likely, preferring the higher bitrate when two are equally likely.
			ChannelParameters bestCandidate = this->currentBestEstimate;
			double maxObjective{ std::numeric_limits<double>::lowest() };

			for (ChannelParameters candidate : GetCandidates(inAlr))
			{
				ApplyNewtonsMethod(candidate);

				const double candidateObjective = GetObjective(candidate);

				if (
				  candidateObjective > maxObjective ||
				  (candidateObjective == maxObjective &&
					 candidate.lossLimitedBitrate > bestCandidate.lossLimitedBitrate))
				{
					maxObjective  = candidateObjective;
					bestCandidate = candidate;
				}
			}

			if (bestCandidate.lossLimitedBitrate < this->currentBestEstimate.lossLimitedBitrate)
			{
				this->lastBitrateReducedAtUs = lastSendTimeUs;
			}

			// Don't increase the estimate while the loss observed is worse than the
			// one the chosen candidate says the link has by itself, since then the
			// excess is ours to fix.
			if (
			  this->averageReportedLossRatio > bestCandidate.inherentLoss &&
			  this->options.notIncreaseIfInherentLossLessThanAverageLoss &&
			  this->currentBestEstimate.lossLimitedBitrate < bestCandidate.lossLimitedBitrate)
			{
				bestCandidate.lossLimitedBitrate = this->currentBestEstimate.lossLimitedBitrate;
			}

			if (IsInLossLimitedState())
			{
				// Right after a decrease the estimate may not grow past what that
				// decrease allowed, so that it doesn't jump straight back to the bitrate
				// that caused the loss.
				if (
				  this->recoveringAfterLossAtUs.has_value() &&
				  this->recoveringAfterLossAtUs.value() + this->options.delayedIncreaseWindowUs >
				    lastSendTimeUs &&
				  bestCandidate.lossLimitedBitrate > this->bitrateLimitInCurrentWindow)
				{
					bestCandidate.lossLimitedBitrate = this->bitrateLimitInCurrentWindow;
				}

				const bool increasingWhenLossLimited = IsEstimateIncreasingWhenLossLimited(
				  this->currentBestEstimate.lossLimitedBitrate, bestCandidate.lossLimitedBitrate);

				// While loss limited, growing beyond what the link is known to be
				// delivering is a guess, so it's bounded by the acknowledged bitrate.
				if (increasingWhenLossLimited && this->acknowledgedBitrate != Types::BitrateInfinite)
				{
					double rampupFactor{ this->options.bitrateRampupUpperBoundFactor };

					if (
					  this->lastHoldInfo.bitrate != Types::BitrateInfinite &&
					  this->acknowledgedBitrate <
					    this->options.bitrateRampupHoldThreshold * this->lastHoldInfo.bitrate)
					{
						rampupFactor = this->options.bitrateRampupUpperBoundFactorInHold;
					}

					bestCandidate.lossLimitedBitrate = std::max(
					  this->currentBestEstimate.lossLimitedBitrate,
					  std::min(
					    bestCandidate.lossLimitedBitrate,
					    Utils::ApplyBitrateFactor(this->acknowledgedBitrate, rampupFactor)));

					// Growing by a single bit is what lets the state stop being
					// decreasing. Without it, a bound that leaves the estimate untouched
					// keeps it decreasing for good.
					if (
					  this->result.state == State::DECREASING &&
					  bestCandidate.lossLimitedBitrate == this->currentBestEstimate.lossLimitedBitrate)
					{
						bestCandidate.lossLimitedBitrate =
						  Utils::AddBitrates(this->currentBestEstimate.lossLimitedBitrate, 1);
					}
				}
			}

			const int64_t boundedBitrate = std::max(
			  GetImmediateLowerBoundBitrate(),
			  std::min(
			    { bestCandidate.lossLimitedBitrate,
					  GetImmediateUpperBoundBitrate(),
					  this->delayBasedEstimate }));

			// A bitrate that had to be brought down to its bounds is not an estimate
			// of the link anymore, so the pair of values is not kept as such.
			if (this->options.boundBestCandidate && boundedBitrate < bestCandidate.lossLimitedBitrate)
			{
				this->currentBestEstimate.lossLimitedBitrate = boundedBitrate;
				this->currentBestEstimate.inherentLoss       = 0;
			}
			else
			{
				this->currentBestEstimate = bestCandidate;

				// A link is never worth describing as delivering less than what it is
				// known to be delivering, unless that bound has been turned off.
				if (this->options.lowerBoundByAckedRateFactor > 0.0)
				{
					this->currentBestEstimate.lossLimitedBitrate =
					  std::max(this->currentBestEstimate.lossLimitedBitrate, GetImmediateLowerBoundBitrate());
				}
			}

			// While holding, the estimate may not grow above the bitrate being held,
			// which is the whole point of holding.
			if (
			  this->result.state == State::DECREASING && this->lastHoldInfo.atUs > lastSendTimeUs &&
			  boundedBitrate < this->delayBasedEstimate)
			{
				// A link is never worth holding below what it is known to be
				// delivering, unless that bound has been turned off.
				if (this->options.lowerBoundByAckedRateFactor > 0.0)
				{
					this->lastHoldInfo.bitrate =
					  std::max(GetImmediateLowerBoundBitrate(), this->lastHoldInfo.bitrate);
				}

				this->result.bitrate = std::min(this->lastHoldInfo.bitrate, boundedBitrate);

				return;
			}

			if (
			  IsEstimateIncreasingWhenLossLimited(this->result.bitrate, boundedBitrate) &&
			  boundedBitrate < this->delayBasedEstimate && boundedBitrate < this->maxBitrate)
			{
				this->result.state = State::INCREASING;
			}
			else if (boundedBitrate < this->delayBasedEstimate && boundedBitrate < this->maxBitrate)
			{
				// A factor of zero means that no hold is ever entered, since each hold
				// would last no time at all.
				if (this->result.state != State::DECREASING && this->options.holdDurationFactor > 0.0)
				{
					MS_DEBUG_DEV(
					  "switching to hold [bitrate:%" PRIi64 ", durationMs:%" PRIi64 ", averageLoss:%f]",
					  boundedBitrate,
					  this->lastHoldInfo.durationUs / 1000,
					  this->averageReportedLossRatio);

					this->lastHoldInfo = { .atUs       = lastSendTimeUs + this->lastHoldInfo.durationUs,
					                       .durationUs = std::min<int64_t>(
						                       MaxHoldDurationUs,
						                       std::llround(
						                         static_cast<double>(this->lastHoldInfo.durationUs) *
						                         this->options.holdDurationFactor)),
					                       .bitrate = boundedBitrate };
				}

				this->result.state = State::DECREASING;
			}
			else
			{
				// The delay based path is what limits us, so any hold that was in place
				// would only keep the estimate low for no reason.
				this->lastHoldInfo = { .atUs       = 0,
				                       .durationUs = InitHoldDurationUs,
				                       .bitrate    = Types::BitrateInfinite };

				this->result.state = State::DELAY_BASED_ESTIMATE;
			}

			this->result.bitrate = boundedBitrate;

			// Open a new window in which the estimate is not allowed to grow freely,
			// so that a link that keeps losing packets is approached gradually.
			if (
			  IsInLossLimitedState() &&
			  (!this->recoveringAfterLossAtUs.has_value() ||
				 this->recoveringAfterLossAtUs.value() + this->options.delayedIncreaseWindowUs <
				   lastSendTimeUs))
			{
				this->bitrateLimitInCurrentWindow = std::max<int64_t>(
				  CongestionControllerMinBitrate,
				  Utils::ApplyBitrateFactor(
				    this->currentBestEstimate.lossLimitedBitrate, this->options.maxIncreaseFactor));

				this->recoveringAfterLossAtUs = lastSendTimeUs;
			}
		}

		bool LossBasedController::PushBackObservation(const std::vector<Types::PacketResult>& packetResults)
		{
			MS_TRACE();

			if (packetResults.empty())
			{
				return false;
			}

			int64_t firstSendTimeUs{ Types::TimeUsInfinite };
			int64_t lastSendTimeUs{ 0 };
			bool anySendTime{ false };

			for (const auto& packetResult : packetResults)
			{
				const auto sendTimeUs = packetResult.sentPacket.sendTimeUs;

				// A packet with no send time belongs to no span of send times, and its
				// bytes cannot be counted either: the duration of the observation comes
				// from the instants of the other packets, so adding its size would
				// inflate the sending rate attributed to them.
				if (sendTimeUs == Types::TimeUsInfinite)
				{
					continue;
				}

				if (packetResult.IsReceived())
				{
					this->partialObservation.lostPackets.erase(packetResult.sentPacket.sequenceNumber);
				}
				else
				{
					this->partialObservation.lostPackets.emplace(
					  packetResult.sentPacket.sequenceNumber,
					  static_cast<int64_t>(packetResult.sentPacket.size));
				}

				this->partialObservation.numPackets += 1;
				this->partialObservation.sizeBytes += static_cast<int64_t>(packetResult.sentPacket.size);

				firstSendTimeUs = std::min(firstSendTimeUs, sendTimeUs);
				lastSendTimeUs  = std::max(lastSendTimeUs, sendTimeUs);
				anySendTime     = true;
			}

			if (!anySendTime)
			{
				return false;
			}

			// This is the first feedback ever received.
			if (!this->lastSendTimeOfLatestObservationUs.has_value())
			{
				this->lastSendTimeOfLatestObservationUs = firstSendTimeUs;
			}

			const int64_t observationDurationUs =
			  lastSendTimeUs - this->lastSendTimeOfLatestObservationUs.value();

			// Too short a span to tell anything.
			if (observationDurationUs <= 0 || observationDurationUs < this->options.observationDurationLowerBoundUs)
			{
				return false;
			}

			this->lastSendTimeOfLatestObservationUs = lastSendTimeUs;

			int64_t lostSizeBytes{ 0 };

			for (const auto& kv : this->partialObservation.lostPackets)
			{
				lostSizeBytes += kv.second;
			}

			Observation observation;

			observation.numPackets = this->partialObservation.numPackets;
			observation.numLostPackets = static_cast<int64_t>(this->partialObservation.lostPackets.size());
			observation.numReceivedPackets = observation.numPackets - observation.numLostPackets;
			observation.sizeBytes          = this->partialObservation.sizeBytes;
			observation.lostSizeBytes      = lostSizeBytes;
			observation.sendingRate =
			  GetSendingRate((this->partialObservation.sizeBytes * 8 * 1000000) / observationDurationUs);
			observation.id = this->numObservations++;

			this->observations[observation.id % this->options.observationWindowSize] = observation;

			this->partialObservation = PartialObservation();

			UpdateAverageReportedLossRatio();
			CalculateImmediateUpperBoundBitrate();

			return true;
		}

		std::vector<LossBasedController::ChannelParameters> LossBasedController::GetCandidates(bool inAlr) const
		{
			MS_TRACE();

			std::vector<int64_t> bitrates;

			// The factors plus the acknowledged bitrate, the delay based estimate and
			// the bound that the observed loss puts on the estimate.
			bitrates.reserve(this->options.candidateFactors.size() + 3);

			for (const double candidateFactor : this->options.candidateFactors)
			{
				bitrates.push_back(
				  Utils::ApplyBitrateFactor(this->currentBestEstimate.lossLimitedBitrate, candidateFactor));
			}

			// While not sending enough to fill the link, what it delivers says nothing
			// about what it could deliver, so it's no candidate.
			if (
			  this->acknowledgedBitrate != Types::BitrateInfinite &&
			  this->options.appendAcknowledgedRateCandidate &&
			  !(this->options.notUseAckedRateInAlr && inAlr))
			{
				bitrates.push_back(
				  Utils::ApplyBitrateFactor(
				    this->acknowledgedBitrate, this->options.bitrateBackoffLowerBoundFactor));
			}

			if (
			  this->delayBasedEstimate != Types::BitrateInfinite &&
			  this->options.appendDelayBasedEstimateCandidate &&
			  this->delayBasedEstimate > this->currentBestEstimate.lossLimitedBitrate)
			{
				bitrates.push_back(this->delayBasedEstimate);
			}

			// Coming all the way down to that bound in one step rather than gradually
			// only makes sense while not filling the link, since then the loss is not
			// ours to fix by sending less.
			if (
			  inAlr && this->options.appendUpperBoundCandidateInAlr &&
			  this->currentBestEstimate.lossLimitedBitrate > GetImmediateUpperBoundBitrate())
			{
				bitrates.push_back(GetImmediateUpperBoundBitrate());
			}

			const int64_t candidateBitrateUpperBound = GetCandidateBitrateUpperBound();

			std::vector<ChannelParameters> candidates;

			candidates.reserve(bitrates.size());

			for (const int64_t bitrate : bitrates)
			{
				ChannelParameters candidate = this->currentBestEstimate;

				candidate.lossLimitedBitrate = std::min(
				  bitrate,
				  std::max(this->currentBestEstimate.lossLimitedBitrate, candidateBitrateUpperBound));
				candidate.inherentLoss = GetFeasibleInherentLoss(candidate);

				candidates.push_back(candidate);
			}

			return candidates;
		}

		int64_t LossBasedController::GetCandidateBitrateUpperBound() const
		{
			MS_TRACE();

			int64_t candidateBitrateUpperBound{ this->maxBitrate };

			if (IsInLossLimitedState() && this->bitrateLimitInCurrentWindow != Types::BitrateInfinite)
			{
				candidateBitrateUpperBound = this->bitrateLimitInCurrentWindow;
			}

			if (this->acknowledgedBitrate == Types::BitrateInfinite)
			{
				return candidateBitrateUpperBound;
			}

			// The longer it's been since the estimate was last reduced, the more it is
			// allowed to grow beyond its usual bound.
			if (this->options.rampupAccelerationMaxFactor > 0.0)
			{
				// Never having been reduced counts as the longest time possible, which
				// is what gives the fullest acceleration.
				const int64_t sinceBitrateReducedUs =
				  this->lastBitrateReducedAtUs.has_value() &&
				      this->lastSendTimeOfLatestObservationUs.has_value()
				    ? std::min(
				        this->options.rampupAccelerationMaxoutTimeUs,
				        std::max<int64_t>(
				          this->lastSendTimeOfLatestObservationUs.value() -
				            this->lastBitrateReducedAtUs.value(),
				          0))
				    : this->options.rampupAccelerationMaxoutTimeUs;
				const double rampupAcceleration =
				  this->options.rampupAccelerationMaxFactor * static_cast<double>(sinceBitrateReducedUs) /
				  static_cast<double>(this->options.rampupAccelerationMaxoutTimeUs);

				candidateBitrateUpperBound = Utils::AddBitrates(
				  candidateBitrateUpperBound,
				  Utils::ApplyBitrateFactor(this->acknowledgedBitrate, rampupAcceleration));
			}

			return candidateBitrateUpperBound;
		}

		double LossBasedController::GetObjective(const ChannelParameters& channelParameters) const
		{
			MS_TRACE();

			double objective{ 0.0 };

			const double highBitrateBias = GetHighBitrateBias(channelParameters.lossLimitedBitrate);

			for (const auto& observation : this->observations)
			{
				if (!observation.IsInitialized())
				{
					continue;
				}

				const double lossProbability = getLossProbability(
				  channelParameters.inherentLoss,
				  channelParameters.lossLimitedBitrate,
				  observation.sendingRate);

				const double temporalWeight =
				  this->temporalWeights[(this->numObservations - 1) - observation.id];

				if (this->options.useByteLossRate)
				{
					objective +=
					  temporalWeight * ((toKiloBytes(observation.lostSizeBytes) * std::log(lossProbability)) +
						                  (toKiloBytes(observation.sizeBytes - observation.lostSizeBytes) *
						                   std::log(1.0 - lossProbability)));
					objective += temporalWeight * highBitrateBias * toKiloBytes(observation.sizeBytes);
				}
				else
				{
					objective +=
					  temporalWeight *
					  ((static_cast<double>(observation.numLostPackets) * std::log(lossProbability)) +
						 (static_cast<double>(observation.numReceivedPackets) * std::log(1.0 - lossProbability)));
					objective += temporalWeight * highBitrateBias * static_cast<double>(observation.numPackets);
				}
			}

			return objective;
		}

		LossBasedController::Derivatives LossBasedController::GetDerivatives(
		  const ChannelParameters& channelParameters) const
		{
			MS_TRACE();

			Derivatives derivatives;

			for (const auto& observation : this->observations)
			{
				if (!observation.IsInitialized())
				{
					continue;
				}

				const double lossProbability = getLossProbability(
				  channelParameters.inherentLoss,
				  channelParameters.lossLimitedBitrate,
				  observation.sendingRate);

				const double temporalWeight =
				  this->temporalWeights[(this->numObservations - 1) - observation.id];

				if (this->options.useByteLossRate)
				{
					derivatives.first +=
					  temporalWeight * ((toKiloBytes(observation.lostSizeBytes) / lossProbability) -
						                  (toKiloBytes(observation.sizeBytes - observation.lostSizeBytes) /
						                   (1.0 - lossProbability)));
					derivatives.second -=
					  temporalWeight * ((toKiloBytes(observation.lostSizeBytes) / std::pow(lossProbability, 2)) +
						                  (toKiloBytes(observation.sizeBytes - observation.lostSizeBytes) /
						                   std::pow(1.0 - lossProbability, 2)));
				}
				else
				{
					derivatives.first +=
					  temporalWeight *
					  ((static_cast<double>(observation.numLostPackets) / lossProbability) -
						 (static_cast<double>(observation.numReceivedPackets) / (1.0 - lossProbability)));
					derivatives.second -=
					  temporalWeight *
					  ((static_cast<double>(observation.numLostPackets) / std::pow(lossProbability, 2)) +
						 (static_cast<double>(observation.numReceivedPackets) /
						  std::pow(1.0 - lossProbability, 2)));
				}
			}

			// NOTE: The second derivative is negative by construction, so a value of
			// zero can only come from rounding and would make the step below divide by
			// zero.
			if (derivatives.second >= 0.0)
			{
				derivatives.second = -1.0e-6;
			}

			return derivatives;
		}

		void LossBasedController::ApplyNewtonsMethod(ChannelParameters& channelParameters) const
		{
			MS_TRACE();

			if (this->numObservations <= 0)
			{
				return;
			}

			for (int64_t i{ 0 }; i < this->options.newtonIterations; ++i)
			{
				const Derivatives derivatives = GetDerivatives(channelParameters);

				channelParameters.inherentLoss -=
				  this->options.newtonStepSize * derivatives.first / derivatives.second;
				channelParameters.inherentLoss = GetFeasibleInherentLoss(channelParameters);
			}
		}

		double LossBasedController::GetFeasibleInherentLoss(const ChannelParameters& channelParameters) const
		{
			MS_TRACE();

			return std::min(
			  std::max(channelParameters.inherentLoss, this->options.inherentLossLowerBound),
			  GetInherentLossUpperBound(channelParameters.lossLimitedBitrate));
		}

		double LossBasedController::GetInherentLossUpperBound(int64_t bitrate) const
		{
			MS_TRACE();

			if (bitrate == 0)
			{
				return 1.0;
			}

			// The lower the bitrate, the more loss a link is allowed to be said to
			// have by itself, since at a low enough bitrate the traffic cannot be the
			// cause.
			const double inherentLossUpperBound =
			  this->options.inherentLossUpperBoundOffset +
			  (static_cast<double>(this->options.inherentLossUpperBoundBitrateBalance) /
				 static_cast<double>(bitrate));

			return std::min(inherentLossUpperBound, 1.0);
		}

		double LossBasedController::AdjustBiasFactor(double lossRate, double biasFactor) const
		{
			MS_TRACE();

			return biasFactor * (this->options.lossThresholdOfHighBitratePreference - lossRate) /
			       (this->options.bitratePreferenceSmoothingFactor +
			        std::abs(this->options.lossThresholdOfHighBitratePreference - lossRate));
		}

		double LossBasedController::GetHighBitrateBias(int64_t bitrate) const
		{
			MS_TRACE();

			if (bitrate <= 0)
			{
				return 0.0;
			}

			const double bitrateKbps = static_cast<double>(bitrate) / 1000.0;

			return (AdjustBiasFactor(this->averageReportedLossRatio, this->options.higherBitrateBiasFactor) *
			        bitrateKbps) +
			       (AdjustBiasFactor(
			          this->averageReportedLossRatio, this->options.higherLogBitrateBiasFactor) *
			        std::log(1.0 + bitrateKbps));
		}

		int64_t LossBasedController::GetSendingRate(int64_t instantSendingRate) const
		{
			MS_TRACE();

			if (this->numObservations <= 0)
			{
				return instantSendingRate;
			}

			const int64_t latestObservationIdx =
			  (this->numObservations - 1) % this->options.observationWindowSize;
			const int64_t previousSendingRate = this->observations[latestObservationIdx].sendingRate;

			// Each share is rounded on its own before they are added, so that the
			// smoothed rate doesn't depend on how the two of them happen to split.
			return Utils::AddBitrates(
			  Utils::ApplyBitrateFactor(previousSendingRate, this->options.sendingRateSmoothingFactor),
			  Utils::ApplyBitrateFactor(instantSendingRate, 1.0 - this->options.sendingRateSmoothingFactor));
		}

		void LossBasedController::UpdateAverageReportedLossRatio()
		{
			MS_TRACE();

			this->averageReportedLossRatio = this->options.useByteLossRate
			                                   ? CalculateAverageReportedByteLossRatio()
			                                   : CalculateAverageReportedPacketLossRatio();
		}

		double LossBasedController::CalculateAverageReportedPacketLossRatio() const
		{
			MS_TRACE();

			if (this->numObservations <= 0)
			{
				return 0.0;
			}

			double numPackets{ 0.0 };
			double numLostPackets{ 0.0 };

			for (const auto& observation : this->observations)
			{
				if (!observation.IsInitialized())
				{
					continue;
				}

				const double temporalWeight =
				  this->immediateUpperBoundTemporalWeights[(this->numObservations - 1) - observation.id];

				numPackets += temporalWeight * static_cast<double>(observation.numPackets);
				numLostPackets += temporalWeight * static_cast<double>(observation.numLostPackets);
			}

			// NOTE: Nothing was sent at all, so there is no loss to tell. Without this
			// the division would give a NaN, which makes every comparison it takes
			// part in false and silently freezes the estimate for good.
			if (numPackets == 0.0)
			{
				return 0.0;
			}

			return numLostPackets / numPackets;
		}

		double LossBasedController::CalculateAverageReportedByteLossRatio() const
		{
			MS_TRACE();

			if (this->numObservations <= 0)
			{
				return 0.0;
			}

			double totalBytes{ 0.0 };
			double lostBytes{ 0.0 };
			double minLossRate{ 1.0 };
			double maxLossRate{ 0.0 };
			double minLostBytes{ 0.0 };
			double maxLostBytes{ 0.0 };
			double minBytesReceived{ 0.0 };
			double maxBytesReceived{ 0.0 };
			int64_t sendingRateOfMaxLossObservation{ 0 };

			for (const auto& observation : this->observations)
			{
				if (!observation.IsInitialized())
				{
					continue;
				}

				const double temporalWeight =
				  this->immediateUpperBoundTemporalWeights[(this->numObservations - 1) - observation.id];

				totalBytes += temporalWeight * static_cast<double>(observation.sizeBytes);
				lostBytes += temporalWeight * static_cast<double>(observation.lostSizeBytes);

				const double lossRate = observation.sizeBytes != 0
				                          ? static_cast<double>(observation.lostSizeBytes) /
				                              static_cast<double>(observation.sizeBytes)
				                          : 0.0;

				// The highest and the lowest are left out only once there are enough
				// observations for that to still leave something.
				if (this->numObservations <= 3)
				{
					continue;
				}

				if (lossRate > maxLossRate)
				{
					maxLossRate      = lossRate;
					maxLostBytes     = temporalWeight * static_cast<double>(observation.lostSizeBytes);
					maxBytesReceived = temporalWeight * static_cast<double>(observation.sizeBytes);
					sendingRateOfMaxLossObservation = observation.sendingRate;
				}

				if (lossRate < minLossRate)
				{
					minLossRate      = lossRate;
					minLostBytes     = temporalWeight * static_cast<double>(observation.lostSizeBytes);
					minBytesReceived = temporalWeight * static_cast<double>(observation.sizeBytes);
				}
			}

			// NOTE: Nothing was sent at all, so there is no loss to tell. Without this
			// the division below would give a NaN, which makes every comparison it
			// takes part in false and silently freezes the estimate for good.
			if (totalBytes == 0.0)
			{
				return 0.0;
			}

			// A sudden jump of the sending rate explains the loss of that observation
			// on its own, so it's not a spike to be filtered out.
			if (GetMedianSendingRate() * this->options.medianSendingRateFactor <= sendingRateOfMaxLossObservation)
			{
				return lostBytes / totalBytes;
			}

			// It could happen if the window was of two observations.
			if (totalBytes == maxBytesReceived + minBytesReceived)
			{
				return lostBytes / totalBytes;
			}

			return (lostBytes - minLostBytes - maxLostBytes) /
			       (totalBytes - maxBytesReceived - minBytesReceived);
		}

		int64_t LossBasedController::GetMedianSendingRate() const
		{
			MS_TRACE();

			std::vector<int64_t> sendingRates;

			sendingRates.reserve(this->observations.size());

			for (const auto& observation : this->observations)
			{
				if (!observation.IsInitialized() || observation.sendingRate == 0)
				{
					continue;
				}

				sendingRates.push_back(observation.sendingRate);
			}

			if (sendingRates.empty())
			{
				return 0;
			}

			std::ranges::sort(sendingRates);

			if (sendingRates.size() % 2 == 0)
			{
				return (sendingRates[(sendingRates.size() / 2) - 1] + sendingRates[sendingRates.size() / 2]) /
				       2;
			}

			return sendingRates[sendingRates.size() / 2];
		}

		int64_t LossBasedController::GetImmediateUpperBoundBitrate() const
		{
			MS_TRACE();

			return this->immediateUpperBoundBitrate.value_or(this->maxBitrate);
		}

		void LossBasedController::CalculateImmediateUpperBoundBitrate()
		{
			MS_TRACE();

			int64_t bitrate{ this->maxBitrate };

			// Beyond a bit of loss, the more is observed the less the link is allowed
			// to be told to carry, without waiting for the estimate to converge.
			if (this->averageReportedLossRatio > this->options.immediateUpperBoundLossOffset)
			{
				const double boundBitrate =
				  static_cast<double>(this->options.immediateUpperBoundBitrateBalance) /
				  (this->averageReportedLossRatio - this->options.immediateUpperBoundLossOffset);

				// NOTE: A loss barely above the offset gives a bound beyond what an
				// int64_t can hold, and converting such a value is undefined behaviour.
				// It bounds nothing anyway once it's over the maximum bitrate.
				bitrate = boundBitrate >= static_cast<double>(this->maxBitrate) ? this->maxBitrate
				                                                                : std::llround(boundBitrate);
			}

			this->immediateUpperBoundBitrate = bitrate;
		}

		int64_t LossBasedController::GetImmediateLowerBoundBitrate() const
		{
			MS_TRACE();

			return this->immediateLowerBoundBitrate.value_or(0);
		}

		void LossBasedController::CalculateImmediateLowerBoundBitrate()
		{
			MS_TRACE();

			int64_t bitrate{ 0 };

			// What the link is known to be delivering is never worth going below.
			if (this->acknowledgedBitrate != Types::BitrateInfinite)
			{
				bitrate = Utils::ApplyBitrateFactor(
				  this->acknowledgedBitrate, this->options.lowerBoundByAckedRateFactor);
			}

			this->immediateLowerBoundBitrate = std::max(bitrate, this->minBitrate);
		}

		void LossBasedController::CalculateTemporalWeights()
		{
			MS_TRACE();

			for (int64_t i{ 0 }; i < this->options.observationWindowSize; ++i)
			{
				this->temporalWeights[i] = std::pow(this->options.temporalWeightFactor, i);
				this->immediateUpperBoundTemporalWeights[i] =
				  std::pow(this->options.immediateUpperBoundTemporalWeightFactor, i);
			}
		}

		bool LossBasedController::IsInLossLimitedState() const
		{
			MS_TRACE();

			return this->result.state != State::DELAY_BASED_ESTIMATE;
		}

		bool LossBasedController::IsEstimateIncreasingWhenLossLimited(
		  int64_t oldEstimate, int64_t newEstimate) const
		{
			MS_TRACE();

			return (oldEstimate < newEstimate ||
			        (oldEstimate == newEstimate && this->result.state == State::INCREASING)) &&
			       IsInLossLimitedState();
		}
	} // namespace BWE
} // namespace RTC