Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

41.0 KB
Raw Blame
use crate::{
    NewScreenshotAdded, NewStudioRecordingAdded, RecordingStarted, RecordingStopped,
    RequestOpenSettings, recording,
    recording_settings::{RecordingSettingsStore, RecordingTargetMode},
    windows::ShowCapWindow,
};
use cap_recording::RecordingMode;

use cap_project::{RecordingMeta, RecordingMetaInner};
use std::sync::atomic::{AtomicBool, Ordering};
use std::{
    path::PathBuf,
    sync::{Arc, Mutex},
};
use tauri::Manager;
use tauri::menu::{IconMenuItem, MenuId, PredefinedMenuItem, Submenu};
use tauri::{
    AppHandle,
    image::Image,
    menu::{Menu, MenuItem},
    tray::{TrayIcon, TrayIconBuilder},
};
use tauri_plugin_dialog::DialogExt;
use tauri_plugin_opener::OpenerExt;
use tauri_specta::Event;

const PREVIOUS_ITEM_PREFIX: &str = "previous_item_";
const MAX_PREVIOUS_ITEMS: usize = 6;
const MAX_TITLE_LENGTH: usize = 30;
const THUMBNAIL_SIZE: u32 = 32;

#[cfg(target_os = "linux")]
#[derive(Clone, Copy)]
enum LinuxTrayIcon {
    Instant,
    Screenshot,
    Studio,
    Stop,
}

#[cfg(target_os = "linux")]
impl LinuxTrayIcon {
    fn name(self) -> &'static str {
        match self {
            Self::Instant => "so.cap.desktop-tray-instant-symbolic",
            Self::Screenshot => "so.cap.desktop-tray-screenshot-symbolic",
            Self::Studio => "so.cap.desktop-tray-studio-symbolic",
            Self::Stop => "so.cap.desktop-tray-stop-symbolic",
        }
    }

    fn svg(self) -> &'static str {
        match self {
            Self::Instant => {
                include_str!("../icons/linux/so.cap.desktop-tray-instant-symbolic.svg")
            }
            Self::Screenshot => {
                include_str!("../icons/linux/so.cap.desktop-tray-screenshot-symbolic.svg")
            }
            Self::Studio => include_str!("../icons/linux/so.cap.desktop-tray-studio-symbolic.svg"),
            Self::Stop => include_str!("../icons/linux/so.cap.desktop-tray-stop-symbolic.svg"),
        }
    }
}

#[derive(Debug)]
pub enum TrayItem {
    OpenCap,
    RecordDisplay,
    RecordWindow,
    RecordArea,
    TakeScreenshot,
    ImportVideo,
    ViewAllRecordings,
    ViewAllScreenshots,
    OpenSettings,
    UploadLogs,
    Quit,
    PreviousItem(String),
    ModeStudio,
    ModeInstant,
    ModeScreenshot,
    RequestPermissions,
}

impl From<TrayItem> for MenuId {
    fn from(value: TrayItem) -> Self {
        match value {
            TrayItem::OpenCap => "open_cap",
            TrayItem::RecordDisplay => "record_display",
            TrayItem::RecordWindow => "record_window",
            TrayItem::RecordArea => "record_area",
            TrayItem::TakeScreenshot => "take_screenshot",
            TrayItem::ImportVideo => "import_video",
            TrayItem::ViewAllRecordings => "view_all_recordings",
            TrayItem::ViewAllScreenshots => "view_all_screenshots",
            TrayItem::OpenSettings => "open_settings",
            TrayItem::UploadLogs => "upload_logs",
            TrayItem::Quit => "quit",
            TrayItem::PreviousItem(id) => {
                return format!("{PREVIOUS_ITEM_PREFIX}{id}").into();
            }
            TrayItem::ModeStudio => "mode_studio",
            TrayItem::ModeInstant => "mode_instant",
            TrayItem::ModeScreenshot => "mode_screenshot",
            TrayItem::RequestPermissions => "request_permissions",
        }
        .into()
    }
}

impl TryFrom<MenuId> for TrayItem {
    type Error = String;

    fn try_from(value: MenuId) -> Result<Self, Self::Error> {
        let id_str = value.0.as_str();

        if let Some(path) = id_str.strip_prefix(PREVIOUS_ITEM_PREFIX) {
            return Ok(TrayItem::PreviousItem(path.to_string()));
        }

        match id_str {
            "open_cap" => Ok(TrayItem::OpenCap),
            "record_display" => Ok(TrayItem::RecordDisplay),
            "record_window" => Ok(TrayItem::RecordWindow),
            "record_area" => Ok(TrayItem::RecordArea),
            "take_screenshot" => Ok(TrayItem::TakeScreenshot),
            "import_video" => Ok(TrayItem::ImportVideo),
            "view_all_recordings" => Ok(TrayItem::ViewAllRecordings),
            "view_all_screenshots" => Ok(TrayItem::ViewAllScreenshots),
            "open_settings" => Ok(TrayItem::OpenSettings),
            "upload_logs" => Ok(TrayItem::UploadLogs),
            "quit" => Ok(TrayItem::Quit),
            "mode_studio" => Ok(TrayItem::ModeStudio),
            "mode_instant" => Ok(TrayItem::ModeInstant),
            "mode_screenshot" => Ok(TrayItem::ModeScreenshot),
            "request_permissions" => Ok(TrayItem::RequestPermissions),
            value => Err(format!("Invalid tray item id {value}")),
        }
    }
}

