调度：scope、任务与 effect

//! 1. Dirty Scopes:
//!    Description: When a scope is marked dirty, a rerun of the scope will be scheduled. This will cause the scope to rerun and update the DOM if any changes are detected during the diffing phase.
//!    Priority: These are the highest priority tasks. Dirty scopes will be rerun in order from the scope closest to the root to the scope furthest from the root. We follow this order to ensure that if a higher component reruns and drops a lower component, the lower component will not be run after it should be dropped.
//!
//! 2. Tasks:
//!    Description: Futures spawned in the dioxus runtime each have an unique task id. When the waker for that future is called, the task is rerun.
//!    Priority: These are the second highest priority tasks. They are run after all other dirty scopes have been resolved because those dirty scopes may cause children (and the tasks those children own) to drop which should cancel the futures.
//!
//! 3. Effects:
//!    Description: Effects should always run after all changes to the DOM have been applied.
//!    Priority: These are the lowest priority tasks in the scheduler. They are run after all other dirty scopes and futures have been resolved. Other tasks may cause components to rerun, which would update the DOM. These effects should only run after the DOM has been updated.

pub(crate) enum SchedulerMsg {
    /// All components have been marked as dirty, requiring a full render
    #[allow(unused)]
    AllDirty,

    /// Immediate updates from Components that mark them as dirty
    Immediate(ScopeId),

    /// A task has woken and needs to be progressed
    TaskNotified(slotmap::DefaultKey),

    /// An effect has been queued to run after the next render
    EffectQueued,
}

pub struct ScopeOrder {
    pub(crate) height: u32,
    pub(crate) id: ScopeId,
}

impl Ord for ScopeOrder {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.height.cmp(&other.height).then(self.id.cmp(&other.id))
    }
}

ScopeId(0) height=0 parent=None
ScopeId(1) height=1 parent=Some(ScopeId(0))
ScopeId(2) height=2 parent=Some(ScopeId(1))
ScopeId(3) height=3 parent=Some(ScopeId(2))
ScopeId(4) height=4 parent=Some(ScopeId(3))

fn app() -> Element {
  let mut a = use_signal(|| 0);
  let mut b = use_signal(|| 0);
  log(format!("App runs: a={a} b={b}"));
  rsx! {
    button {
      onclick: move |_| {
        a += 1;
        a += 1;
        b += 1;
        log("handler returns");
      },
      "a={a} b={b}"
    }
  }
}

App runs: a=0 b=0
-- handle_event(click)
handler returns
-- wait_for_work
  [trace] Marking scope ScopeId(3) as dirty
  [trace] Marking scope ScopeId(3) as dirty
  [trace] Marking scope ScopeId(3) as dirty
-- render_immediate
App runs: a=2 b=1
  edit: SetText "a=2 b=1" id=2
-- done

        match (dirty_scope, dirty_task) {
            (Some(scope), Some(task)) => {
                let tasks_order = task.borrow();
                match scope.cmp(tasks_order) {
                    std::cmp::Ordering::Less => {
                        let scope = self.dirty_scopes.pop_first().unwrap();
                        Some(Work::RerunScope(scope))
                    }
                    std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => {
                        Some(Work::PollTask(self.pop_task().unwrap()))
                    }
                }
            }
            (Some(_), None) => {
                let scope = self.dirty_scopes.pop_first().unwrap();
                Some(Work::RerunScope(scope))
            }
            (None, Some(_)) => Some(Work::PollTask(self.pop_task().unwrap())),
            (None, None) => None,
        }

fn app() -> Element {
  let mut p = use_signal(|| 0);
  let c = use_signal(|| 0);
  use_hook(|| PARENT_TASK.set(Some(spawn(forever("Parent task")))));
  log(format!("  Parent runs p={p}"));
  rsx! {
    button {
      onclick: move |_| {
        let mut c = c;
        match CASE.get() {
          1 => { c += 1; PARENT_TASK.get().unwrap().wake(); }
          2 => { p += 1; CHILD_TASK.get().unwrap().wake(); }
          _ => { c += 1; CHILD_TASK.get().unwrap().wake(); }
        }
      },
      "p={p}"
    }
    Child { c }
  }
}

#[component]
fn Child(c: Signal<i32>) -> Element {
  use_hook(|| CHILD_TASK.set(Some(spawn(forever("Child task")))));
  log(format!("  Child runs c={c}"));
  rsx! { "c={c}" }
}

  Parent runs p=0
  Child runs c=0
-- first render_immediate (polls the two new tasks)
  Parent task polled
  Child task polled
-- case 1: Child dirty + Parent task woken
  Parent task polled
  Child runs c=1
  edit: SetText "c=1" id=3
-- case 2: Parent dirty + Child task woken
  Parent runs p=1
  edit: SetText "p=1" id=2
  Child task polled

// Case A: child dirty first, parent dirty second; child props also change
fn app_a() -> Element {
  let mut p = use_signal(|| 0);
  let c = use_signal(|| 0);
  log(format!("Parent runs p={p}"));
  rsx! {
    button {
      onclick: move |_| {
        let mut c = c;
        c += 1; // child's own signal first
        p += 1; // then parent's
      },
      "p={p}"
    }
    Child { p: p(), c }
  }
}

