lucre 0.10.0

use std::{
    collections::{BTreeMap, btree_map},
    fmt,
    iter::FusedIterator,
};

use crate::{Currency, Decimal, Format, Money, MoneyError, format::write_padded};

/// A balance spread across several currencies.
///
/// [`Money`] refuses to mix currencies: `+` panics, `PartialOrd` answers
/// `None`, and summing to `Option<Money>` is only safe when every amount
/// agrees. A bag keeps each currency on its own books instead, so
/// accumulating a mixed pile always succeeds — no operation here can produce
/// [`MoneyError::CurrencyMismatch`].
///
/// A currency is held only while its balance is nonzero, so two bags
/// describing the same position always compare equal. Balances may run
/// negative; nothing here enforces solvency.
///
/// Iterating a bag yields each currency's balance in ISO alphabetic order,
/// which is enough to price a whole bag against an
/// [`ExchangeRate`](crate::ExchangeRate) apiece.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, Money, MoneyBag};
///
/// let mut wallet = MoneyBag::new();
/// wallet += Money::from_major(25, &Currency::USD);
/// wallet += Money::from_major(10, &Currency::EUR);
/// wallet += Money::from_major(5, &Currency::USD);
///
/// assert_eq!(
///     wallet.balance(&Currency::USD),
///     Money::from_major(30, &Currency::USD)
/// );
/// assert_eq!(wallet.to_string(), "10.00 EUR, 30.00 USD");
/// ```
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
pub struct MoneyBag {
    balances: BTreeMap<Currency, Decimal>,
}

impl MoneyBag {
    /// Create a bag holding nothing.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::MoneyBag;
    ///
    /// assert!(MoneyBag::new().is_empty());
    /// ```
    #[must_use]
    pub fn new() -> Self {
        Self {
            balances: BTreeMap::new(),
        }
    }

    /// How much of a currency the bag holds.
    ///
    /// A currency the bag has never seen answers zero, so this question always
    /// has an answer.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut wallet = MoneyBag::new();
    /// wallet += Money::from_minor(2550, &Currency::USD);
    ///
    /// assert_eq!(
    ///     wallet.balance(&Currency::USD),
    ///     Money::from_minor(2550, &Currency::USD)
    /// );
    /// assert_eq!(
    ///     wallet.balance(&Currency::JPY),
    ///     Money::from_major(0, &Currency::JPY)
    /// );
    /// ```
    #[must_use]
    pub fn balance(&self, currency: &Currency) -> Money {
        Money::from_decimal(self.amount_of(currency), currency)
    }

    /// Withdraw a currency's whole balance, leaving the bag without it.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut wallet = MoneyBag::new();
    /// wallet += Money::from_major(40, &Currency::GBP);
    ///
    /// assert_eq!(
    ///     wallet.take(&Currency::GBP),
    ///     Money::from_major(40, &Currency::GBP)
    /// );
    /// assert!(wallet.is_empty());
    /// ```
    pub fn take(&mut self, currency: &Currency) -> Money {
        let amount = self.balances.remove(currency).unwrap_or(Decimal::ZERO);

        Money::from_decimal(amount, currency)
    }

    /// Whether this bag could pay out everything another one holds.
    ///
    /// Every currency is weighed separately, so a bag rich in one currency
    /// cannot make up a shortfall in another. Neither `covers` nor its
    /// negation implies an ordering: two bags can each hold something the
    /// other lacks.
    ///
    /// Accepts a [`Money`] as readily as another bag, owned or borrowed.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut wallet = MoneyBag::new();
    /// wallet += Money::from_major(50, &Currency::USD);
    /// wallet += Money::from_major(20, &Currency::EUR);
    ///
    /// assert!(wallet.covers(Money::from_major(45, &Currency::USD)));
    /// assert!(!wallet.covers(Money::from_major(30, &Currency::EUR)));
    ///
    /// // A whole invoice at once, in as many currencies as it names.
    /// let invoice: MoneyBag = [
    ///     Money::from_major(45, &Currency::USD),
    ///     Money::from_major(20, &Currency::EUR),
    /// ]
    /// .into_iter()
    /// .collect();
    ///
    /// assert!(wallet.covers(&invoice));
    /// ```
    #[must_use]
    pub fn covers<B: Into<MoneyBag>>(&self, other: B) -> bool {
        other
            .into()
            .balances
            .iter()
            .all(|(currency, owed)| self.amount_of(currency) >= *owed)
    }

