upstream-rs 1.18.0

use crate::services::{integration::CompletionManager, storage::config_storage::ConfigStorage};
use crate::utils::static_paths::UpstreamPaths;
#[cfg(windows)]
use anyhow::Context;
use anyhow::Result;
#[cfg(unix)]
use std::collections::BTreeSet;
use std::fs;
use std::io;
#[cfg(unix)]
use std::io::Write;
#[cfg(unix)]
use std::path::Path;

// Unix shell source lines
#[cfg(unix)]
const SOURCE_LINE_BASH: &str =
    "[ -f $HOME/.upstream/metadata/paths.sh ] && source $HOME/.upstream/metadata/paths.sh";
#[cfg(unix)]
const SOURCE_LINE_FISH: &str =
    "test -f $HOME/.upstream/metadata/paths.sh; and source $HOME/.upstream/metadata/paths.sh";

pub struct InitCheckReport {
    pub ok: bool,
    pub messages: Vec<String>,
}

#[cfg(windows)]
fn normalize_windows_path(path: &str) -> String {
    let mut normalized = path.replace('/', "\\").trim().to_ascii_lowercase();
    while normalized.ends_with('\\') {
        normalized.pop();
    }
    normalized
}

pub fn initialize(paths: &UpstreamPaths) -> Result<()> {
    create_package_dirs(paths)?;
    create_metadata_files(paths)?;
    create_default_config_file(paths)?;

    #[cfg(windows)]
    add_to_windows_path(paths)?;

    #[cfg(unix)]
    update_shell_profiles(paths)?;

    Ok(())
}

pub fn purge_data(paths: &UpstreamPaths) -> Result<()> {
    if paths.dirs.data_dir.exists() {
        fs::remove_dir_all(&paths.dirs.data_dir)?;
    }
    Ok(())
}

pub fn check(paths: &UpstreamPaths) -> Result<InitCheckReport> {
    let mut report = InitCheckReport {
        ok: true,
        messages: Vec::new(),
    };

    for (label, path) in [
        ("config directory", &paths.dirs.config_dir),
        ("data directory", &paths.dirs.data_dir),
        ("metadata directory", &paths.dirs.metadata_dir),
        ("symlinks directory", &paths.integration.symlinks_dir),
        ("appimages directory", &paths.install.appimages_dir),
        ("binaries directory", &paths.install.binaries_dir),
        ("archives directory", &paths.install.archives_dir),
    ] {
        if path.exists() {
            report
                .messages
                .push(format!("[OK] {} exists: {}", label, path.display()));
        } else {
            report.ok = false;
            report
                .messages
                .push(format!("[FAIL] {} missing: {}", label, path.display()));
        }
    }

    let completion_manager = CompletionManager::new(paths);
    let completion_dirs = completion_manager.installed_shell_completion_dirs();
    if completion_dirs.is_empty() {
        report
            .messages
            .push("[OK] no supported shells detected for completion installation".to_string());
    }
    for (shell, path) in completion_dirs {
        let label = format!("{shell} completions directory");
        if path.exists() {
            report
                .messages
                .push(format!("[OK] {} exists: {}", label, path.display()));
        } else {
            report.ok = false;
            report
                .messages
                .push(format!("[FAIL] {} missing: {}", label, path.display()));
        }
    }

    if paths.config.config_file.exists() {
        report.messages.push(format!(
            "[OK] config file exists: {}",
            paths.config.config_file.display()
        ));
    } else {
        report.ok = false;
        report.messages.push(format!(
            "[FAIL] config file missing: {}",
            paths.config.config_file.display()
        ));
    }

    #[cfg(unix)]
    check_unix_integration(paths, &mut report)?;

    #[cfg(windows)]
    check_windows_integration(paths, &mut report)?;

    Ok(report)
}

#[cfg(unix)]
fn get_installed_shells() -> io::Result<Vec<String>> {
    const SHELLS_FILE: &str = "/etc/shells";
    if !Path::new(SHELLS_FILE).exists() {
        return Ok(Vec::new());
    }
    let content = fs::read_to_string(SHELLS_FILE)?;
    let shells = content
        .lines()
        .map(|l| l.trim())
        .filter(|l| !l.is_empty() && !l.starts_with('#'))
        .map(|l| l.to_string())
        .collect();
    Ok(shells)
}

