use anyhow::Result;
use rand::Rng;
use runtime_foxdriver::Page;
use std::time::Duration;
use crate::choice::{chance_with_rng, random_item_with_rng};
use crate::sampling::standard_normal;
const COMMON_WORDS: &[&str] = &[
"the", "be", "to", "of", "and", "a", "in", "that", "have", "it", "for", "not", "on", "with",
"he", "as", "you", "do", "at", "this", "but", "his", "by", "from", "they", "we", "say", "her",
"she", "or", "an", "will", "my", "one", "all", "would", "there", "their", "what", "so", "up",
"out", "if", "about", "who", "get", "which", "go", "me", "when", "make", "can", "like", "time",
"no", "just", "him", "know", "take", "into", "your", "good", "some", "could", "them", "see",
"other", "than", "then", "now", "look", "only", "come", "its", "over", "think", "also", "back",
"after", "use", "two", "how", "our", "work", "first", "well", "way", "even", "new", "want",
"because", "any", "these", "give", "day", "most", "us",
];
const KEYBOARD_ROWS: &[&[char]] = &[
&['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'],
&['a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l'],
&['z', 'x', 'c', 'v', 'b', 'n', 'm'],
];
#[derive(Debug, Clone)]
pub struct TypingConfig {
pub wpm: f64,
pub typo_rate: f64,
pub shift_delay_ms: u64,
pub digit_speed_factor: f64,
pub symbol_speed_factor: f64,
}
impl Default for TypingConfig {
fn default() -> Self {
Self {
wpm: 60.0,
typo_rate: 0.03,
shift_delay_ms: 80,
digit_speed_factor: 1.4,
symbol_speed_factor: 1.8,
}
}
}
impl TypingConfig {
pub fn with_wpm(wpm: f64) -> Self {
Self {
wpm: wpm.clamp(40.0, 80.0),
..Default::default()
}
}
}
pub struct HumanTyper {
config: TypingConfig,
}
impl HumanTyper {
pub fn new(config: TypingConfig) -> Self {
Self { config }
}
pub async fn type_text(&self, page: &Page, text: &str) -> Result<()> {
let mut rng = rand::thread_rng();
let chars: Vec<char> = text.chars().collect();
let mut i = 0;
while i < chars.len() {
let word_len = Self::word_len_at(&chars, i);
let word: String = chars[i..i + word_len].iter().collect();
let is_common = is_common_word(&word);
for j in 0..word_len {
let ch = chars[i + j];
self.type_char(page, ch, is_common, &mut rng).await?;
}
i += word_len;
if word_len == 0 {
let ch = chars[i];
self.type_char(page, ch, false, &mut rng).await?;
i += 1;
}
}
Ok(())
}
async fn type_char<R: Rng>(
&self,
page: &Page,
ch: char,
is_common_word_context: bool,
rng: &mut R,
) -> Result<()> {
if !ch.is_whitespace() && chance_with_rng(self.config.typo_rate, rng) {
if let Some(typo_ch) = adjacent_key(ch, rng) {
let typo_str = typo_ch.to_string();
page.type_text(&typo_str).await?;
tokio::time::sleep(Duration::from_millis(rng.gen_range(80..180))).await;
page.type_text("\u{0008}").await?;
tokio::time::sleep(Duration::from_millis(rng.gen_range(60..140))).await;
}
}
if ch.is_uppercase() {
tokio::time::sleep(Duration::from_millis(
self.config.shift_delay_ms + rng.gen_range(0..40),
))
.await;
}
let ch_str = ch.to_string();
page.type_text(&ch_str).await?;
tokio::time::sleep(Duration::from_millis(rng.gen_range(30..80))).await;
let base_delay = self.base_delay_ms();
let delay = self.inter_key_delay(ch, is_common_word_context, base_delay, rng);
tokio::time::sleep(Duration::from_millis(delay)).await;
Ok(())
}
fn base_delay_ms(&self) -> f64 {
let chars_per_sec = self.config.wpm * 5.0 / 60.0;
1000.0 / chars_per_sec
}
fn inter_key_delay<R: Rng>(&self, ch: char, is_common: bool, base_ms: f64, rng: &mut R) -> u64 {
let category_factor = if ch.is_ascii_digit() {
self.config.digit_speed_factor
} else if !ch.is_alphabetic() && !ch.is_whitespace() {
self.config.symbol_speed_factor
} else if is_common {
0.7 } else {
1.0
};
let sigma = 0.3_f64;
let z = standard_normal(rng);
let lognormal = (sigma * z).exp();
let jittered = base_ms * category_factor * lognormal;
let extra = if chance_with_rng(0.05, rng) {
rng.gen_range(300..800) as f64
} else {
0.0
};
(jittered + extra).round() as u64
}
fn word_len_at(chars: &[char], pos: usize) -> usize {
chars[pos..]
.iter()
.take_while(|c| c.is_alphabetic() || **c == '\'')
.count()
}
}
impl Default for HumanTyper {
fn default() -> Self {
Self::new(TypingConfig::default())
}
}
fn is_common_word(word: &str) -> bool {
let lower = word.to_lowercase();
COMMON_WORDS.contains(&lower.as_str())
}
fn adjacent_key<R: Rng>(ch: char, rng: &mut R) -> Option<char> {
let lower = ch.to_lowercase().next()?;
for (ri, row) in KEYBOARD_ROWS.iter().enumerate() {
if let Some(ci) = row.iter().position(|&k| k == lower) {
let mut candidates: Vec<char> = Vec::new();
if ci > 0 {
candidates.push(row[ci - 1]);
}
if ci + 1 < row.len() {
candidates.push(row[ci + 1]);
}
if ri > 0 {
let above = KEYBOARD_ROWS[ri - 1];
let mapped = ci.min(above.len().saturating_sub(1));
candidates.push(above[mapped]);
}
if ri + 1 < KEYBOARD_ROWS.len() {
let below = KEYBOARD_ROWS[ri + 1];
let mapped = ci.min(below.len().saturating_sub(1));
candidates.push(below[mapped]);
}
if candidates.is_empty() {
return None;
}
return random_item_with_rng(&candidates, rng).copied();
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_config_wpm_in_range() {
let cfg = TypingConfig::default();
assert!(cfg.wpm >= 40.0 && cfg.wpm <= 80.0);
}
#[test]
fn default_typer_uses_default_config() {
let typer = HumanTyper::default();
assert_eq!(typer.config.wpm, TypingConfig::default().wpm);
assert_eq!(typer.config.typo_rate, TypingConfig::default().typo_rate);
}
#[test]
fn with_wpm_clamps_low() {
let cfg = TypingConfig::with_wpm(10.0);
assert_eq!(cfg.wpm, 40.0);
}
#[test]
fn with_wpm_clamps_high() {
let cfg = TypingConfig::with_wpm(200.0);
assert_eq!(cfg.wpm, 80.0);
}
#[test]
fn with_wpm_exact() {
let cfg = TypingConfig::with_wpm(55.0);
assert!((cfg.wpm - 55.0).abs() < f64::EPSILON);
}
#[test]
fn base_delay_at_60wpm_is_200ms() {
let typer = HumanTyper::new(TypingConfig::with_wpm(60.0));
let d = typer.base_delay_ms();
assert!((d - 200.0).abs() < 1.0, "expected ≈200 ms, got {d}");
}
#[test]
fn base_delay_at_40wpm_is_300ms() {
let typer = HumanTyper::new(TypingConfig::with_wpm(40.0));
let d = typer.base_delay_ms();
assert!((d - 300.0).abs() < 1.0, "expected ≈300 ms, got {d}");
}
#[test]
fn inter_key_delay_digits_slower() {
let typer = HumanTyper::new(TypingConfig::default());
let base = typer.base_delay_ms();
let mut rng = rand::thread_rng();
let sum_digit: f64 = (0..200)
.map(|_| typer.inter_key_delay('7', false, base, &mut rng) as f64)
.sum();
let sum_alpha: f64 = (0..200)
.map(|_| typer.inter_key_delay('a', false, base, &mut rng) as f64)
.sum();
assert!(
sum_digit > sum_alpha,
"digits avg {:.0} should exceed alpha avg {:.0}",
sum_digit / 200.0,
sum_alpha / 200.0
);
}
#[test]
fn inter_key_delay_common_word_faster() {
let typer = HumanTyper::new(TypingConfig::default());
let base = typer.base_delay_ms();
let mut rng = rand::thread_rng();
let sum_common: f64 = (0..200)
.map(|_| typer.inter_key_delay('a', true, base, &mut rng) as f64)
.sum();
let sum_rare: f64 = (0..200)
.map(|_| typer.inter_key_delay('a', false, base, &mut rng) as f64)
.sum();
assert!(
sum_common < sum_rare,
"common avg {:.0} should be below rare avg {:.0}",
sum_common / 200.0,
sum_rare / 200.0
);
}
#[test]
fn sample_normal_reasonable_range() {
let mut rng = rand::thread_rng();
let samples: Vec<f64> = (0..1000).map(|_| standard_normal(&mut rng)).collect();
let mean = samples.iter().sum::<f64>() / samples.len() as f64;
assert!(mean.abs() < 0.15, "normal mean {mean:.3} should be near 0");
}
#[test]
fn adjacent_key_returns_different_char() {
let mut rng = rand::thread_rng();
let typo = adjacent_key('f', &mut rng);
assert!(typo.is_some());
assert_ne!(typo.unwrap(), 'f');
}
#[test]
fn adjacent_key_unknown_returns_none() {
let mut rng = rand::thread_rng();
let typo = adjacent_key('🦀', &mut rng);
assert!(typo.is_none());
}
#[test]
fn is_common_word_recognizes_the() {
assert!(is_common_word("the"));
assert!(is_common_word("The"));
assert!(is_common_word("THE"));
}
#[test]
fn is_common_word_rejects_rare() {
assert!(!is_common_word("supercalifragilistic"));
assert!(!is_common_word("xylophone"));
}
#[test]
fn word_len_at_extracts_word() {
let chars: Vec<char> = "hello world".chars().collect();
assert_eq!(HumanTyper::word_len_at(&chars, 0), 5);
assert_eq!(HumanTyper::word_len_at(&chars, 6), 5);
}
#[test]
fn word_len_at_non_alpha_is_zero() {
let chars: Vec<char> = ", test".chars().collect();
assert_eq!(HumanTyper::word_len_at(&chars, 0), 0);
}
#[test]
fn config_typo_rate_default() {
let cfg = TypingConfig::default();
assert!((cfg.typo_rate - 0.03).abs() < f64::EPSILON);
}
#[test]
fn config_shift_delay_positive() {
let cfg = TypingConfig::default();
assert!(cfg.shift_delay_ms > 0);
}
#[test]
fn config_symbol_speed_factor_gt_digit() {
let cfg = TypingConfig::default();
assert!(cfg.symbol_speed_factor > cfg.digit_speed_factor);
}
}