#[derive(Debug, Clone)]
enum PreviousItemType {
    StudioRecording,
    InstantRecording {
        #[allow(dead_code)]
        link: Option<String>,
    },
    Screenshot,
}

#[derive(Clone)]
struct CachedPreviousItem {
    path: PathBuf,
    pretty_name: String,
    thumbnail: Option<Vec<u8>>,
    thumbnail_width: u32,
    thumbnail_height: u32,
    item_type: PreviousItemType,
}

#[derive(Default)]
struct PreviousItemsCache {
    items: Vec<CachedPreviousItem>,
    revision: u64,
    loaded: bool,
}

impl PreviousItemsCache {
    fn invalidate(&mut self) {
        self.revision = self.revision.wrapping_add(1);
    }

    fn finish_loading(&mut self, revision: u64, items: Vec<CachedPreviousItem>) -> bool {
        if self.revision != revision {
            return false;
        }
        self.items = items;
        self.loaded = true;
        self.invalidate();
        true
    }
}

fn screenshots_path(app: &AppHandle) -> PathBuf {
    let path = app.path().app_data_dir().unwrap().join("screenshots");
    std::fs::create_dir_all(&path).unwrap_or_default();
    path
}

fn truncate_title(title: &str) -> String {
    if title.chars().count() <= MAX_TITLE_LENGTH {
        title.to_string()
    } else {
        let truncate_at = MAX_TITLE_LENGTH - 1;
        let byte_index = title
            .char_indices()
            .nth(truncate_at)
            .map(|(i, _)| i)
            .unwrap_or(title.len());
        format!("{}…", &title[..byte_index])
    }
}

fn load_thumbnail_data(path: &PathBuf) -> Option<(Vec<u8>, u32, u32)> {
    use image::imageops::FilterType;
    use image::{GenericImageView, RgbaImage};

    let image_data = std::fs::read(path).ok()?;
    let img = image::load_from_memory(&image_data).ok()?;

    let (orig_w, orig_h) = img.dimensions();
    let size = THUMBNAIL_SIZE;

    let scale = (size as f32 / orig_w as f32).max(size as f32 / orig_h as f32);
    let scaled_w = (orig_w as f32 * scale).round() as u32;
    let scaled_h = (orig_h as f32 * scale).round() as u32;

    let scaled = img.resize_exact(scaled_w, scaled_h, FilterType::Triangle);

    let x_offset = (scaled_w.saturating_sub(size)) / 2;
    let y_offset = (scaled_h.saturating_sub(size)) / 2;

    let mut result = RgbaImage::new(size, size);
    for y in 0..size {
        for x in 0..size {
            let src_x = x + x_offset;
            let src_y = y + y_offset;
            if src_x < scaled_w && src_y < scaled_h {
                result.put_pixel(x, y, scaled.get_pixel(src_x, src_y));
            }
        }
    }

    Some((result.into_raw(), size, size))
}

fn load_single_item(
    path: &PathBuf,
    screenshots_dir: &PathBuf,
    load_thumbnail: bool,
) -> Option<CachedPreviousItem> {
    if !path.is_dir() {
        return None;
    }

    let meta = RecordingMeta::load_for_project(path).ok()?;
    let is_screenshot = path.extension().and_then(|s| s.to_str()) == Some("cap")
        && path.parent().map(|p| p == screenshots_dir).unwrap_or(false);

    let (thumbnail_path, item_type) = if is_screenshot {
        let png_path = std::fs::read_dir(path).ok().and_then(|dir| {
            dir.flatten()
                .find(|e| e.path().extension().and_then(|s| s.to_str()) == Some("png"))
                .map(|e| e.path())
        });
        (png_path, PreviousItemType::Screenshot)
    } else {
        let thumb = path.join("screenshots/display.jpg");
        let thumb_path = if thumb.exists() { Some(thumb) } else { None };
        let item_type = match &meta.inner {
            RecordingMetaInner::Studio(_) => PreviousItemType::StudioRecording,
            RecordingMetaInner::Instant(_) => PreviousItemType::InstantRecording {
                link: meta.sharing.as_ref().map(|s| s.link.clone()),
            },
        };
        (thumb_path, item_type)
    };

    let (thumbnail, thumbnail_width, thumbnail_height) = if load_thumbnail {
        thumbnail_path
            .as_ref()
            .and_then(load_thumbnail_data)
            .map(|(data, w, h)| (Some(data), w, h))
            .unwrap_or((None, 0, 0))
    } else {
        (None, 0, 0)
    };

    Some(CachedPreviousItem {
        path: path.clone(),
        pretty_name: meta.pretty_name,
        thumbnail,
        thumbnail_width,
        thumbnail_height,
        item_type,
    })
}

