//! Meeting auto-capture — the single-signal variant.
//!
//! The frontend polls `detect_meeting_processes` on an interval with the
//! user's app patterns. On a positive hit it surfaces a non-modal toast
//! that reminds the user to start recording with their hotkey. We do not
//! start recording from this signal — the user decides.

use std::sync::Mutex;

use lumotia_core::process_watch::{self, ProcessLister};

/// Tauri-managed state for the meeting poller. Holds a long-lived
/// `ProcessLister` so each poll refreshes the existing `sysinfo::System`
/// in place instead of allocating a fresh one — the previous implementation
/// rebuilt the process table from scratch every 15 s.
pub struct MeetingState {
    lister: Mutex<ProcessLister>,
}

impl MeetingState {
    pub fn new() -> Self {
        Self {
            lister: Mutex::new(ProcessLister::new()),
        }
    }
}

impl Default for MeetingState {
    fn default() -> Self {
        Self::new()
    }
}

#[tauri::command]
pub fn detect_meeting_processes(
    state: tauri::State<'_, MeetingState>,
    patterns: Vec<String>,
) -> Result<Vec<String>, String> {
    if patterns.is_empty() {
        return Ok(Vec::new());
    }
    let processes = {
        let mut lister = state
            .lister
            .lock()
            .map_err(|e| format!("MeetingState lister poisoned: {e}"))?;
        lister.snapshot()
    };
    Ok(process_watch::match_meeting_patterns(&processes, &patterns))
}