//! Preferences that outlive the app, kept in
//! `$XDG_CONFIG_HOME/vectrum-code/settings.json` and edited in the settings
//! view. They're read once and cached, so rendering can consult them freely.

use std::{path::PathBuf, sync::Mutex};

use serde::{Deserialize, Serialize};

use crate::models::Provider;

/// Where a new thread starts: in the project folder, or in a git worktree of
/// its own on a fresh branch.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum WorkspaceMode {
    #[default]
    Local,
    Worktree,
}

/// How a new worktree fills in git submodules.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Submodules {
    Skip,
    TopLevel,
    #[default]
    Recursive,
}

/// What Ctrl+Q takes.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum QuitShortcut {
    /// One press quits.
    Press,
    /// Holding the keys, or pressing them twice quickly, quits.
    #[default]
    Hold,
}

/// How projects are ordered in the sidebar and the project menus.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProjectOrder {
    /// The project with the most recent message first.
    #[default]
    LastMessage,
    Name,
    Added,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TimeFormat {
    /// Whatever the locale prefers.
    #[default]
    System,
    Hour12,
    Hour24,
}

/// How an answer appears while the agent writes it.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Streaming {
    #[default]
    Tokens,
    /// Each paragraph or code block once it's complete.
    Paragraphs,
}

/// What a message sent while the agent works does.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FollowUp {
    /// Hand it to the agent at once, so it can change course mid-turn.
    #[default]
    Steer,
    /// Hold it until the turn ends.
    Queue,
}

/// How eagerly the app checks on things in the background.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BackgroundActivity {
    Always,
    /// Pauses while the window has been in the background for a while, or
    /// the machine saves power.
    #[default]
    Balanced,
    /// Pauses whenever the window is in the background.
    Minimal,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct EnvVar {
    pub key: String,
    pub value: String,
}

/// One configured agent: Claude Code or Pi, with its own binary, home
/// folder, arguments and environment. There can be several of a kind, say
/// two Claude accounts.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct ProviderInstance {
    /// Stable id, used in model keys (`claude:opus`). The first instance of a
    /// kind is named after it.
    pub id: String,
    pub kind: Provider,
    /// Empty shows the kind's name.
    pub name: String,
    pub enabled: bool,
    /// Empty looks the binary up on PATH.
    pub binary: String,
    /// `CLAUDE_CONFIG_DIR` or `PI_CODING_AGENT_DIR`; empty is the default.
    pub home: String,
    /// Extra arguments, split like a shell would.
    pub args: String,
    pub env: Vec<EnvVar>,
}

impl Default for ProviderInstance {
    fn default() -> Self {
        Self::new(Provider::Claude, "claude")
    }
}

impl ProviderInstance {
    pub fn new(kind: Provider, id: &str) -> Self {
        Self {
            id: id.to_string(),
            kind,
            name: String::new(),
            enabled: true,
            binary: String::new(),
            home: String::new(),
            args: String::new(),
            env: Vec::new(),
        }
    }

    pub fn label(&self) -> String {
        if self.name.trim().is_empty() { self.kind.label().to_string() } else { self.name.trim().to_string() }
    }
}

/// A usage hub the Usage page also reads, such as a CLIProxyAPI server.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UsageHub {
    pub name: String,
    /// `cliproxy`.
    pub kind: String,
    pub url: String,
    /// The hub's management key.
    pub key: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
pub struct Settings {
    /// `bone`, `auto` or `graphite`.
    pub colorway: Option<String>,
    /// Model keys (`claude:opus`, `pi:anthropic/claude-sonnet-5-5`), in the
    /// order they were starred.
    pub favorites: Vec<String>,

    // ---- new threads ----
    /// The model key new threads start on. `None` follows the open thread.
    pub default_model: Option<String>,
    /// `default`, an effort level (`high`), `ultracode` or `ultrathink`.
    /// `None` follows the open thread.
    pub default_reasoning: Option<String>,
    /// A permission mode as the CLI spells it. `None` follows the open thread.
    pub default_access: Option<String>,
    pub workspace: WorkspaceMode,
    pub submodules: Submodules,
    /// Base new worktrees on the branch as origin has it.
    pub start_from_origin: bool,
    /// Where the Add project browser opens; empty is the home folder.
    pub add_project_dir: String,