fn load_all_previous_items(app: &AppHandle, load_thumbnails: bool) -> Vec<CachedPreviousItem> {
    let mut paths = Vec::new();
    let screenshots_dir = screenshots_path(app);

    for recordings_dir in crate::recordings_locations::known_recordings_dirs(app) {
        let Ok(entries) = std::fs::read_dir(&recordings_dir) else {
            continue;
        };
        for entry in entries.flatten() {
            paths.push(entry.path());
        }
    }

    if screenshots_dir.exists()
        && let Ok(entries) = std::fs::read_dir(&screenshots_dir)
    {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.extension().and_then(|s| s.to_str()) == Some("cap") {
                paths.push(path);
            }
        }
    }

    newest_valid_items(paths, MAX_PREVIOUS_ITEMS, |path| {
        load_single_item(path, &screenshots_dir, load_thumbnails)
    })
}

fn newest_valid_items<T>(
    paths: Vec<PathBuf>,
    limit: usize,
    mut load: impl FnMut(&PathBuf) -> Option<T>,
) -> Vec<T> {
    let mut candidates = paths
        .into_iter()
        .filter_map(|path| {
            let metadata = path.metadata().ok()?;
            metadata.is_dir().then(|| {
                let created = metadata
                    .created()
                    .unwrap_or_else(|_| std::time::SystemTime::now());
                (path, created)
            })
        })
        .collect::<Vec<_>>();
    candidates.sort_by_key(|(_, created)| std::cmp::Reverse(*created));
    candidates
        .into_iter()
        .filter_map(|(path, _)| load(&path))
        .take(limit)
        .collect()
}

fn load_previous_items_in_background(app: AppHandle, cache: Arc<Mutex<PreviousItemsCache>>) {
    tokio::spawn(async move {
        if !crate::startup::wait_for_window(&app).await {
            return;
        }
        let worker_app = app.clone();
        let worker_cache = cache.clone();
        let result = tokio::task::spawn_blocking(move || {
            while !crate::app_is_exiting(&worker_app) {
                let revision = worker_cache.lock().unwrap().revision;
                let items = load_all_previous_items(&worker_app, true);
                if worker_cache.lock().unwrap().finish_loading(revision, items) {
                    return;
                }
            }
        })
        .await;
        if let Err(error) = result {
            tracing::warn!(%error, "Failed to load tray history");
        }
        if !crate::app_is_exiting(&app) {
            refresh_tray_menu(&app, &cache);
        }
    });
}

fn create_previous_submenu(
    app: &AppHandle,
    cache: &PreviousItemsCache,
) -> tauri::Result<Submenu<tauri::Wry>> {
    if cache.items.is_empty() {
        let submenu = Submenu::with_id(app, "previous", "Previous", false)?;
        submenu.append(&MenuItem::with_id(
            app,
            "previous_empty",
            if cache.loaded {
                "No recent items"
            } else {
                "Loading recent items…"
            },
            false,
            None::<&str>,
        )?)?;
        return Ok(submenu);
    }

    let submenu = Submenu::with_id(app, "previous", "Previous", true)?;

    for item in &cache.items {
        let id = TrayItem::PreviousItem(item.path.to_string_lossy().to_string());
        let title = truncate_title(&item.pretty_name);

        let type_indicator = match &item.item_type {
            PreviousItemType::StudioRecording => "🎬 ",
            PreviousItemType::InstantRecording { .. } => "⚡ ",
            PreviousItemType::Screenshot => "📷 ",
        };
        let display_title = format!("{type_indicator}{title}");

        let icon = item.thumbnail.as_ref().map(|data| {
            Image::new_owned(data.clone(), item.thumbnail_width, item.thumbnail_height)
        });

        let menu_item = IconMenuItem::with_id(app, id, display_title, true, icon, None::<&str>)?;
        submenu.append(&menu_item)?;
    }

    Ok(submenu)
}

fn get_current_mode(app: &AppHandle) -> RecordingMode {
    RecordingSettingsStore::get(app)
        .ok()
        .flatten()
        .and_then(|s| s.mode)
        .unwrap_or_default()
}

fn should_use_minimal_onboarding_tray_menu(app: &AppHandle) -> bool {
    if !app.webview_windows().contains_key("onboarding") {
        return false;
    }
    !crate::permissions::do_permissions_check(false).necessary_granted()
}

pub(crate) struct TrayMenuCache {
    cache: Arc<Mutex<PreviousItemsCache>>,
}

pub(crate) fn refresh_tray_menu_for_app(app: &AppHandle) {
    let Some(state) = app.try_state::<TrayMenuCache>() else {
        return;
    };
    refresh_tray_menu(app, &state.cache);
}