    /// Whether the bag holds no money at all.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut bag = MoneyBag::new();
    /// assert!(bag.is_empty());
    ///
    /// bag += Money::from_major(1, &Currency::USD);
    /// assert!(!bag.is_empty());
    /// ```
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.balances.is_empty()
    }

    /// How many currencies the bag holds a balance in.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut bag = MoneyBag::new();
    /// bag += Money::from_major(1, &Currency::USD);
    /// bag += Money::from_major(1, &Currency::EUR);
    /// assert_eq!(bag.len(), 2);
    ///
    /// // Spending a balance down to nothing drops the currency.
    /// bag -= Money::from_major(1, &Currency::USD);
    /// assert_eq!(bag.len(), 1);
    /// ```
    #[must_use]
    pub fn len(&self) -> usize {
        self.balances.len()
    }

    /// Each currency's balance, ordered by ISO alphabetic code.
    ///
    /// The order is fixed rather than incidental, so rendered output and test
    /// expectations stay stable from run to run.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let mut bag = MoneyBag::new();
    /// bag += Money::from_major(25, &Currency::USD);
    /// bag += Money::from_major(10, &Currency::EUR);
    ///
    /// let codes: Vec<String> = bag.iter().map(|m| m.currency().to_string()).collect();
    ///
    /// assert_eq!(codes, ["EUR", "USD"]);
    /// ```
    pub fn iter(&self) -> Balances<'_> {
        Balances(self.balances.iter())
    }

    /// Everything in both bags — the fallible counterpart of `+`.
    ///
    /// Accepts a [`Money`] as readily as another bag, owned or borrowed.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let wallet = MoneyBag::from(Money::from_major(10, &Currency::USD));
    /// let payment = MoneyBag::from(Money::from_major(5, &Currency::USD));
    ///
    /// assert_eq!(
    ///     wallet.checked_add(Money::from_major(5, &Currency::USD)),
    ///     Ok(MoneyBag::from(Money::from_major(15, &Currency::USD)))
    /// );
    /// assert_eq!(wallet.checked_add(&payment), wallet.checked_add(payment.clone()));
    /// ```
    ///
    /// ## Errors
    ///
    /// Returns [`MoneyError::Overflow`] if any currency's balance would fall
    /// outside the range a [`Decimal`] can hold.
    pub fn checked_add<B: Into<MoneyBag>>(&self, other: B) -> Result<Self, MoneyError> {
        self.combined_with(&other.into(), Decimal::checked_add)
    }

    /// What is left after taking one bag out of another — the fallible
    /// counterpart of `-`.
    ///
    /// Balances are free to go negative, so this fails only on overflow.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Money, MoneyBag};
    ///
    /// let wallet = MoneyBag::from(Money::from_major(10, &Currency::USD));
    ///
    /// assert_eq!(
    ///     wallet.checked_sub(Money::from_major(25, &Currency::USD)),
    ///     Ok(MoneyBag::from(Money::from_major(-15, &Currency::USD)))
    /// );
    /// ```
    ///
    /// ## Errors
    ///
    /// Returns [`MoneyError::Overflow`] if any currency's balance would fall
    /// outside the range a [`Decimal`] can hold.
    pub fn checked_sub<B: Into<MoneyBag>>(&self, other: B) -> Result<Self, MoneyError> {
        self.combined_with(&other.into(), Decimal::checked_sub)
    }

    /// Renders every balance as `format` describes, separated by commas.
    ///
    /// The result is a value for `write!`/`format!`/`to_string`, so nothing is
    /// allocated until it is actually displayed.
    ///
    /// ## Example
    ///
    /// ```
    /// use lucre::{Currency, Format, Money, MoneyBag};
    ///
    /// let mut bag = MoneyBag::new();
    /// bag += Money::from_major(25, &Currency::USD);
    /// bag += Money::from_major(10, &Currency::EUR);
    ///
    /// let bare = Format::new().amount_only();
    ///
    /// assert_eq!(bag.format_with(&bare).to_string(), "10.00, 25.00");
    ///
    /// // Width, fill, and alignment apply to the whole list, as they do to a
    /// // single amount.
    /// assert_eq!(format!("{:>16}", bag.format_with(&bare)), "    10.00, 25.00");
    /// ```
    #[must_use]
    pub fn format_with(&self, format: &Format) -> impl fmt::Display + use<> {
        FormattedBag {
            bag: self.clone(),
            format: *format,
        }
    }

    fn amount_of(&self, currency: &Currency) -> Decimal {
        self.balances
            .get(currency)
            .copied()
            .unwrap_or(Decimal::ZERO)
    }

    /// Records a currency's balance, striking it from the books entirely when
    /// it comes to nothing — the one rule that leaves a single bag per
    /// financial position for `Eq` to compare. Writing never fails, so no path
    /// through the type can abandon a bag half-updated.
    fn set(&mut self, balance: Money) {
        if balance.is_amount_zero() {
            self.balances.remove(&balance.currency());
        } else {
            self.balances.insert(balance.currency(), balance.amount());
        }
    }

    /// Where a currency's balance lands once `money` is folded in, worked out
    /// without touching the bag.
    fn balance_after(
        &self,
        money: Money,
        op: fn(Decimal, Decimal) -> Option<Decimal>,
    ) -> Result<Money, MoneyError> {
        let currency = money.currency();

        op(self.amount_of(&currency), money.amount())
            .map(|total| Money::from_decimal(total, &currency))
            .ok_or(MoneyError::Overflow)
    }

    /// Folds another bag in one currency at a time. The original is read from
    /// and never written to, so an overflow costs only the working copy.
    fn combined_with(
        &self,
        other: &MoneyBag,
        op: fn(Decimal, Decimal) -> Option<Decimal>,
    ) -> Result<Self, MoneyError> {
        let mut combined = self.clone();

        for money in other {
            let balance = combined.balance_after(money, op)?;
            combined.set(balance);
        }

        Ok(combined)
    }

    fn render(&self, format: &Format) -> String {
        self.iter()
            .map(|money| money.format_with(format).to_string())
            .collect::<Vec<_>>()
            .join(", ")
    }
}