    // ---- text generation ----
    /// The model key thread titles are written with; empty keeps the first
    /// line of the first message.
    pub text_model: String,
    /// The reasoning level for generated text, as [`Settings::default_reasoning`].
    pub text_reasoning: Option<String>,

    // ---- conversation ----
    /// Fold a finished turn's tool calls into one "Worked for" row.
    pub fold_turns: bool,
    /// Show what threads and turns cost.
    pub show_costs: bool,
    /// Send with Ctrl+Enter, so Enter starts a new line.
    pub send_with_ctrl_enter: bool,
    pub follow_up: FollowUp,
    pub streaming: Streaming,
    /// List skills in the `/` menu too; `$` always lists them.
    pub slash_skills: bool,
    /// Highlight Markdown in the composer as you type.
    pub rich_composer: bool,
    /// Rest the composer to one line while scrolling a conversation.
    pub collapse_composer: bool,
    pub time_format: TimeFormat,
    /// Open the diff after a turn that changed enough.
    pub proactive_panels: bool,
    /// Ignore whitespace-only edits in diffs.
    pub hide_whitespace: bool,
    /// Open diffs with every file folded.
    pub diff_collapsed: bool,
    pub diff_side_by_side: bool,

    // ---- sidebar ----
    /// One-line thread cards in the sidebar.
    pub compact_threads: bool,
    /// Group sidebar threads under their project.
    pub group_by_project: bool,
    pub project_order: ProjectOrder,
    /// Fold working threads into their own section until they need you.
    pub working_section: bool,
    /// Continue a thread stopped by a usage limit once the limit resets.
    pub auto_resume_limited: bool,
    /// Snooze a thread stopped by a usage limit until the limit resets.
    pub snooze_limited: bool,
    /// Settle a worktree thread once its pull request merges.
    pub auto_settle_merged: bool,
    pub auto_settle_inactive: bool,
    pub inactive_days: u32,

    // ---- confirmations ----
    pub confirm_unpin: bool,
    /// Settling from a thread card takes a second click.
    pub confirm_settle: bool,
    pub confirm_delete: bool,
    pub quit_shortcut: QuitShortcut,

    // ---- notifications and background work ----
    /// A desktop notification when a thread finishes or needs you while the
    /// window is in the background.
    pub notify: bool,
    /// Play a sound with each desktop notification.
    pub notify_sound: bool,
    /// A toast when another thread finishes or needs you while the window
    /// has focus.
    pub in_app_notifications: bool,
    /// Resume threads a restart or crash interrupted.
    pub continue_after_restart: bool,
    /// Check installed agents for newer versions.
    pub update_checks: bool,
    pub background_activity: BackgroundActivity,
    /// Seconds between provider health checks; 0 turns them off.
    pub health_check_secs: u64,

    // ---- integrations ----
    /// The editor "Open in" uses, by name (`Zed`).
    pub editor: Option<String>,
    pub providers: Vec<ProviderInstance>,
    pub usage_hubs: Vec<UsageHub>,

    /// Superseded by `providers`; read once to carry an old path override over.
    #[serde(skip_serializing)]
    claude_bin: Option<String>,
    #[serde(skip_serializing)]
    pi_bin: Option<String>,
}

impl Default for Settings {
    fn default() -> Self {
        Self {
            colorway: None,
            favorites: Vec::new(),
            default_model: None,
            default_reasoning: None,
            default_access: None,
            workspace: WorkspaceMode::Local,
            submodules: Submodules::Recursive,
            start_from_origin: false,
            add_project_dir: String::new(),
            text_model: "claude:haiku".into(),
            text_reasoning: Some("low".into()),
            fold_turns: true,
            show_costs: true,
            send_with_ctrl_enter: false,
            follow_up: FollowUp::Steer,
            streaming: Streaming::Tokens,
            slash_skills: true,
            rich_composer: true,
            collapse_composer: false,
            time_format: TimeFormat::System,
            proactive_panels: false,
            hide_whitespace: true,
            diff_collapsed: false,
            diff_side_by_side: false,
            compact_threads: false,
            group_by_project: false,
            project_order: ProjectOrder::LastMessage,
            working_section: false,
            auto_resume_limited: false,
            snooze_limited: false,
            auto_settle_merged: true,
            auto_settle_inactive: false,
            inactive_days: 3,
            confirm_unpin: false,
            confirm_settle: false,
            confirm_delete: true,
            quit_shortcut: QuitShortcut::Hold,
            notify: false,
            notify_sound: false,
            in_app_notifications: false,
            continue_after_restart: false,
            update_checks: false,
            background_activity: BackgroundActivity::Balanced,
            health_check_secs: 300,
            editor: None,
            providers: Vec::new(),
            usage_hubs: Vec::new(),
            claude_bin: None,
            pi_bin: None,
        }
    }
}