#[component]
fn Child(p: i32, c: Signal<i32>) -> Element {
  log(format!("Child runs p={p} c={c}"));
  rsx! { "child {p} {c}" }
}

// Case B: the scheduler.rs example — parent drops the child that would panic
fn app_b() -> Element {
  let mut s: Signal<Option<i32>> = use_signal(|| Some(1));
  log(format!("Parent runs s={:?}", s()));
  rsx! {
    button { onclick: move |_| s.set(None), "clear" }
    if s.read().is_some() {
      Child2 { s }
    }
  }
}

#[component]
fn Child2(s: Signal<Option<i32>>) -> Element {
  let v = s.read().unwrap();
  log(format!("Child2 runs v={v}"));
  rsx! { "{v}" }
}

== case A
Parent runs p=0
Child runs p=0 c=0
-- click
  [trace] Marking scope ScopeId(4) as dirty
  [trace] Marking scope ScopeId(3) as dirty
-- render_immediate
Parent runs p=1
  edit: SetText "p=1" id=2
Child runs p=1 c=1
  edit: SetText "child 1 1" id=3
== case B
Parent runs s=Some(1)
Child2 runs v=1
-- click
  [trace] Marking scope ScopeId(4) as dirty
  [trace] Marking scope ScopeId(3) as dirty
-- render_immediate
Parent runs s=None
  edit: CreatePlaceholder id=3
  edit: ReplaceWith id=2 m=1

    pub async fn wait_for_work(&mut self) {
        loop {
            // Process all events - Scopes are marked dirty, etc
            // Sometimes when wakers fire we get a slew of updates at once, so its important that we drain this completely
            self.process_events();

            // Now that we have collected all queued work, we should check if we have any dirty scopes. If there are not, then we can poll any queued futures
            if self.has_dirty_scopes() {
                return;
            }

            // Make sure we set the runtime since we're running user code
            let _runtime = RuntimeGuard::new(self.runtime.clone());

            // There isn't any more work we can do synchronously. Wait for any new work to be ready
            self.wait_for_event().await;
        }
    }

        while !self.runtime.dirty_tasks.borrow().is_empty()
            || !self.runtime.pending_effects.borrow().is_empty()
        {
            // Next, run any queued tasks
            // We choose not to poll the deadline since we complete pretty quickly anyways
            while let Some(task) = self.pop_task() {
                let _ = self.runtime.handle_task_wakeup(task);

                // Running that task, may mark a scope higher up as dirty. If it does, return from the function early
                self.queue_events();
                if self.has_dirty_scopes() {
                    return;
                }
            }

            // At this point, we have finished running all tasks that are pending and we haven't found any scopes to rerun. This means it is safe to run our lowest priority work: effects
            while let Some(effect) = self.pop_effect() {
                effect.run();
                // Check if any new scopes are queued for rerun
                self.queue_events();
                if self.has_dirty_scopes() {
                    return;
                }
            }
        }

fn app() -> Element {
  let mut n = use_signal(|| 0);
  log(format!("App runs n={n}"));
  use_effect(move || log(format!("effect runs, sees n={n}")));
  rsx! {
    button { onclick: move |_| n += 1, "n={n}" }
  }
}

-- rebuild
App runs n=0
  edit: LoadTemplate index=0 id=1
  edit: NewEventListener click id=1
  edit: CreateTextNode "n=0" id=2
  edit: ReplacePlaceholder [0] m=1
  edit: AppendChildren id=0 m=1
effect runs, sees n=0
-- wait_for_work: timed out (nothing dirty)
-- click
-- wait_for_work: returned (dirty scope)
-- render_immediate
App runs n=1
  edit: SetText "n=1" id=2
-- render_immediate returned
effect runs, sees n=1
-- wait_for_work: timed out (nothing dirty)

pub(crate) struct LocalTask {
    scope: ScopeId,
    parent: Option<Task>,
    task: RefCell<Pin<Box<dyn Future<Output = ()> + 'static>>>,
    waker: Waker,
    ty: RefCell<TaskType>,
    active: Cell<bool>,
}

struct Guard(&'static str);
impl Drop for Guard {
  fn drop(&mut self) {
    log(format!("drop future: {}", self.0));
  }
}

#[component]
fn Child() -> Element {
  use_hook(|| {
    let g = Guard("spawn in Child");
    spawn(async move {
      let _g = g;
      log("task spawned in Child polled");
      std::future::pending::<()>().await;
    });
    let g = Guard("spawn_forever in Child");
    dioxus_core::spawn_forever(async move {
      let _g = g;
      log("task spawn_forever polled");
      std::future::pending::<()>().await;
    });
  });
  rsx! { "child" }
}

task spawn_forever polled
task spawned in Child polled
-- click hide
-- render_immediate
  edit: CreatePlaceholder id=3
  edit: ReplaceWith id=2 m=1
drop future: spawn in Child
-- drop VirtualDom
drop future: spawn_forever in Child
-- end

-- case 3: Child dirty + Child task woken
  Child task polled
  Child runs c=2
  edit: SetText "c=2" id=3