/// What a borrowed bag yields: one [`Money`] per currency held, ordered by ISO
/// alphabetic code.
///
/// ## Example
///
/// ```
/// use lucre::{Balances, Currency, Money, MoneyBag};
///
/// let bag = MoneyBag::from(Money::from_major(25, &Currency::USD));
/// let balances: Balances<'_> = bag.iter();
///
/// assert_eq!(balances.count(), 1);
/// ```
#[derive(Debug, Clone)]
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct Balances<'a>(btree_map::Iter<'a, Currency, Decimal>);

impl Iterator for Balances<'_> {
    type Item = Money;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(borrowed_entry_to_money)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.0.size_hint()
    }
}

impl DoubleEndedIterator for Balances<'_> {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.0.next_back().map(borrowed_entry_to_money)
    }
}

impl ExactSizeIterator for Balances<'_> {
    fn len(&self) -> usize {
        self.0.len()
    }
}

impl FusedIterator for Balances<'_> {}

/// The same balances, out of a bag given up whole.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, IntoBalances, Money, MoneyBag};
///
/// let bag = MoneyBag::from(Money::from_major(25, &Currency::USD));
/// let balances: IntoBalances = bag.into_iter();
///
/// assert_eq!(balances.count(), 1);
/// ```
#[derive(Debug)]
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct IntoBalances(btree_map::IntoIter<Currency, Decimal>);

