The big picture

/// The shop's workflow: reserve, charge and ship, auditing the charge, rescuing it when the
/// card has expired, and telling the customer how the order went.
#[workflow(name = "orders", policies = [Notify], reporters = [Log])]
// The steps run in this order, and nothing reorders them.
#[with_step(Reserve, name = "reserve")]
// The charge runs at most twice: once, and once more after its rescue step succeeds.
// Every successful charge is audited.
#[with_step(Charge, name = "charge", rescue = RenewCard, policies = [Audit])]
// Shipping may be tried once more, after a failure worth trying again.
#[with_step(Ship, name = "ship", retry_budget = 1)]
struct Orders;

/// Reserves the order's goods in the stock store.
#[derive(Step)]
struct Reserve {
    #[input]
    order: String,
}

#[step]
impl Reserve {
    fn run(self, #[service] stock: &dyn StockStore) -> Result<Outcome, Error> {
        if !stock.reserve(&self.order) {
            return Self::fail("out-of-stock");
        }
        Self::succeed()
    }
}

/// Charges the card the price, less any discount. It only says how it went: what happens after
/// a declined card is not its business.
#[derive(Step)]
struct Charge {
    #[input]
    card: String,
    #[input]
    price: i64,
    #[input]
    discount: Option<i64>,
}

#[step]
impl Charge {
    fn run(
        self,
        #[service] payments: &dyn Payments,
        #[contributor] mut contributor: Contributor<'_>,
    ) -> Result<Outcome, Error> {
        let amount = self.price - self.discount.unwrap_or(0);
        match payments.charge(&self.card, amount) {
            Ok(receipt) => {
                contributor.contribute("charged", amount);
                contributor.contribute("receipt", receipt);
                Self::succeed()
            }
            Err(Declined::ExpiredCard) => Self::fail("expired-card"),
            Err(Declined::Refused) => Self::fail("declined"),
        }
    }
}

/// The charge's rescue step: asks the customer's bank for the card that replaced an expired one.
/// A charge that failed for any other reason, or ended in an abnormal termination, which has no
/// reason, cannot be repaired this way.
#[derive(RescueStep)]
struct RenewCard {
    #[input]
    card: String,
    #[reason]
    reason: Option<Reason>,
}

#[rescue_step]
impl RenewCard {
    fn run(
        self,
        #[service] payments: &dyn Payments,
        #[contributor] mut contributor: Contributor<'_>,
    ) -> Result<RescueOutcome, Error> {
        if self.reason.as_ref().map(Reason::code) != Some("expired-card") {
            return Self::fail("nothing-to-renew");
        }
        let Some(card) = payments.renewed_card(&self.card) else {
            return Self::fail("nothing-to-renew");
        };
        contributor.contribute("card", card);
        Self::succeed()
    }
}

/// Ships the order through the carrier it is given, without knowing which one it is. A carrier
/// that cannot take the parcel might be replaced on another try, so that failure is worth trying
/// again.
#[derive(Step)]
struct Ship {
    #[input]
    order: String,
    #[input]
    weight: i64,
}

#[step]
impl Ship {
    fn run(
        self,
        #[service] carrier: &dyn Carrier,
        #[service] stock: &dyn StockStore,
        #[contributor] mut contributor: Contributor<'_>,
    ) -> Result<Outcome, Error> {
        let Some(tracking) = carrier.send(&self.order, self.weight) else {
            return Self::fail("parcel-refused");
        };
        stock.hand_over(&self.order);
        contributor.contribute("tracking", tracking);
        Self::succeed()
    }
}

/// Audits every successful charge, in the journey's events, including one after a rescue.
#[derive(Default)]
struct Audit;

#[step_policy(name = "audit")]
impl Audit {
    #[on_step_success]
    fn audited(
        &self,
        #[from_step] charged: i64,
        #[from_step] receipt: String,
        #[reporter] mut reporter: HookReporter<'_>,
    ) -> Result<Option<OnSuccess>, Error> {
        reporter.info(format!("charged {charged}, receipt {receipt}"))?;
        Self::carry_on()
    }
}

/// A role the shop provides: telling a customer something.
trait Messages {
    fn tell(&self, customer: &str, message: &str);
}

/// Tells the customer how the order went, once, when the journey ends.
#[derive(Default)]
struct Notify;

#[workflow_policy(name = "notify")]
impl Notify {
    #[on_workflow_success]
    fn shipped(
        &self,
        #[from_workflow] customer: String,
        #[from_workflow] order: String,
        #[from_workflow] tracking: String,
        #[role] messages: &dyn Messages,
    ) -> Result<(), Error> {
        messages.tell(
            &customer,
            &format!("order {order} is on its way: {tracking}"),
        );
        Ok(())
    }

    #[on_workflow_failure]
    fn failed(
        &self,
        #[from_workflow] customer: String,
        #[from_workflow] order: String,
        #[role] messages: &dyn Messages,
    ) -> Result<(), Error> {
        messages.tell(&customer, &format!("order {order} could not be completed"));
        Ok(())
    }
}

#[workflow]
impl Orders {
    /// One payment client for the journey, used by the charge and its rescue step.
    #[provider(key = "payments")]
    fn bank(&self) -> Result<Provided<dyn Payments>, Error> {
        Ok(provide!(BANK))
    }

    /// One stock store for the journey, shared by reserve and ship.
    #[provider(key = "stock")]
    fn warehouse(&self) -> Result<Provided<dyn StockStore>, Error> {
        Ok(provide!(WAREHOUSE))
    }

    /// A carrier for every attempt: the main carrier first, the backup carrier after.
    #[provider(per_attempt)]
    fn carrier(&self, #[attempt] attempt: NonZeroU32) -> Result<Provided<dyn Carrier>, Error> {
        if attempt.get() == 1 {
            Ok(provide!(MAIN_CARRIER))
        } else {
            Ok(provide!(BACKUP_CARRIER))
        }
    }
}

/// How the shop tells a customer something, for the notify policy: here, by printing it.
#[role]
impl Messages for Orders {
    fn tell(&self, customer: &str, message: &str) {
        println!("  to {customer}: {message}");
    }
}

// The workflow lists its steps, their policies, services and rescue step, without running
// anything.
for listed in Orders::descriptor().listing() {
    println!("{}", entry(&listed));
}

// The order, the customer, the card, the price, the discount and the parcel's weight in kg.
let orders = [
    ("A-1", "Ann", "ann-card-2028", 40, Some(5), 2),
    ("A-2", "Ben", "ben-card-2024", 25, None, 1),
    ("A-3", "Cat", "cat-card-2027", 30, None, 30),
    ("A-4", "Dan", "dan-card-2025", 1200, None, 3),
    ("A-5", "Eve", "eve-card-2027", 20, None, 2),
    ("A-6", "Fin", "fin-card-2028", 1500, None, 4),
    ("A-7", "Gil", "gil-card-2029", 45, None, 60),
];