#[tauri: :command]
pub async fn shift_timeline(
    state: State<'_, AppState>,
    start_from: i64,
    delta_minutes: i64
) -> Result<(), String> {
    let mut tasks = state.db
        .get_tasks_after(start_from)
        .await?;
    
    for task in tasks.iter_mut() {
        let new_start = task.planned_start + delta_minutes;
        
        // 언플러그드 타임(식사, 회의) 확인
        if let Some(conflict) = 
            check_unplugged_conflict(new_start, task.duration) 
        {
            // 충돌 시 태스크 분할 및 시프트
            split_and_reschedule(task, conflict).await?;
        } else {
            // 단순 시간 이동
            task.planned_start = new_start;
            state.db.update_task(task).await?;
        }
    }
    Ok(())
}

// Rust 백엔드: 동적 모델 폴백 엔진 (retrospective.rs)
let mut models_to_try = Vec::new();

// 1. 마지막 성공 모델 캐시 우선 시도
if let Some(ref cached_model) = user.last_successful_model {
    models_to_try.push(cached_model.clone());
}

// 2. API에서 사용 가능한 모델 동적 조회 및 우선순위 정렬
let available = internal_fetch_available_models(&api_key).await?;
available.sort_by(|a, b| {
    // flash-lite(3) > flash(2) > pro(1) 우선순위
    let score = |name: &str| match () {
        _ if name.contains("flash-lite") => 3,
        _ if name.contains("flash") => 2,
        _ if name.contains("pro") => 1,
        _ => 0,
    };
    score(&b.name).cmp(&score(&a.name))
});

for model in models_to_try {
    match try_generate_content(&client, &model, &prompt).await {
        Ok(text) => {
            // 성공 모델 DB 캐싱
            database::user::save_last_model(&pool, &model.name).await?;
            return Ok(text);
        }
        Err(e) => { eprintln!("Model {} failed: {}", model.name, e); continue; }
    }
}
Err("All Gemini models failed".into())

fun validate(sentence: String) {
    if (sentence.isBlank()) return

    // 1. 정책 기반 전처리 (공백, 숫자 제거 등)
    val filtered = applyPolicies(sentence, defaultPolicies)

    // 2. 일차 탐지
    val detectedBans = trie.parseText(filtered)
    if (detectedBans.isEmpty()) return

    // 3. 허용 단어(WhiteList) 제외 처리
    val allowTrie = getAllowTrie(defaultPolicies)
    val detectedAllows = allowTrie.parseText(filtered)

    val remains = detectedBans.asSequence()
        .filterNot { ban ->
            detectedAllows.any { allow ->
                overlaps(ban.start, ban.end, allow.start, allow.end)
            }
        }
        .map { it.payload.word }
        .distinct()
        .toList()

    if (remains.isNotEmpty()) {
        throw ProfanityDetectedException(remains)
    }
}

// 구간 중첩 판별: 두 구간이 겹치면 true
private fun overlaps(s1: Int, e1: Int, s2: Int, e2: Int) =
    s1 <= e2 && s2 <= e1

// 허용 단어 Trie를 정책 조합별로 캐싱
private fun getAllowTrie(
    policies: Set<ProfanityFilterRegex>
): PayloadTrie<String> {
    return allowTrieCache.computeIfAbsent(policies) { key ->
        val builder = PayloadTrie.builder<String>()
        allowWords.forEach { word ->
            val normalized = applyPolicies(word, key)
            if (normalized.isNotBlank())
                builder.addKeyword(normalized, normalized)
        }
        builder.build()
    }
}