impl Iterator for IntoBalances {
    type Item = Money;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(entry_to_money)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.0.size_hint()
    }
}

impl DoubleEndedIterator for IntoBalances {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.0.next_back().map(entry_to_money)
    }
}

impl ExactSizeIterator for IntoBalances {
    fn len(&self) -> usize {
        self.0.len()
    }
}

impl FusedIterator for IntoBalances {}

fn entry_to_money((currency, amount): (Currency, Decimal)) -> Money {
    Money::from_decimal(amount, &currency)
}

fn borrowed_entry_to_money((currency, amount): (&Currency, &Decimal)) -> Money {
    entry_to_money((*currency, *amount))
}

/// Renders as [`Format::default`] describes, separated by commas. An empty bag
/// renders as nothing at all, so callers wanting a placeholder should check
/// [`MoneyBag::is_empty`] first.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, Money, MoneyBag};
///
/// let mut bag = MoneyBag::new();
/// bag += Money::from_minor(150000, &Currency::USD);
/// bag += Money::from_major(10, &Currency::EUR);
///
/// assert_eq!(bag.to_string(), "10.00 EUR, 1,500.00 USD");
/// assert_eq!(MoneyBag::new().to_string(), "");
/// ```
impl fmt::Display for MoneyBag {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write_padded(f, &self.render(&Format::default()))
    }
}

struct FormattedBag {
    bag: MoneyBag,
    format: Format,
}

impl fmt::Display for FormattedBag {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write_padded(f, &self.bag.render(&self.format))
    }
}

/// A single amount, bagged. A zero amount makes an empty bag.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, Money, MoneyBag};
///
/// let bag = MoneyBag::from(Money::from_major(5, &Currency::CAD));
///
/// assert_eq!(bag.balance(&Currency::CAD), Money::from_major(5, &Currency::CAD));
/// assert!(MoneyBag::from(Money::from_major(0, &Currency::CAD)).is_empty());
/// ```
impl From<Money> for MoneyBag {
    fn from(money: Money) -> Self {
        let mut bag = Self::new();
        bag.set(money);

        bag
    }
}

impl From<&Money> for MoneyBag {
    fn from(money: &Money) -> Self {
        Self::from(*money)
    }
}

impl From<&MoneyBag> for MoneyBag {
    fn from(bag: &MoneyBag) -> Self {
        bag.clone()
    }
}

impl std::ops::AddAssign<Money> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_add`] to handle that as an
    /// error.
    fn add_assign(&mut self, rhs: Money) {
        let balance = self
            .balance_after(rhs, Decimal::checked_add)
            .unwrap_or_else(|e| panic!("addition error: {e}"));

        self.set(balance);
    }
}

impl std::ops::AddAssign<&Money> for MoneyBag {
    fn add_assign(&mut self, rhs: &Money) {
        *self += *rhs;
    }
}

impl std::ops::SubAssign<Money> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_sub`] to handle that as an
    /// error.
    fn sub_assign(&mut self, rhs: Money) {
        let balance = self
            .balance_after(rhs, Decimal::checked_sub)
            .unwrap_or_else(|e| panic!("subtraction error: {e}"));

        self.set(balance);
    }
}

impl std::ops::SubAssign<&Money> for MoneyBag {
    fn sub_assign(&mut self, rhs: &Money) {
        *self -= *rhs;
    }
}

impl std::ops::AddAssign<&MoneyBag> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_add`] to handle that as an
    /// error.
    fn add_assign(&mut self, rhs: &MoneyBag) {
        *self = self
            .combined_with(rhs, Decimal::checked_add)
            .unwrap_or_else(|e| panic!("addition error: {e}"));
    }
}

impl std::ops::AddAssign<MoneyBag> for MoneyBag {
    fn add_assign(&mut self, rhs: MoneyBag) {
        *self += &rhs;
    }
}

impl std::ops::SubAssign<&MoneyBag> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_sub`] to handle that as an
    /// error.
    fn sub_assign(&mut self, rhs: &MoneyBag) {
        *self = self
            .combined_with(rhs, Decimal::checked_sub)
            .unwrap_or_else(|e| panic!("subtraction error: {e}"));
    }
}

