Settings Commands

#[tauri::command]
pub async fn get_settings(
    app: AppHandle,
) -> Result<Settings, String>

import { invoke } from '@tauri-apps/api/core';

const settings = await invoke<AppSettings>('get_settings');
console.log('Current model:', settings.current_model);
console.log('Hotkey:', settings.hotkey);

#[tauri::command]
pub async fn save_settings(
    app: AppHandle,
    settings: Settings,
) -> Result<(), String>

const settings = await invoke<AppSettings>('get_settings');

// Update a setting
settings.language = 'es';
settings.theme = 'dark';

// Save changes
await invoke('save_settings', { settings });

interface AppSettings {
  // Recording
  hotkey: string;                              // Global hotkey (e.g., "CommandOrControl+Shift+Space")
  recording_mode?: 'toggle' | 'push_to_talk';  // Recording mode
  use_different_ptt_key?: boolean;             // Use separate PTT key
  ptt_hotkey?: string;                         // Push-to-talk hotkey

  // Speech Recognition
  current_model: string;                       // Selected model name
  current_model_engine?: 'whisper' | 'parakeet' | 'soniox';
  language: string;                            // Language code (e.g., "en")
  translate_to_english?: boolean;              // Translate to English

  // Audio
  selected_microphone?: string | null;         // Microphone device name
  play_sound_on_recording?: boolean;           // Play sound on start
  play_sound_on_recording_end?: boolean;       // Play sound on stop
  pause_media_during_recording?: boolean;      // Pause system media

  // UI
  theme: string;                               // "light", "dark", or "system"
  pill_indicator_mode?: 'never' | 'always' | 'when_recording';
  pill_indicator_position?: string;            // "top-center", "bottom-center", etc.
  pill_indicator_offset?: number;              // Offset from edge (10-50 pixels)

  // Transcription
  keep_transcription_in_clipboard?: boolean;   // Keep in clipboard after paste
  transcription_cleanup_days?: number | null;  // Auto-delete after N days (null = keep forever)

  // System
  launch_at_startup?: boolean;                 // Launch on login
  check_updates_automatically?: boolean;       // Auto-check for updates
  onboarding_completed?: boolean;              // Onboarding finished
}

#[tauri::command]
pub async fn set_global_shortcut(
    app: AppHandle,
    shortcut: String,
) -> Result<(), String>

try {
  await invoke('set_global_shortcut', {
    shortcut: 'CommandOrControl+Shift+R'
  });
  console.log('Hotkey updated successfully');
} catch (error) {
  console.error('Failed to set hotkey:', error);
  // Error: "Hotkey is already in use by another application"
}

#[tauri::command]
pub async fn get_supported_languages() -> Result<Vec<LanguageInfo>, String>

interface LanguageInfo {
  code: string;  // ISO 639-1 code (e.g., "en")
  name: string;  // Display name (e.g., "English")
}

const languages = await invoke<LanguageInfo[]>('get_supported_languages');

// Build language selector
languages.forEach(lang => {
  console.log(`${lang.code}: ${lang.name}`);
});

[
  { "code": "en", "name": "English" },
  { "code": "es", "name": "Spanish" },
  { "code": "fr", "name": "French" },
  { "code": "de", "name": "German" },
  { "code": "ja", "name": "Japanese" },
  { "code": "zh", "name": "Chinese" }
]

#[tauri::command]
pub async fn set_audio_device(
    app: AppHandle,
    device_name: Option<String>,
) -> Result<(), String>

// Set specific device
await invoke('set_audio_device', {
  deviceName: 'External USB Microphone'
});

// Use system default
await invoke('set_audio_device', {
  deviceName: null
});

#[tauri::command]
pub async fn validate_microphone_selection(
    app: AppHandle,
) -> Result<bool, String>

const wasReset = await invoke<boolean>('validate_microphone_selection');

if (wasReset) {
  console.log('Selected microphone no longer available, using default');
}

#[tauri::command]
pub async fn set_model_from_tray(
    app: AppHandle,
    model_name: String,
) -> Result<(), String>

await invoke('set_model_from_tray', {
  modelName: 'base.en'
});

#[tauri::command]
pub async fn update_tray_menu(
    app: AppHandle,
) -> Result<(), String>

await invoke('update_tray_menu');

#[tauri::command]
pub async fn frontend_log(
    message: String,
) -> Result<(), String>

await invoke('frontend_log', {
  message: 'User clicked download button'
});

// Recording indicator offset bounds
pub const MIN_INDICATOR_OFFSET: u32 = 10;  // pixels
pub const MAX_INDICATOR_OFFSET: u32 = 50;  // pixels
pub const DEFAULT_INDICATOR_OFFSET: u32 = 10;

impl Default for Settings {
    fn default() -> Self {
        Self {
            hotkey: "CommandOrControl+Shift+Space".to_string(),
            current_model: "".to_string(),  // Auto-select
            current_model_engine: "whisper".to_string(),
            language: "en".to_string(),
            translate_to_english: false,
            theme: "system".to_string(),
            transcription_cleanup_days: None,  // Keep forever
            launch_at_startup: false,
            onboarding_completed: false,
            check_updates_automatically: true,
            selected_microphone: None,  // System default
            recording_mode: "toggle".to_string(),
            use_different_ptt_key: false,
            ptt_hotkey: Some("Alt+Space".to_string()),
            keep_transcription_in_clipboard: false,
            play_sound_on_recording: true,
            play_sound_on_recording_end: true,
            pill_indicator_mode: "when_recording".to_string(),
            pill_indicator_position: "bottom-center".to_string(),
            pill_indicator_offset: DEFAULT_INDICATOR_OFFSET,
            pause_media_during_recording: true,
        }
    }
}

import { invoke } from '@tauri-apps/api/core';
import type { AppSettings } from '@/types';

// Load current settings
const settings = await invoke<AppSettings>('get_settings');

// Update multiple settings
const updatedSettings: AppSettings = {
  ...settings,
  
  // Change model
  current_model: 'large-v3',
  current_model_engine: 'whisper',
  
  // Update UI preferences
  theme: 'dark',
  pill_indicator_mode: 'always',
  pill_indicator_position: 'top-center',
  
  // Configure audio
  selected_microphone: 'AirPods Pro',
  play_sound_on_recording: false,
  
  // Set language
  language: 'es',
  translate_to_english: false,
};

// Save all changes
try {
  await invoke('save_settings', { settings: updatedSettings });
  console.log('Settings saved successfully');
} catch (error) {
  console.error('Failed to save settings:', error);
}