#[cfg(windows)]
fn add_to_windows_path(paths: &UpstreamPaths) -> Result<()> {
    use winreg::RegKey;
    use winreg::enums::*;

    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let env_key = hkcu
        .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
        .context("Failed to open registry key")?;

    let symlinks_path = paths.integration.symlinks_dir.display().to_string();
    let symlinks_norm = normalize_windows_path(&symlinks_path);

    // Get current PATH
    let current_path: String = env_key.get_value("Path").unwrap_or_else(|_| String::new());

    // Check if our path is already in PATH
    let path_entries: Vec<&str> = current_path.split(';').collect();
    if path_entries
        .iter()
        .any(|&p| normalize_windows_path(p) == symlinks_norm)
    {
        return Ok(()); // Already in PATH
    }

    // Add our path to the beginning
    let new_path = if current_path.is_empty() {
        symlinks_path
    } else {
        format!("{};{}", symlinks_path, current_path)
    };

    env_key
        .set_value("Path", &new_path)
        .context("Failed to set PATH")?;

    // Broadcast WM_SETTINGCHANGE to notify other applications
    broadcast_environment_change();

    Ok(())
}

#[cfg(windows)]
fn broadcast_environment_change() {
    use std::ptr;
    use winapi::shared::minwindef::LPARAM;
    use winapi::um::winuser::{
        HWND_BROADCAST, SMTO_ABORTIFHUNG, SendMessageTimeoutW, WM_SETTINGCHANGE,
    };

    unsafe {
        let env_string: Vec<u16> = "Environment\0".encode_utf16().collect();
        SendMessageTimeoutW(
            HWND_BROADCAST,
            WM_SETTINGCHANGE,
            0,
            env_string.as_ptr() as LPARAM,
            SMTO_ABORTIFHUNG,
            5000,
            ptr::null_mut(),
        );
    }
}

fn create_package_dirs(paths: &UpstreamPaths) -> io::Result<()> {
    fs::create_dir_all(&paths.dirs.config_dir)?;
    fs::create_dir_all(&paths.dirs.data_dir)?;
    fs::create_dir_all(&paths.dirs.metadata_dir)?;
    fs::create_dir_all(&paths.install.appimages_dir)?;
    fs::create_dir_all(&paths.install.binaries_dir)?;
    fs::create_dir_all(&paths.install.archives_dir)?;
    fs::create_dir_all(&paths.integration.icons_dir)?;
    fs::create_dir_all(&paths.integration.symlinks_dir)?;
    for (_shell, dir) in CompletionManager::new(paths).installed_shell_completion_dirs() {
        fs::create_dir_all(dir)?;
    }
    Ok(())
}

fn create_default_config_file(paths: &UpstreamPaths) -> Result<()> {
    if paths.config.config_file.exists() {
        return Ok(());
    }

    let storage = ConfigStorage::new(&paths.config.config_file)?;
    storage.save_config()?;
    Ok(())
}

#[cfg(unix)]
fn create_metadata_files(paths: &UpstreamPaths) -> io::Result<()> {
    if !paths.config.paths_file.exists() {
        let export_line = format!(
            r#"export PATH="{}:$PATH""#,
            paths.integration.symlinks_dir.display()
        );
        fs::write(
            &paths.config.paths_file,
            format!(
                "#!/bin/bash\n# Upstream managed PATH additions\n{}\n",
                export_line
            ),
        )?;
    }
    Ok(())
}

#[cfg(windows)]
fn create_metadata_files(_paths: &UpstreamPaths) -> io::Result<()> {
    // On Windows, we use registry-based PATH, so no metadata files needed
    Ok(())
}

#[cfg(unix)]
fn update_shell_profiles(paths: &UpstreamPaths) -> io::Result<()> {
    let shells = get_installed_shells()?;
    for shell_path in shells {
        let shell_name = Path::new(&shell_path)
            .file_name()
            .and_then(|s| s.to_str())
            .unwrap_or("");
        match shell_name.to_lowercase().as_str() {
            "bash" | "sh" => {
                add_line_to_profile(paths, ".bashrc", SOURCE_LINE_BASH)?;
            }
            "zsh" => {
                add_line_to_profile(paths, ".zshrc", SOURCE_LINE_BASH)?;
            }
            "fish" => {
                let fish_config = Path::new(".config").join("fish").join("config.fish");
                add_line_to_profile(paths, &fish_config.to_string_lossy(), SOURCE_LINE_FISH)?;
            }
            _ => {}
        }
    }
    Ok(())
}