impl std::ops::SubAssign<MoneyBag> for MoneyBag {
    fn sub_assign(&mut self, rhs: MoneyBag) {
        *self -= &rhs;
    }
}

impl std::ops::Add<&MoneyBag> for &MoneyBag {
    type Output = MoneyBag;

    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_add`] to handle that as an
    /// error.
    fn add(self, rhs: &MoneyBag) -> Self::Output {
        self.combined_with(rhs, Decimal::checked_add)
            .unwrap_or_else(|e| panic!("addition error: {e}"))
    }
}

impl std::ops::Add for MoneyBag {
    type Output = MoneyBag;

    fn add(self, rhs: Self) -> Self::Output {
        &self + &rhs
    }
}

impl std::ops::Add<&MoneyBag> for MoneyBag {
    type Output = MoneyBag;

    fn add(self, rhs: &MoneyBag) -> Self::Output {
        &self + rhs
    }
}

impl std::ops::Add<MoneyBag> for &MoneyBag {
    type Output = MoneyBag;

    fn add(self, rhs: MoneyBag) -> Self::Output {
        self + &rhs
    }
}

impl std::ops::Sub<&MoneyBag> for &MoneyBag {
    type Output = MoneyBag;

    /// # Panics
    ///
    /// Panics on overflow. Use [`MoneyBag::checked_sub`] to handle that as an
    /// error.
    fn sub(self, rhs: &MoneyBag) -> Self::Output {
        self.combined_with(rhs, Decimal::checked_sub)
            .unwrap_or_else(|e| panic!("subtraction error: {e}"))
    }
}

impl std::ops::Sub for MoneyBag {
    type Output = MoneyBag;

    fn sub(self, rhs: Self) -> Self::Output {
        &self - &rhs
    }
}

impl std::ops::Sub<&MoneyBag> for MoneyBag {
    type Output = MoneyBag;

    fn sub(self, rhs: &MoneyBag) -> Self::Output {
        &self - rhs
    }
}

impl std::ops::Sub<MoneyBag> for &MoneyBag {
    type Output = MoneyBag;

    fn sub(self, rhs: MoneyBag) -> Self::Output {
        self - &rhs
    }
}

impl IntoIterator for MoneyBag {
    type Item = Money;
    type IntoIter = IntoBalances;

    fn into_iter(self) -> Self::IntoIter {
        IntoBalances(self.balances.into_iter())
    }
}

/// Borrowing a bag still yields owned [`Money`], which is [`Copy`].
impl<'a> IntoIterator for &'a MoneyBag {
    type Item = Money;
    type IntoIter = Balances<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl Extend<Money> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow, as `+=` does.
    fn extend<I: IntoIterator<Item = Money>>(&mut self, iter: I) {
        for money in iter {
            *self += money;
        }
    }
}

impl<'a> Extend<&'a Money> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow, as `+=` does.
    fn extend<I: IntoIterator<Item = &'a Money>>(&mut self, iter: I) {
        self.extend(iter.into_iter().copied());
    }
}

impl Extend<MoneyBag> for MoneyBag {
    /// # Panics
    ///
    /// Panics on overflow, as `+` does.
    fn extend<I: IntoIterator<Item = MoneyBag>>(&mut self, iter: I) {
        for bag in iter {
            *self += &bag;
        }
    }
}

/// Gathers amounts of any currencies at all, where collecting to
/// `Option<Money>` would insist they match.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, Money, MoneyBag};
///
/// let payments = [
///     Money::from_major(30, &Currency::USD),
///     Money::from_major(12, &Currency::EUR),
/// ];
///
/// let bag: MoneyBag = payments.into_iter().collect();
///
/// assert_eq!(bag.to_string(), "12.00 EUR, 30.00 USD");
/// ```
///
/// ## Panics
///
/// Panics on overflow, as `+=` does.
impl FromIterator<Money> for MoneyBag {
    fn from_iter<I: IntoIterator<Item = Money>>(iter: I) -> Self {
        let mut bag = Self::new();
        bag.extend(iter);

        bag
    }
}

impl<'a> FromIterator<&'a Money> for MoneyBag {
    /// ## Panics
    ///
    /// Panics on overflow, as `+=` does.
    fn from_iter<I: IntoIterator<Item = &'a Money>>(iter: I) -> Self {
        iter.into_iter().copied().collect()
    }
}