fn create_mode_submenu(app: &AppHandle) -> tauri::Result<Submenu<tauri::Wry>> {
    let current_mode = get_current_mode(app);

    let submenu = Submenu::with_id(app, "select_mode", "Select Mode", true)?;

    let modes = [
        (TrayItem::ModeStudio, RecordingMode::Studio, "Studio"),
        (TrayItem::ModeInstant, RecordingMode::Instant, "Instant"),
        (
            TrayItem::ModeScreenshot,
            RecordingMode::Screenshot,
            "Screenshot",
        ),
    ];

    for (tray_item, mode, label) in modes {
        let is_selected = current_mode == mode;
        let display_label = if is_selected {
            format!("✓ {label}")
        } else {
            format!("   {label}")
        };

        let menu_item = MenuItem::with_id(app, tray_item, display_label, true, None::<&str>)?;
        submenu.append(&menu_item)?;
    }

    Ok(submenu)
}

fn build_tray_menu(app: &AppHandle, cache: &PreviousItemsCache) -> tauri::Result<Menu<tauri::Wry>> {
    if should_use_minimal_onboarding_tray_menu(app) {
        return Menu::with_items(
            app,
            &[
                &MenuItem::with_id(
                    app,
                    TrayItem::RequestPermissions,
                    "Request Permissions",
                    true,
                    None::<&str>,
                )?,
                &PredefinedMenuItem::separator(app)?,
                &MenuItem::with_id(
                    app,
                    "version",
                    format!("Cap v{}", env!("CARGO_PKG_VERSION")),
                    false,
                    None::<&str>,
                )?,
                &MenuItem::with_id(app, TrayItem::Quit, "Quit Cap", true, None::<&str>)?,
            ],
        );
    }

    let previous_submenu = create_previous_submenu(app, cache)?;
    let mode_submenu = create_mode_submenu(app)?;
    let current_mode = get_current_mode(app);
    let is_screenshot_mode = current_mode == RecordingMode::Screenshot;

    let menu = Menu::new(app)?;

    menu.append(&MenuItem::with_id(
        app,
        TrayItem::OpenCap,
        "Open Main Window",
        true,
        None::<&str>,
    )?)?;

    if is_screenshot_mode {
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordDisplay,
            "Screenshot Display",
            true,
            None::<&str>,
        )?)?;
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordWindow,
            "Screenshot Window",
            true,
            None::<&str>,
        )?)?;
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordArea,
            "Screenshot Area",
            true,
            None::<&str>,
        )?)?;
    } else {
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordDisplay,
            "Record Display",
            true,
            None::<&str>,
        )?)?;
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordWindow,
            "Record Window",
            true,
            None::<&str>,
        )?)?;
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::RecordArea,
            "Record Area",
            true,
            None::<&str>,
        )?)?;
        menu.append(&MenuItem::with_id(
            app,
            TrayItem::TakeScreenshot,
            "Take a Screenshot",
            true,
            None::<&str>,
        )?)?;
    }

    menu.append(&MenuItem::with_id(
        app,
        TrayItem::ImportVideo,
        "Import Media...",
        true,
        None::<&str>,
    )?)?;

    menu.append(&PredefinedMenuItem::separator(app)?)?;
    menu.append(&mode_submenu)?;
    menu.append(&previous_submenu)?;
    menu.append(&PredefinedMenuItem::separator(app)?)?;

    menu.append(&MenuItem::with_id(
        app,
        TrayItem::ViewAllRecordings,
        "View all recordings",
        true,
        None::<&str>,
    )?)?;
    menu.append(&MenuItem::with_id(
        app,
        TrayItem::ViewAllScreenshots,
        "View all screenshots",
        true,
        None::<&str>,
    )?)?;
    menu.append(&MenuItem::with_id(
        app,
        TrayItem::OpenSettings,
        "Settings",
        true,
        None::<&str>,
    )?)?;

    menu.append(&PredefinedMenuItem::separator(app)?)?;
    menu.append(&MenuItem::with_id(
        app,
        TrayItem::UploadLogs,
        "Upload Logs",
        true,
        None::<&str>,
    )?)?;
    menu.append(&MenuItem::with_id(
        app,
        "version",
        format!("Cap v{}", env!("CARGO_PKG_VERSION")),
        false,
        None::<&str>,
    )?)?;
    menu.append(&MenuItem::with_id(
        app,
        TrayItem::Quit,
        "Quit Cap",
        true,
        None::<&str>,
    )?)?;

    Ok(menu)
}

fn add_new_item_to_cache(cache: &Arc<Mutex<PreviousItemsCache>>, app: &AppHandle, path: PathBuf) {
    let screenshots_dir = screenshots_path(app);

    let Some(new_item) = load_single_item(&path, &screenshots_dir, true) else {
        return;
    };

    let mut cache_guard = cache.lock().unwrap();

    cache_guard.items.retain(|item| item.path != path);

    cache_guard.items.insert(0, new_item);

    cache_guard.items.truncate(MAX_PREVIOUS_ITEMS);
    cache_guard.invalidate();
}