#[cfg(unix)]
fn check_unix_integration(paths: &UpstreamPaths, report: &mut InitCheckReport) -> io::Result<()> {
    let expected_line = format!(
        r#"export PATH="{}:$PATH""#,
        paths.integration.symlinks_dir.display()
    );

    if !paths.config.paths_file.exists() {
        report.ok = false;
        report.messages.push(format!(
            "[FAIL] PATH metadata file missing: {}",
            paths.config.paths_file.display()
        ));
    } else {
        let content = fs::read_to_string(&paths.config.paths_file)?;
        if content.contains(&expected_line) {
            report.messages.push(format!(
                "[OK] PATH metadata file contains symlink export: {}",
                paths.config.paths_file.display()
            ));
        } else {
            report.ok = false;
            report.messages.push(format!(
                "[FAIL] PATH metadata file missing expected export line: {}",
                paths.config.paths_file.display()
            ));
        }
    }

    let mut profiles_to_check: BTreeSet<(String, String)> = BTreeSet::new();
    for shell_path in get_installed_shells()? {
        let shell_name = Path::new(&shell_path)
            .file_name()
            .and_then(|s| s.to_str())
            .unwrap_or("")
            .to_ascii_lowercase();
        match shell_name.as_str() {
            "bash" | "sh" => {
                profiles_to_check.insert((".bashrc".to_string(), SOURCE_LINE_BASH.to_string()));
            }
            "zsh" => {
                profiles_to_check.insert((".zshrc".to_string(), SOURCE_LINE_BASH.to_string()));
            }
            "fish" => {
                profiles_to_check.insert((
                    ".config/fish/config.fish".to_string(),
                    SOURCE_LINE_FISH.to_string(),
                ));
            }
            _ => {}
        }
    }

    for (profile_rel, expected_line) in profiles_to_check {
        let profile_path = paths.dirs.user_dir.join(&profile_rel);
        if !profile_path.exists() {
            report.ok = false;
            report.messages.push(format!(
                "[FAIL] Shell profile missing: {}",
                profile_path.display()
            ));
            continue;
        }

        let content = fs::read_to_string(&profile_path)?;
        if content.contains(&expected_line) {
            report.messages.push(format!(
                "[OK] Shell profile contains upstream hook: {}",
                profile_path.display()
            ));
        } else {
            report.ok = false;
            report.messages.push(format!(
                "[FAIL] Shell profile missing upstream hook: {}",
                profile_path.display()
            ));
        }
    }

    Ok(())
}

#[cfg(unix)]
fn add_line_to_profile(paths: &UpstreamPaths, relative_path: &str, line: &str) -> io::Result<()> {
    let profile_path = paths.dirs.user_dir.join(relative_path);

    // Ensure parent directory exists
    if let Some(parent) = profile_path.parent() {
        fs::create_dir_all(parent)?;
    }

    // Backup original file
    if profile_path.exists() {
        let backup_path = profile_path.with_extension("bak");
        if !backup_path.exists() {
            fs::copy(&profile_path, &backup_path)?;
        }
    }

    if !profile_path.exists() {
        fs::write(&profile_path, format!("{}\n", line))?;
        return Ok(());
    }

    let content = fs::read_to_string(&profile_path)?;
    if !content.contains(line) {
        let mut file = fs::OpenOptions::new().append(true).open(&profile_path)?;
        writeln!(file, "\n{}", line)?;
    }

    Ok(())
}

#[cfg(unix)]
pub fn cleanup(paths: &UpstreamPaths) -> Result<()> {
    let shells = get_installed_shells()?;
    for shell_path in shells {
        let shell_name = Path::new(&shell_path)
            .file_name()
            .and_then(|s| s.to_str())
            .unwrap_or("");
        let profile = match shell_name.to_lowercase().as_str() {
            "bash" | "sh" => Some(".bashrc"),
            "zsh" => Some(".zshrc"),
            "fish" => Some(".config/fish/config.fish"),
            _ => None,
        };
        if let Some(profile_rel) = profile {
            let profile_path = paths.dirs.user_dir.join(profile_rel);
            if !profile_path.exists() {
                continue;
            }
            let mut content = fs::read_to_string(&profile_path)?;
            content = content
                .replace(&format!("{}\n", SOURCE_LINE_BASH), "")
                .replace(SOURCE_LINE_BASH, "")
                .replace(&format!("{}\n", SOURCE_LINE_FISH), "")
                .replace(SOURCE_LINE_FISH, "");
            fs::write(&profile_path, content)?;
        }
    }
    Ok(())
}

#[cfg(windows)]
pub fn cleanup(paths: &UpstreamPaths) -> Result<()> {
    remove_from_windows_path(paths)
}