impl FromIterator<MoneyBag> for MoneyBag {
    /// ## Panics
    ///
    /// Panics on overflow, as `+` does.
    fn from_iter<I: IntoIterator<Item = MoneyBag>>(iter: I) -> Self {
        let mut bag = Self::new();
        bag.extend(iter);

        bag
    }
}

/// Totals a sequence of amounts however many currencies they name.
///
/// Both this and summing to `Option<Money>` are available over the same
/// iterator, so the type asked for is the decision: `Option<Money>` demands
/// the currencies match and panics otherwise, a bag keeps them apart.
///
/// ## Example
///
/// ```
/// use lucre::{Currency, Money, MoneyBag};
///
/// let cart = [
///     Money::from_minor(1999, &Currency::USD),
///     Money::from_minor(1250, &Currency::USD),
/// ];
///
/// assert_eq!(
///     cart.iter().sum::<Option<Money>>(),
///     Some(Money::from_minor(3249, &Currency::USD))
/// );
/// assert_eq!(cart.iter().sum::<MoneyBag>().to_string(), "32.49 USD");
///
/// // Only the bag survives a mixed cart; `Option<Money>` would panic.
/// let mixed = [
///     Money::from_minor(1999, &Currency::USD),
///     Money::from_minor(1250, &Currency::EUR),
/// ];
///
/// assert_eq!(mixed.iter().sum::<MoneyBag>().to_string(), "12.50 EUR, 19.99 USD");
/// ```
///
/// ## Panics
///
/// Panics on overflow, as `+=` does.
impl std::iter::Sum<Money> for MoneyBag {
    fn sum<I: Iterator<Item = Money>>(iter: I) -> Self {
        iter.collect()
    }
}

impl<'a> std::iter::Sum<&'a Money> for MoneyBag {
    /// ## Panics
    ///
    /// Panics on overflow, as `+=` does.
    fn sum<I: Iterator<Item = &'a Money>>(iter: I) -> Self {
        iter.copied().collect()
    }
}