fn refresh_tray_menu(app: &AppHandle, cache: &Arc<Mutex<PreviousItemsCache>>) {
    let app_clone = app.clone();
    let cache_clone = cache.clone();

    let _ = app.run_on_main_thread(move || {
        let Some(tray) = app_clone.tray_by_id("tray") else {
            return;
        };

        let cache_guard = cache_clone.lock().unwrap();
        if let Ok(menu) = build_tray_menu(&app_clone, &cache_guard) {
            let _ = tray.set_menu(Some(menu));
        }
    });
}

fn handle_previous_item_click(app: &AppHandle, path_str: &str) {
    let path = PathBuf::from(path_str);

    let screenshots_dir = screenshots_path(app);
    let is_screenshot = path.extension().and_then(|s| s.to_str()) == Some("cap")
        && path.parent().map(|p| p == screenshots_dir).unwrap_or(false);

    if is_screenshot {
        let app = app.clone();
        let screenshot_path = path;
        tokio::spawn(async move {
            let _ = ShowCapWindow::ScreenshotEditor {
                path: screenshot_path,
            }
            .show(&app)
            .await;
        });
        return;
    }

    let meta = match RecordingMeta::load_for_project(&path) {
        Ok(m) => m,
        Err(e) => {
            tracing::error!("Failed to load recording meta for previous item: {e}");
            return;
        }
    };

    match &meta.inner {
        RecordingMetaInner::Studio(_) => {
            let app = app.clone();
            let project_path = path.clone();
            tokio::spawn(async move {
                let _ = ShowCapWindow::Editor { project_path }.show(&app).await;
            });
        }
        RecordingMetaInner::Instant(_) => {
            if let Some(sharing) = &meta.sharing {
                let _ = app.opener().open_url(&sharing.link, None::<String>);
            } else {
                let mp4_path = path.join("content/output.mp4");
                if mp4_path.exists() {
                    let _ = app
                        .opener()
                        .open_path(mp4_path.to_str().unwrap_or_default(), None::<String>);
                }
            }
        }
    }
}

pub fn get_tray_icon() -> &'static [u8] {
    include_bytes!("../icons/tray-default-icon.png")
}

pub fn get_mode_icon(mode: RecordingMode) -> &'static [u8] {
    if cfg!(target_os = "windows") {
        return get_tray_icon();
    }
    match mode {
        RecordingMode::Studio => include_bytes!("../icons/tray-default-icon-studio.png"),
        RecordingMode::Instant => include_bytes!("../icons/tray-default-icon-instant.png"),
        RecordingMode::Screenshot => include_bytes!("../icons/tray-default-icon-screenshot.png"),
    }
}

#[cfg(target_os = "linux")]
fn linux_tray_icon_for_mode(mode: RecordingMode) -> LinuxTrayIcon {
    match mode {
        RecordingMode::Studio => LinuxTrayIcon::Studio,
        RecordingMode::Instant => LinuxTrayIcon::Instant,
        RecordingMode::Screenshot => LinuxTrayIcon::Screenshot,
    }
}

#[cfg(target_os = "linux")]
fn write_linux_tray_symbolic_icon(icon: LinuxTrayIcon) -> std::io::Result<PathBuf> {
    let dir = dirs::runtime_dir()
        .unwrap_or_else(std::env::temp_dir)
        .join("cap-tray-icons");
    std::fs::create_dir_all(&dir)?;

    let path = dir.join(format!("{}.svg", icon.name()));
    let svg = icon.svg().as_bytes();
    if std::fs::read(&path).ok().as_deref() != Some(svg) {
        std::fs::write(path, svg)?;
    }

    Ok(dir)
}

#[cfg(target_os = "linux")]
fn set_linux_tray_icon(tray: &TrayIcon<tauri::Wry>, icon: LinuxTrayIcon) -> tauri::Result<()> {
    let icon_dir = write_linux_tray_symbolic_icon(icon).map_err(tauri::Error::Io)?;
    let icon_name = icon.name().to_string();

    tray.with_inner_tray_icon(move |inner| unsafe {
        let indicator = inner.app_indicator() as *mut libappindicator::AppIndicator;
        if let Some(indicator) = indicator.as_mut() {
            indicator.set_icon_theme_path(&icon_dir.to_string_lossy());
            indicator.set_icon_full(&icon_name, "Cap tray icon");
        }
    })?;

    Ok(())
}

#[cfg(target_os = "linux")]
fn set_tray_icon_for_mode(tray: &TrayIcon<tauri::Wry>, mode: RecordingMode) -> tauri::Result<()> {
    set_linux_tray_icon(tray, linux_tray_icon_for_mode(mode))
}

#[cfg(not(target_os = "linux"))]
fn set_tray_icon_for_mode(tray: &TrayIcon<tauri::Wry>, mode: RecordingMode) -> tauri::Result<()> {
    let icon = Image::from_bytes(get_mode_icon(mode))?;
    tray.set_icon(Some(icon))?;
    tray.set_icon_as_template(true)?;
    Ok(())
}

