From 50bc1cd1ab234485ab30cfaf6acfb1762668a417 Mon Sep 17 00:00:00 2001
From: user1823 <92206575+user1823@users.noreply.github.com>
Date: Sat, 21 Jun 2025 13:32:29 +0530
Subject: [PATCH] Format

---
 rslib/src/scheduler/fsrs/memory_state.rs | 77 +++++++++++++-----------
 1 file changed, 41 insertions(+), 36 deletions(-)

diff --git a/rslib/src/scheduler/fsrs/memory_state.rs b/rslib/src/scheduler/fsrs/memory_state.rs
index ac5ffe1e7..a77aca5a6 100644
--- a/rslib/src/scheduler/fsrs/memory_state.rs
+++ b/rslib/src/scheduler/fsrs/memory_state.rs
@@ -112,21 +112,21 @@ impl Collection {
                     card.desired_retention = desired_retention;
                     card.decay = decay;
                     if let Some(item) = &item {
-                        card.set_memory_state(&fsrs, Some(item), historical_retention.unwrap())?;
+                        card.set_memory_state(&fsrs, item, historical_retention.unwrap())?;
                         // if rescheduling
                         if let Some(reviews) = &last_revlog_info {
                             // and we have a last review time for the card
                             if let Some(last_info) = reviews.get(&card.id) {
                                 if let Some(last_review) = &last_info.last_reviewed_at {
                                     let days_elapsed =
-                                    timing.next_day_at.elapsed_days_since(*last_review) as i32;
+                                        timing.next_day_at.elapsed_days_since(*last_review) as i32;
                                     // and the card's not new
                                     if let Some(state) = &card.memory_state {
                                         // or in (re)learning
                                         if card.ctype == CardType::Review {
                                             let deck = self
-                                            .get_deck(card.original_or_current_deck_id())?
-                                            .or_not_found(card.original_or_current_deck_id())?;
+                                                .get_deck(card.original_or_current_deck_id())?
+                                                .or_not_found(card.original_or_current_deck_id())?;
                                             let deckconfig_id = deck.config_id().unwrap();
                                             // reschedule it
                                             let original_interval = card.interval;
@@ -136,57 +136,62 @@ impl Collection {
                                                 0,
                                             );
                                             card.interval = rescheduler
-                                            .as_mut()
-                                            .and_then(|r| {
-                                                r.find_interval(
-                                                    interval,
-                                                    1,
-                                                    req.max_interval,
-                                                    days_elapsed as u32,
-                                                    deckconfig_id,
-                                                    get_fuzz_seed(&card, true),
-                                                )
-                                            })
-                                            .unwrap_or_else(|| {
-                                                with_review_fuzz(
-                                                    card.get_fuzz_factor(true),
-                                                    interval,
-                                                    1,
-                                                    req.max_interval,
-                                                )
-                                            });
+                                                .as_mut()
+                                                .and_then(|r| {
+                                                    r.find_interval(
+                                                        interval,
+                                                        1,
+                                                        req.max_interval,
+                                                        days_elapsed as u32,
+                                                        deckconfig_id,
+                                                        get_fuzz_seed(&card, true),
+                                                    )
+                                                })
+                                                .unwrap_or_else(|| {
+                                                    with_review_fuzz(
+                                                        card.get_fuzz_factor(true),
+                                                        interval,
+                                                        1,
+                                                        req.max_interval,
+                                                    )
+                                                });
                                             let due = if card.original_due != 0 {
                                                 &mut card.original_due
                                             } else {
                                                 &mut card.due
                                             };
-                                            let new_due = (timing.days_elapsed as i32) - days_elapsed
-                                            + card.interval as i32;
+                                            let new_due = (timing.days_elapsed as i32)
+                                                - days_elapsed
+                                                + card.interval as i32;
                                             if let Some(rescheduler) = &mut rescheduler {
                                                 rescheduler.update_due_cnt_per_day(
-                                                *due,
-                                                new_due,
-                                                deckconfig_id,
+                                                    *due,
+                                                    new_due,
+                                                    deckconfig_id,
                                                 );
                                             }
                                             *due = new_due;
                                             // Add a rescheduled revlog entry
-                                            self.log_rescheduled_review(&card, original_interval, usn)?;
+                                            self.log_rescheduled_review(
+                                                &card,
+                                                original_interval,
+                                                usn,
+                                            )?;
                                         }
                                     }
                                 }
                             }
                         }
+                    } else {
+                        // clear memory states if item is None
+                        card.memory_state = None;
+                    }
                 } else {
-                    // clear memory states if item is None
+                    // clear FSRS data if FSRS is disabled
                     card.memory_state = None;
+                    card.desired_retention = None;
+                    card.decay = None;
                 }
-            } else {
-                // clear FSRS data if FSRS is disabled
-                card.memory_state = None;
-                card.desired_retention = None;
-                card.decay = None;
-            }
                 self.update_card_inner(&mut card, original, usn)?;
             }
         }