impl std::iter::Sum<MoneyBag> for MoneyBag {
    /// ## Panics
    ///
    /// Panics on overflow, as `+` does.
    fn sum<I: Iterator<Item = MoneyBag>>(iter: I) -> Self {
        iter.collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn usd(major: i64) -> Money {
        Money::from_major(major, &Currency::USD)
    }

    fn eur(major: i64) -> Money {
        Money::from_major(major, &Currency::EUR)
    }

    #[test]
    fn accumulates_each_currency_separately_test() {
        let mut bag = MoneyBag::new();
        bag += usd(10);
        bag += eur(4);
        bag += usd(5);

        assert_eq!(bag.balance(&Currency::USD), usd(15));
        assert_eq!(bag.balance(&Currency::EUR), eur(4));
        assert_eq!(bag.len(), 2);
    }

    #[test]
    fn untouched_currency_balances_zero_test() {
        let bag = MoneyBag::from(usd(10));

        assert_eq!(
            bag.balance(&Currency::JPY),
            Money::from_major(0, &Currency::JPY)
        );
    }

    #[test]
    fn zeroed_balance_is_dropped_test() {
        let mut bag = MoneyBag::from(usd(10));
        bag -= usd(10);

        assert!(bag.is_empty());
        assert_eq!(bag, MoneyBag::new());
    }

    #[test]
    fn equal_positions_compare_equal_regardless_of_history_test() {
        let mut spent = MoneyBag::new();
        spent += usd(10);
        spent += eur(7);
        spent -= eur(7);

        assert_eq!(spent, MoneyBag::from(usd(10)));
    }

    #[test]
    fn balances_may_go_negative_test() {
        let mut bag = MoneyBag::new();
        bag -= usd(3);

        assert_eq!(bag.balance(&Currency::USD), usd(-3));
        assert_eq!(bag.len(), 1);
    }

    #[test]
    fn take_removes_and_returns_the_balance_test() {
        let mut bag = MoneyBag::from(usd(10));

        assert_eq!(bag.take(&Currency::USD), usd(10));
        assert_eq!(bag.take(&Currency::USD), usd(0));
        assert!(bag.is_empty());
    }

    #[test]
    fn covers_weighs_currencies_separately_test() {
        let mut wallet = MoneyBag::new();
        wallet += usd(50);
        wallet += eur(20);

        assert!(wallet.covers(usd(50)));
        assert!(wallet.covers(MoneyBag::from(eur(20))));
        assert!(!wallet.covers(eur(21)));
        assert!(wallet.covers(MoneyBag::new()));
    }

    #[test]
    fn a_surplus_cannot_cover_another_currencys_shortfall_test() {
        let wallet = MoneyBag::from(usd(1_000));

        assert!(!wallet.covers(eur(1)));
    }

    #[test]
    fn covers_is_not_an_ordering_test() {
        let rich_in_usd = MoneyBag::from(usd(10));
        let rich_in_eur = MoneyBag::from(eur(10));

        assert!(!rich_in_usd.covers(&rich_in_eur));
        assert!(!rich_in_eur.covers(&rich_in_usd));
    }

    #[test]
    fn iterates_in_alphabetic_code_order_test() {
        let mut bag = MoneyBag::new();
        bag += Money::from_major(1, &Currency::ZAR);
        bag += usd(1);
        bag += Money::from_major(1, &Currency::AUD);

        let codes: Vec<String> = bag.iter().map(|m| m.currency().to_string()).collect();

        assert_eq!(codes, ["AUD", "USD", "ZAR"]);
    }

    #[test]
    fn checked_add_accepts_money_and_bags_test() {
        let wallet = MoneyBag::from(usd(10));
        let deposit = MoneyBag::from(eur(5));

        assert_eq!(wallet.checked_add(usd(5)), Ok(MoneyBag::from(usd(15))));
        assert_eq!(
            wallet.checked_add(deposit.clone()),
            Ok([usd(10), eur(5)].into_iter().collect())
        );
        assert_eq!(
            wallet.checked_add(&deposit),
            Ok([usd(10), eur(5)].into_iter().collect())
        );
        assert_eq!(wallet.checked_sub(&wallet), Ok(MoneyBag::new()));
    }

    #[test]
    fn checked_add_reports_overflow_test() {
        let ceiling = MoneyBag::from(Money::from_decimal(Decimal::MAX, &Currency::USD));

        assert_eq!(ceiling.checked_add(usd(1)), Err(MoneyError::Overflow));
    }

    #[test]
    fn checked_sub_reports_overflow_test() {
        let floor = MoneyBag::from(Money::from_decimal(Decimal::MIN, &Currency::USD));

        assert_eq!(floor.checked_sub(usd(1)), Err(MoneyError::Overflow));
    }

    #[test]
    fn overflow_leaves_the_bag_untouched_test() {
        let ceiling = MoneyBag::from(Money::from_decimal(Decimal::MAX, &Currency::USD));
        let mut attempt = ceiling.clone();
        attempt += eur(1);

        assert!(attempt.checked_add(usd(1)).is_err());
        assert_eq!(attempt.balance(&Currency::EUR), eur(1));
    }

    #[test]
    #[should_panic(expected = "addition error: overflow")]
    fn addition_panics_on_overflow_test() {
        let mut bag = MoneyBag::from(Money::from_decimal(Decimal::MAX, &Currency::USD));
        bag += usd(1);
    }

    #[test]
    fn bags_add_and_subtract_test() {
        let left: MoneyBag = [usd(10), eur(5)].into_iter().collect();
        let right: MoneyBag = [usd(3), eur(5)].into_iter().collect();

        assert_eq!(&left + &right, [usd(13), eur(10)].into_iter().collect());
        assert_eq!(left - right, MoneyBag::from(usd(7)));
    }

    #[test]
    fn bags_accumulate_in_place_test() {
        let mut running: MoneyBag = [usd(10), eur(5)].into_iter().collect();
        running += MoneyBag::from(usd(3));
        running -= &MoneyBag::from(eur(5));

        assert_eq!(running, MoneyBag::from(usd(13)));
    }

    #[test]
    #[allow(clippy::op_ref)]
    fn borrowed_operands_test() {
        let wallet: MoneyBag = [usd(10), eur(5)].into_iter().collect();
        let refund = MoneyBag::from(eur(5));

        assert_eq!(&wallet + &refund, [usd(10), eur(10)].into_iter().collect());
        assert_eq!(
            wallet.clone() + &refund,
            [usd(10), eur(10)].into_iter().collect()
        );
        assert_eq!(
            &wallet + refund.clone(),
            [usd(10), eur(10)].into_iter().collect()
        );
        assert_eq!(&wallet - &refund, MoneyBag::from(usd(10)));
    }

    #[test]
    fn sums_mixed_currencies_test() {
        let cart = [usd(10), eur(5), usd(2)];

        assert_eq!(
            cart.iter().sum::<MoneyBag>(),
            [usd(12), eur(5)].into_iter().collect()
        );
    }

    #[test]
    fn sums_bags_test() {
        let accounts = [MoneyBag::from(usd(10)), MoneyBag::from(eur(5))];

        assert_eq!(
            accounts.into_iter().sum::<MoneyBag>(),
            [usd(10), eur(5)].into_iter().collect()
        );
    }

    #[test]
    fn zero_money_makes_an_empty_bag_test() {
        assert!(MoneyBag::from(usd(0)).is_empty());
    }

    #[test]
    fn empty_bag_renders_as_nothing_test() {
        assert_eq!(MoneyBag::new().to_string(), "");
    }

    #[test]
    fn rendering_honors_width_and_alignment_test() {
        let bag = MoneyBag::from(usd(10));

        assert_eq!(format!("{bag:>14}"), "     10.00 USD");
        assert_eq!(
            format!("{:*<12}", bag.format_with(&Format::new())),
            "10.00 USD***"
        );
    }

    #[test]
    fn renders_balances_in_order_test() {
        let bag: MoneyBag = [usd(10), eur(5)].into_iter().collect();

        assert_eq!(bag.to_string(), "5.00 EUR, 10.00 USD");
    }

    #[test]
    fn into_iterator_yields_balances_test() {
        let bag: MoneyBag = [usd(10), eur(5)].into_iter().collect();
        let owned: Vec<Money> = bag.clone().into_iter().collect();
        let borrowed: Vec<Money> = (&bag).into_iter().collect();

        assert_eq!(owned, vec![eur(5), usd(10)]);
        assert_eq!(owned, borrowed);
    }

    #[test]
    fn balances_count_and_reverse_without_walking_forward_test() {
        let bag: MoneyBag = [usd(10), eur(5)].into_iter().collect();

        assert_eq!(bag.iter().len(), 2);
        assert_eq!(bag.iter().rev().collect::<Vec<_>>(), vec![usd(10), eur(5)]);
        assert_eq!(
            bag.into_iter().rev().collect::<Vec<_>>(),
            vec![usd(10), eur(5)]
        );
    }
}