#[cfg(target_os = "linux")]
fn set_tray_stop_icon(tray: &TrayIcon<tauri::Wry>) -> tauri::Result<()> {
    set_linux_tray_icon(tray, LinuxTrayIcon::Stop)
}

#[cfg(not(target_os = "linux"))]
fn set_tray_stop_icon(tray: &TrayIcon<tauri::Wry>) -> tauri::Result<()> {
    let icon = Image::from_bytes(include_bytes!("../icons/tray-stop-icon.png"))?;
    tray.set_icon(Some(icon))?;
    tray.set_icon_as_template(true)?;
    Ok(())
}

pub fn update_tray_icon_for_mode(app: &AppHandle, mode: RecordingMode) {
    if cfg!(target_os = "windows") {
        return;
    }

    let Some(tray) = app.tray_by_id("tray") else {
        return;
    };

    if let Err(error) = set_tray_icon_for_mode(&tray, mode) {
        tracing::warn!("Failed to update tray icon: {error}");
    }
}

fn handle_mode_selection(
    app: &AppHandle,
    mode: RecordingMode,
    cache: &Arc<Mutex<PreviousItemsCache>>,
) {
    if let Err(e) = RecordingSettingsStore::set_mode(app, mode) {
        tracing::error!("Failed to set recording mode: {e}");
        return;
    }

    update_tray_icon_for_mode(app, mode);
    refresh_tray_menu(app, cache);
}

