use anyhow::Result;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use runtime_foxdriver::Page;
use std::time::Duration;
use crate::choice::chance_with_rng;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ScrollBehavior {
Reading,
Scanning,
Searching,
Idle,
}
impl ScrollBehavior {
fn base_velocity(self) -> f64 {
match self {
ScrollBehavior::Reading => 80.0,
ScrollBehavior::Scanning => 200.0,
ScrollBehavior::Searching => 420.0,
ScrollBehavior::Idle => 30.0,
}
}
fn friction(self) -> f64 {
match self {
ScrollBehavior::Reading => 0.72,
ScrollBehavior::Scanning => 0.65,
ScrollBehavior::Searching => 0.55,
ScrollBehavior::Idle => 0.80,
}
}
fn overshoot_probability(self) -> f64 {
match self {
ScrollBehavior::Reading => 0.05,
ScrollBehavior::Scanning => 0.12,
ScrollBehavior::Searching => 0.20,
ScrollBehavior::Idle => 0.02,
}
}
fn pause_range_ms(self) -> (u64, u64) {
match self {
ScrollBehavior::Reading => (600, 2000),
ScrollBehavior::Scanning => (200, 700),
ScrollBehavior::Searching => (50, 200),
ScrollBehavior::Idle => (2000, 8000),
}
}
}
#[derive(Debug, Clone)]
pub struct HumanScrollConfig {
pub total_px: i32,
pub behavior: ScrollBehavior,
pub flick_count: usize,
pub scroll_down: bool,
}
impl Default for HumanScrollConfig {
fn default() -> Self {
Self {
total_px: 800,
behavior: ScrollBehavior::Reading,
flick_count: 5,
scroll_down: true,
}
}
}
pub struct HumanScroller {
config: HumanScrollConfig,
}
impl HumanScroller {
#[must_use]
pub fn new(config: HumanScrollConfig) -> Self {
Self { config }
}
pub async fn scroll(&self, page: &Page) -> Result<()> {
let mut rng = StdRng::from_entropy();
let direction: f64 = if self.config.scroll_down { 1.0 } else { -1.0 };
let flick_amounts = self.distribute_flicks(&mut rng);
for flick_px in flick_amounts {
self.execute_flick(page, flick_px * direction, &mut rng)
.await?;
if chance_with_rng(self.config.behavior.overshoot_probability(), &mut rng) {
let overshoot = rng.gen_range(30..120) as f64 * direction;
Self::scroll_by(page, overshoot).await?;
tokio::time::sleep(Duration::from_millis(rng.gen_range(100..300))).await;
let correction = overshoot * rng.gen_range(0.6_f64..0.9);
Self::scroll_by(page, -correction).await?;
tokio::time::sleep(Duration::from_millis(rng.gen_range(80..200))).await;
}
let (lo, hi) = self.config.behavior.pause_range_ms();
let pause = rng.gen_range(lo..hi);
tokio::time::sleep(Duration::from_millis(pause)).await;
}
Ok(())
}
async fn execute_flick<R: Rng + ?Sized>(
&self,
page: &Page,
target_px: f64,
rng: &mut R,
) -> Result<()> {
let friction = self.config.behavior.friction();
let base_v = self.config.behavior.base_velocity();
let mut velocity = base_v * (1.0 + rng.gen_range(-0.20_f64..0.20)) * target_px.signum();
let mut remaining = target_px.abs();
let tick_ms: u64 = rng.gen_range(16..32);
while remaining > 1.0 && velocity.abs() > 1.0 {
let step = velocity.abs().min(remaining);
Self::scroll_by(page, step * target_px.signum()).await?;
remaining -= step;
velocity *= friction;
velocity += rng.gen_range(-2.0_f64..2.0);
tokio::time::sleep(Duration::from_millis(tick_ms)).await;
}
Ok(())
}
fn distribute_flicks<R: Rng + ?Sized>(&self, rng: &mut R) -> Vec<f64> {
let n = self.config.flick_count.max(1);
let weights: Vec<f64> = (0..n)
.map(|_| {
let u: f64 = rng.gen::<f64>().max(1e-12);
-u.ln() })
.collect();
let total_w: f64 = weights.iter().sum();
weights
.iter()
.map(|w| (w / total_w) * f64::from(self.config.total_px))
.collect()
}
async fn scroll_by(page: &Page, dy: f64) -> Result<()> {
let js = format!("window.scrollBy(0, {dy:.1})");
page.evaluate(js).await?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use rand::rngs::StdRng;
use rand::SeedableRng;
#[test]
fn searching_faster_than_reading() {
assert!(
ScrollBehavior::Searching.base_velocity() > ScrollBehavior::Reading.base_velocity()
);
}
#[test]
fn idle_slowest_velocity() {
assert!(ScrollBehavior::Idle.base_velocity() < ScrollBehavior::Reading.base_velocity());
}
#[test]
fn friction_between_zero_and_one() {
for b in [
ScrollBehavior::Reading,
ScrollBehavior::Scanning,
ScrollBehavior::Searching,
ScrollBehavior::Idle,
] {
let f = b.friction();
assert!(
(0.0..=1.0).contains(&f),
"friction {f} out of range for {b:?}"
);
}
}
#[test]
fn searching_lowest_friction() {
assert!(ScrollBehavior::Searching.friction() < ScrollBehavior::Reading.friction());
}
#[test]
fn overshoot_probability_valid() {
for b in [
ScrollBehavior::Reading,
ScrollBehavior::Scanning,
ScrollBehavior::Searching,
ScrollBehavior::Idle,
] {
let p = b.overshoot_probability();
assert!(
(0.0..=1.0).contains(&p),
"overshoot prob {p} out of range for {b:?}"
);
}
}
#[test]
fn searching_highest_overshoot_prob() {
assert!(
ScrollBehavior::Searching.overshoot_probability()
> ScrollBehavior::Reading.overshoot_probability()
);
}
#[test]
fn pause_range_lo_lt_hi() {
for b in [
ScrollBehavior::Reading,
ScrollBehavior::Scanning,
ScrollBehavior::Searching,
ScrollBehavior::Idle,
] {
let (lo, hi) = b.pause_range_ms();
assert!(lo < hi, "pause range lo {lo} >= hi {hi} for {b:?}");
}
}
#[test]
fn idle_has_longest_pauses() {
let (_, idle_hi) = ScrollBehavior::Idle.pause_range_ms();
let (_, scanning_hi) = ScrollBehavior::Scanning.pause_range_ms();
assert!(idle_hi > scanning_hi);
}
#[test]
fn distribute_flicks_correct_count() {
let scroller = HumanScroller::new(HumanScrollConfig {
flick_count: 7,
..Default::default()
});
let mut rng = StdRng::seed_from_u64(1);
let flicks = scroller.distribute_flicks(&mut rng);
assert_eq!(flicks.len(), 7);
}
#[test]
fn distribute_flicks_sum_matches_total() {
let total = 1200;
let scroller = HumanScroller::new(HumanScrollConfig {
total_px: total,
flick_count: 6,
..Default::default()
});
let mut rng = StdRng::seed_from_u64(2);
let flicks = scroller.distribute_flicks(&mut rng);
let sum: f64 = flicks.iter().sum();
assert!(
(sum - f64::from(total)).abs() < 1.0,
"sum {sum:.1} != {total}"
);
}
#[test]
fn distribute_flicks_all_positive() {
let scroller = HumanScroller::new(HumanScrollConfig::default());
let mut rng = StdRng::seed_from_u64(3);
for _ in 0..20 {
let flicks = scroller.distribute_flicks(&mut rng);
for f in flicks {
assert!(f > 0.0);
}
}
}
#[test]
fn distribute_flicks_unequal() {
let scroller = HumanScroller::new(HumanScrollConfig {
flick_count: 5,
total_px: 1000,
..Default::default()
});
let mut rng = StdRng::seed_from_u64(4);
let flicks = scroller.distribute_flicks(&mut rng);
let first = flicks[0];
let all_same = flicks.iter().all(|&f| (f - first).abs() < 0.01);
assert!(!all_same, "expected unequal flick distribution");
}
#[test]
fn default_config_sane() {
let cfg = HumanScrollConfig::default();
assert!(cfg.total_px > 0);
assert!(cfg.flick_count > 0);
assert!(cfg.scroll_down);
assert_eq!(cfg.behavior, ScrollBehavior::Reading);
}
}