impl Settings {
    /// Makes sure there's at least one instance of each kind, carrying old
    /// binary overrides over.
    fn normalize(&mut self) {
        for (kind, old_bin) in [(Provider::Claude, self.claude_bin.take()), (Provider::Pi, self.pi_bin.take())] {
            if !self.providers.iter().any(|instance| instance.kind == kind) {
                let mut instance = ProviderInstance::new(kind, kind.key());
                instance.binary = old_bin.unwrap_or_default();
                self.providers.push(instance);
            }
        }
    }

    pub fn instance(&self, id: &str) -> Option<&ProviderInstance> {
        self.providers.iter().find(|instance| instance.id == id)
    }
}

static CACHE: Mutex<Option<Settings>> = Mutex::new(None);

pub fn path() -> Option<PathBuf> {
    let base = std::env::var_os("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".config")))?;
    Some(base.join("vectrum-code").join("settings.json"))
}

fn read_file() -> Settings {
    let mut settings: Settings = path()
        .and_then(|path| std::fs::read_to_string(path).ok())
        .and_then(|text| serde_json::from_str(&text).ok())
        .unwrap_or_default();
    settings.normalize();
    settings
}

/// Reads one value out of the settings.
pub fn get<T>(read: impl FnOnce(&Settings) -> T) -> T {
    let mut cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
    read(cache.get_or_insert_with(read_file))
}

pub fn load() -> Settings {
    get(Settings::clone)
}

/// The configured agents, enabled or not.
pub fn instances() -> Vec<ProviderInstance> {
    get(|settings| settings.providers.clone())
}

/// One agent's configuration, falling back to a default for its kind.
pub fn instance(id: &str, kind: Provider) -> ProviderInstance {
    get(|settings| settings.instance(id).cloned()).unwrap_or_else(|| ProviderInstance::new(kind, id))
}

/// Applies `edit` to the settings and writes them back.
pub fn update(edit: impl FnOnce(&mut Settings)) {
    let settings = {
        let mut cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
        let settings = cache.get_or_insert_with(read_file);
        edit(settings);
        settings.normalize();
        settings.clone()
    };
    let Some(path) = path() else { return };
    let written = path
        .parent()
        .map(std::fs::create_dir_all)
        .unwrap_or(Ok(()))
        .and_then(|_| std::fs::write(&path, serde_json::to_string_pretty(&settings).unwrap_or_default()));
    if let Err(err) = written {
        eprintln!("vectrum-code: couldn't save {}: {err}", path.display());
    }
}

/// Puts everything but favorites, agents and usage hubs back to its default.
pub fn restore_defaults() {
    update(|settings| {
        let favorites = std::mem::take(&mut settings.favorites);
        let providers = std::mem::take(&mut settings.providers);
        let usage_hubs = std::mem::take(&mut settings.usage_hubs);
        *settings = Settings { favorites, providers, usage_hubs, ..Settings::default() };
    });
}

/// `~/bin/claude` → `/home/me/bin/claude`.
pub fn expand_home(path: &str) -> PathBuf {
    match (path.strip_prefix("~/"), std::env::var_os("HOME")) {
        (Some(rest), Some(home)) => PathBuf::from(home).join(rest),
        _ if path == "~" => std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from(path)),
        _ => PathBuf::from(path),
    }
}

/// Where the app keeps its own data: threads, worktrees, scratch space.
pub fn data_dir() -> Option<PathBuf> {
    let base = std::env::var_os("XDG_DATA_HOME")
        .map(PathBuf::from)
        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/share")))?;
    Some(base.join("vectrum-code"))
}