pub fn create_tray(app: &AppHandle) -> tauri::Result<()> {
    let cache = Arc::new(Mutex::new(PreviousItemsCache::default()));

    app.manage(TrayMenuCache {
        cache: cache.clone(),
    });

    let menu = {
        let cache_guard = cache.lock().unwrap();
        build_tray_menu(app, &cache_guard)?
    };
    let app = app.clone();
    let is_recording = Arc::new(AtomicBool::new(false));

    let current_mode = get_current_mode(&app);
    let initial_icon = Image::from_bytes(get_mode_icon(current_mode))?;

    let _ = TrayIconBuilder::with_id("tray")
        .icon(initial_icon)
        .icon_as_template(cfg!(target_os = "macos"))
        .menu(&menu)
        .show_menu_on_left_click(true)
        .on_menu_event({
            let app_handle = app.clone();
            let cache = cache.clone();
            move |app: &AppHandle, event| match TrayItem::try_from(event.id) {
                Ok(TrayItem::OpenCap) => {
                    let app = app.clone();
                    tauri::async_runtime::spawn(async move {
                        let _ = ShowCapWindow::Main {
                            init_target_mode: None,
                        }
                        .show(&app)
                        .await;
                    });
                }
                Ok(TrayItem::RecordDisplay) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        crate::open_target_picker(&app, RecordingTargetMode::Display).await;
                    });
                }
                Ok(TrayItem::RecordWindow) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        crate::open_target_picker(&app, RecordingTargetMode::Window).await;
                    });
                }
                Ok(TrayItem::RecordArea) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        crate::open_target_picker(&app, RecordingTargetMode::Area).await;
                    });
                }
                Ok(TrayItem::TakeScreenshot) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        use cap_recording::screen_capture::ScreenCaptureTarget;
                        use scap_targets::Display;

                        let display =
                            Display::get_containing_cursor().unwrap_or_else(Display::primary);
                        let target = ScreenCaptureTarget::Display { id: display.id() };

                        match recording::take_screenshot(app.clone(), target.clone()).await {
                            Ok(path) => {
                                if crate::automation::should_open_screenshot_editor(&app, &target) {
                                    let _ =
                                        ShowCapWindow::ScreenshotEditor { path }.show(&app).await;
                                }
                            }
                            Err(e) => {
                                tracing::error!("Failed to take screenshot: {e}");
                            }
                        }
                    });
                }
                Ok(TrayItem::ImportVideo) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        let file_path = app
                            .dialog()
                            .file()
                            .add_filter(
                                "Media Files",
                                &[
                                    "mp4", "mov", "avi", "mkv", "webm", "wmv", "m4v", "flv", "png",
                                    "jpg", "jpeg", "webp", "gif", "bmp", "tif", "tiff",
                                ],
                            )
                            .add_filter(
                                "Video Files",
                                &["mp4", "mov", "avi", "mkv", "webm", "wmv", "m4v", "flv"],
                            )
                            .add_filter(
                                "Image Files",
                                &["png", "jpg", "jpeg", "webp", "gif", "bmp", "tif", "tiff"],
                            )
                            .blocking_pick_file();

                        if let Some(file_path) = file_path {
                            let path = match file_path.into_path() {
                                Ok(p) => p,
                                Err(e) => {
                                    tracing::error!("Invalid file path: {e}");
                                    return;
                                }
                            };

                            if crate::import::is_supported_video_import_path(&path) {
                                match crate::import::start_video_import(app.clone(), path).await {
                                    Ok(project_path) => {
                                        let _ =
                                            ShowCapWindow::Editor { project_path }.show(&app).await;
                                    }
                                    Err(e) => {
                                        tracing::error!("Failed to import video: {e}");
                                        app.dialog()
                                            .message(format!("Failed to import video: {e}"))
                                            .title("Import Error")
                                            .kind(tauri_plugin_dialog::MessageDialogKind::Error)
                                            .blocking_show();
                                    }
                                }
                            } else if crate::import::is_supported_image_import_path(&path) {
                                match crate::import::start_image_import(app.clone(), path).await {
                                    Ok(path) => {
                                        let _ = ShowCapWindow::ScreenshotEditor { path }
                                            .show(&app)
                                            .await;
                                    }
                                    Err(e) => {
                                        tracing::error!("Failed to import image: {e}");
                                        app.dialog()
                                            .message(format!("Failed to import image: {e}"))
                                            .title("Import Error")
                                            .kind(tauri_plugin_dialog::MessageDialogKind::Error)
                                            .blocking_show();
                                    }
                                }
                            } else {
                                tracing::error!("Unsupported media import path: {:?}", path);
                                app.dialog()
                                    .message("Unsupported media file.")
                                    .title("Import Error")
                                    .kind(tauri_plugin_dialog::MessageDialogKind::Error)
                                    .blocking_show();
                            }
                        }
                    });
                }
                Ok(TrayItem::ViewAllRecordings) => {
                    let _ = RequestOpenSettings {
                        page: "recordings".to_string(),
                    }
                    .emit(&app_handle);
                }
                Ok(TrayItem::ViewAllScreenshots) => {
                    let _ = RequestOpenSettings {
                        page: "screenshots".to_string(),
                    }
                    .emit(&app_handle);
                }
                Ok(TrayItem::OpenSettings) => {
                    let app = app.clone();
                    tokio::spawn(
                        async move { ShowCapWindow::Settings { page: None }.show(&app).await },
                    );
                }
                Ok(TrayItem::UploadLogs) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        match crate::logging::upload_log_file(&app).await {
                            Ok(_) => {
                                tracing::info!("Successfully uploaded logs");
                                app.dialog()
                                    .message("Logs uploaded successfully")
                                    .show(|_| {});
                            }
                            Err(e) => {
                                tracing::error!("Failed to upload logs: {e:#}");
                                app.dialog().message("Failed to upload logs").show(|_| {});
                            }
                        }
                    });
                }
                Ok(TrayItem::Quit) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        crate::request_app_exit(app).await;
                    });
                }
                Ok(TrayItem::PreviousItem(path)) => {
                    handle_previous_item_click(app, &path);
                }
                Ok(TrayItem::ModeStudio) => {
                    handle_mode_selection(app, RecordingMode::Studio, &cache);
                }
                Ok(TrayItem::ModeInstant) => {
                    handle_mode_selection(app, RecordingMode::Instant, &cache);
                }
                Ok(TrayItem::ModeScreenshot) => {
                    handle_mode_selection(app, RecordingMode::Screenshot, &cache);
                }
                Ok(TrayItem::RequestPermissions) => {
                    let app = app.clone();
                    tokio::spawn(async move {
                        let _ = ShowCapWindow::Onboarding.show(&app).await;
                    });
                }
                _ => {}
            }
        })
        .on_tray_icon_event({
            let is_recording = Arc::clone(&is_recording);
            let app_handle = app.clone();
            move |tray, event| {
                if let tauri::tray::TrayIconEvent::Click { button_state, .. } = event {
                    if is_recording.load(Ordering::Relaxed) {
                        if button_state != tauri::tray::MouseButtonState::Down {
                            return;
                        }
                        let app = app_handle.clone();
                        tokio::spawn(async move {
                            let _ = recording::stop_recording(app.clone(), app.state()).await;
                        });
                    } else {
                        let _ = tray.set_visible(true);
                    }
                }
            }
        })
        .build(&app);

    #[cfg(target_os = "linux")]
    if let Some(tray) = app.tray_by_id("tray")
        && let Err(error) = set_tray_icon_for_mode(&tray, current_mode)
    {
        tracing::warn!("Failed to initialize Linux tray icon: {error}");
    }

    RecordingStarted::listen_any(&app, {
        let app = app.clone();
        let is_recording = is_recording.clone();
        move |_| {
            is_recording.store(true, Ordering::Relaxed);

            if cfg!(target_os = "windows") {
                return;
            }

            let Some(tray) = app.tray_by_id("tray") else {
                return;
            };

            if let Err(error) = set_tray_stop_icon(&tray) {
                tracing::warn!("Failed to update tray icon for recording start: {error}");
            }
        }
    });

    RecordingStopped::listen_any(&app, {
        let app_handle = app.clone();
        let is_recording = is_recording.clone();
        move |_| {
            is_recording.store(false, Ordering::Relaxed);

            if cfg!(target_os = "windows") {
                return;
            }

            let Some(tray) = app_handle.tray_by_id("tray") else {
                return;
            };

            let current_mode = get_current_mode(&app_handle);
            if let Err(error) = set_tray_icon_for_mode(&tray, current_mode) {
                tracing::warn!("Failed to update tray icon for recording stop: {error}");
            }
        }
    });

    NewStudioRecordingAdded::listen_any(&app, {
        let app_handle = app.clone();
        let cache_clone = cache.clone();
        move |event| {
            add_new_item_to_cache(&cache_clone, &app_handle, event.payload.path.clone());
            refresh_tray_menu(&app_handle, &cache_clone);
        }
    });

    NewScreenshotAdded::listen_any(&app, {
        let app_handle = app.clone();
        let cache_clone = cache.clone();
        move |event| {
            let path = if event.payload.path.extension().and_then(|s| s.to_str()) == Some("png") {
                event.payload.path.parent().map(|p| p.to_path_buf())
            } else {
                Some(event.payload.path.clone())
            };

            if let Some(path) = path {
                add_new_item_to_cache(&cache_clone, &app_handle, path);
                refresh_tray_menu(&app_handle, &cache_clone);
            }
        }
    });

    crate::recordings_locations::RecordingsMigrationProgress::listen_any(&app, {
        let app_handle = app.clone();
        let cache_clone = cache.clone();
        move |event| {
            // Rebuild once when a storage-folder migration finishes: moved
            // projects changed paths, so cached entries are stale.
            if event.payload.done == event.payload.total {
                cache_clone.lock().unwrap().invalidate();
                load_previous_items_in_background(app_handle.clone(), cache_clone.clone());
            }
        }
    });

    crate::RecordingDeleted::listen_any(&app, {
        let app = app.clone();
        let cache = cache.clone();
        move |event| {
            {
                let mut cache = cache.lock().unwrap();
                cache.items.retain(|item| item.path != event.payload.path);
                cache.invalidate();
            }
            refresh_tray_menu(&app, &cache);
            load_previous_items_in_background(app.clone(), cache.clone());
        }
    });

    load_previous_items_in_background(app.clone(), cache.clone());

    Ok(())
}