#[cfg(windows)]
fn remove_from_windows_path(paths: &UpstreamPaths) -> Result<()> {
    use winreg::RegKey;
    use winreg::enums::*;

    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let env_key = hkcu
        .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
        .context("Failed to open registry key")?;

    let symlinks_path = paths.integration.symlinks_dir.display().to_string();
    let symlinks_norm = normalize_windows_path(&symlinks_path);

    // Get current PATH
    let current_path: String = env_key.get_value("Path").unwrap_or_else(|_| String::new());

    // Remove our path from PATH
    let path_entries: Vec<&str> = current_path
        .split(';')
        .filter(|&p| normalize_windows_path(p) != symlinks_norm)
        .collect();

    let new_path = path_entries.join(";");

    env_key
        .set_value("Path", &new_path)
        .context("Failed to set PATH")?;

    // Broadcast WM_SETTINGCHANGE to notify other applications
    broadcast_environment_change();

    Ok(())
}

#[cfg(windows)]
fn check_windows_integration(paths: &UpstreamPaths, report: &mut InitCheckReport) -> Result<()> {
    use winreg::RegKey;
    use winreg::enums::*;

    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let env_key = hkcu
        .open_subkey_with_flags("Environment", KEY_READ)
        .context("Failed to open PATH")?;

    let symlinks_path = paths.integration.symlinks_dir.display().to_string();
    let symlinks_norm = normalize_windows_path(&symlinks_path);
    let current_path: String = env_key.get_value("Path").unwrap_or_else(|_| String::new());

    let in_path = current_path
        .split(';')
        .any(|p| normalize_windows_path(p) == symlinks_norm);

    if in_path {
        report
            .messages
            .push("[OK] Windows PATH contains upstream symlinks directory".to_string());
    } else {
        report.ok = false;
        report
            .messages
            .push("[FAIL] Windows PATH missing upstream symlinks directory".to_string());
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::purge_data;
    use crate::utils::static_paths::{
        AppDirs, ConfigPaths, InstallPaths, IntegrationPaths, UpstreamPaths,
    };
    use std::path::{Path, PathBuf};
    use std::time::{SystemTime, UNIX_EPOCH};
    use std::{fs, io};

    fn temp_root(name: &str) -> PathBuf {
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map(|d| d.as_nanos())
            .unwrap_or(0);
        std::env::temp_dir().join(format!("upstream-init-test-{name}-{nanos}"))
    }

    fn test_paths(root: &Path) -> UpstreamPaths {
        let dirs = AppDirs {
            user_dir: root.to_path_buf(),
            config_dir: root.join("config"),
            data_dir: root.join(".upstream"),
            metadata_dir: root.join(".upstream/metadata"),
        };

        UpstreamPaths {
            config: ConfigPaths {
                config_file: dirs.config_dir.join("config.toml"),
                packages_file: dirs.metadata_dir.join("packages.json"),
                metadata_file: dirs.metadata_dir.join("metadata.json"),
                paths_file: dirs.metadata_dir.join("paths.sh"),
            },
            install: InstallPaths {
                appimages_dir: dirs.data_dir.join("appimages"),
                binaries_dir: dirs.data_dir.join("binaries"),
                archives_dir: dirs.data_dir.join("archives"),
                rollback_dir: dirs.data_dir.join("rollback"),
            },
            integration: IntegrationPaths {
                symlinks_dir: dirs.data_dir.join("symlinks"),
                xdg_applications_dir: dirs.user_dir.join(".local/share/applications"),
                icons_dir: dirs.data_dir.join("icons"),
                bash_completions_dir: dirs
                    .user_dir
                    .join(".local/share/bash-completion/completions"),
                fish_completions_dir: dirs.user_dir.join(".config/fish/completions"),
                zsh_completions_dir: dirs.user_dir.join(".local/share/zsh/site-functions"),
            },
            dirs,
        }
    }

    fn cleanup(path: &Path) -> io::Result<()> {
        if path.exists() {
            fs::remove_dir_all(path)?;
        }
        Ok(())
    }

    #[test]
    fn purge_data_removes_data_dir_but_keeps_config_dir() {
        let root = temp_root("purge");
        let paths = test_paths(&root);
        fs::create_dir_all(&paths.dirs.data_dir).expect("create data dir");
        fs::create_dir_all(&paths.dirs.config_dir).expect("create config dir");
        fs::write(paths.dirs.data_dir.join("data"), b"data").expect("write data");
        fs::write(paths.dirs.config_dir.join("config.toml"), b"").expect("write config");

        purge_data(&paths).expect("purge data");

        assert!(!paths.dirs.data_dir.exists());
        assert!(paths.dirs.config_dir.exists());

        cleanup(&root).expect("cleanup");
    }
}