#[cfg(target_os = "linux")]
pub(crate) fn clean_stop_icon() -> Result<cap_utils::linux_recording_stop::StopTrayIcon, String> {
    let image = image::load_from_memory(include_bytes!("../icons/tray-stop-icon.png"))
        .map_err(|error| error.to_string())?
        .resize_exact(32, 32, image::imageops::FilterType::Triangle)
        .into_rgba8();
    cap_utils::linux_recording_stop::StopTrayIcon::from_rgba(32, 32, image.as_raw())
}

#[cfg(test)]
mod startup_history_tests {
    use super::*;

    #[test]
    fn history_load_reads_only_enough_valid_metadata_for_the_menu() {
        let directory = tempfile::tempdir().unwrap();
        let paths = (0..100)
            .map(|index| {
                let path = directory.path().join(format!("{index}.cap"));
                std::fs::create_dir(&path).unwrap();
                path
            })
            .collect::<Vec<_>>();
        let mut reads = 0;
        let loaded = newest_valid_items(paths.clone(), 6, |_| {
            reads += 1;
            (reads > 2).then_some(reads)
        });
        assert_eq!(reads, 8);
        assert_eq!(loaded, vec![3, 4, 5, 6, 7, 8]);

        let mut reference = paths.clone();
        reference
            .sort_by_key(|path| std::cmp::Reverse(path.metadata().unwrap().created().unwrap()));
        reference.truncate(6);
        assert_eq!(
            newest_valid_items(paths, 6, |path| Some(path.clone())),
            reference
        );
    }

    #[test]
    fn a_late_history_scan_cannot_overwrite_new_items_or_moved_folders() {
        let mut cache = PreviousItemsCache::default();
        let old_revision = cache.revision;
        cache.invalidate();
        assert!(!cache.finish_loading(old_revision, Vec::new()));
        assert!(!cache.loaded);
        assert!(cache.finish_loading(cache.revision, Vec::new()));
        assert!(cache.loaded);
        assert!(!cache.finish_loading(old_revision, Vec::new()));
    }
}

#[cfg(target_os = "linux")]
pub(crate) async fn set_clean_stop_mode(
    app: &AppHandle,
    generation: u32,
    active: bool,
) -> Result<(), String> {
    let (tx, rx) = tokio::sync::oneshot::channel();
    let handle = app.clone();
    app.run_on_main_thread(move || {
        let result = if crate::clean_capture::wayland_generation(&handle) != Some(generation) {
            Err("Recording tray transition was superseded".to_string())
        } else if let Some(tray) = handle.tray_by_id("tray") {
            tray.set_visible(!active).map_err(|error| error.to_string())
        } else {
            Ok(())
        };
        let _ = tx.send(result);
    })
    .map_err(|error| error.to_string())?;
    tokio::time::timeout(std::time::Duration::from_secs(2), rx)
        .await
        .map_err(|_| "Recording tray transition timed out".to_string())?
        .map_err(|_| "Recording tray transition was lost".to_string())?
}