lib.rs

use std::{
    fs,
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
};

use glob::{MatchOptions, Pattern};
use log::trace;
use pet_core::{
    env::PythonEnv,
    os_environment::Environment,
    python_environment::{PythonEnvironment, PythonEnvironmentBuilder, PythonEnvironmentKind},
    pyvenv_cfg::PyVenvCfg,
    reporter::Reporter,
    Configuration, Locator, LocatorKind, RefreshStatePersistence,
};
use pet_fs::path::norm_case;
use pet_python_utils::executable::{find_executable, find_executables};
use serde::Deserialize;

pub struct Uv {
    pub workspace_directories: Arc<Mutex<Vec<PathBuf>>>,
    /// Directory where uv stores managed Python installations,
    /// e.g. `~/.local/share/uv/python` on Unix or `%APPDATA%\uv\python` on Windows.
    uv_install_dir: Option<PathBuf>,
}

/// Represents information stored in a `pyvenv.cfg` generated by uv
struct UvVenv {
    uv_version: String,
    python_version: String,
    prompt: String,
}

impl UvVenv {
    fn maybe_from_file(file: &Path) -> Option<Self> {
        let contents = fs::read_to_string(file).ok()?;
        let mut uv_version = None;
        let mut python_version = None;
        let mut prompt = None;
        for line in contents.lines() {
            if let Some(uv_version_value) = line.trim_start().strip_prefix("uv = ") {
                uv_version = Some(uv_version_value.trim_end().to_string())
            }
            if let Some(version_info) = line.trim_start().strip_prefix("version_info = ") {
                python_version = Some(version_info.to_string());
            }
            if let Some(prompt_value) = line.trim_start().strip_prefix("prompt = ") {
                prompt = Some(prompt_value.trim_end().to_string());
            }
            if uv_version.is_some() && python_version.is_some() && prompt.is_some() {
                // we've found all the values we need, stop parsing
                break;
            }
        }
        Some(Self {
            uv_version: uv_version?,
            python_version: python_version?,
            prompt: prompt?,
        })
    }
}

impl Default for Uv {
    fn default() -> Self {
        Self::from(&pet_core::os_environment::EnvironmentApi::new())
    }
}

impl Uv {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn from(environment: &dyn Environment) -> Self {
        Self {
            workspace_directories: Arc::new(Mutex::new(Vec::new())),
            uv_install_dir: get_uv_python_install_dir(environment),
        }
    }
}

impl Locator for Uv {
    fn get_kind(&self) -> LocatorKind {
        LocatorKind::Uv
    }

    fn refresh_state(&self) -> RefreshStatePersistence {
        RefreshStatePersistence::ConfiguredOnly
    }

    fn supported_categories(&self) -> Vec<PythonEnvironmentKind> {
        vec![
            PythonEnvironmentKind::Uv,
            PythonEnvironmentKind::UvWorkspace,
        ]
    }

    fn configure(&self, config: &Configuration) {
        let mut ws = self
            .workspace_directories
            .lock()
            .expect("workspace_directories mutex poisoned");
        ws.clear();
        if let Some(workspace_directories) = config.workspace_directories.as_ref() {
            ws.extend(workspace_directories.iter().cloned());
        }
    }

    fn try_from(&self, env: &PythonEnv) -> Option<PythonEnvironment> {
        // Check if this is a uv-managed global Python installation
        if let Some(uv_env) = self.try_from_managed_install(env) {
            return Some(uv_env);
        }

        // Check if this is a uv-managed virtual environment (pyvenv.cfg with uv marker)
        let cfg = env
            .executable
            .parent()
            .and_then(PyVenvCfg::find)
            .or_else(|| {
                env.prefix
                    .as_ref()
                    .and_then(|prefix| PyVenvCfg::find(prefix))
            })?;
        let uv_venv = UvVenv::maybe_from_file(&cfg.file_path)?;
        trace!(
            "uv-managed venv found in {}, made by uv {}",
            env.executable.display(),
            uv_venv.uv_version
        );
        let prefix = env.prefix.clone().or_else(|| {
            env.executable
                .parent()
                .and_then(|p| p.parent().map(|pp| pp.to_path_buf()))
        });
        let pyproject = prefix
            .as_ref()
            .and_then(|prefix| prefix.parent())
            .and_then(parse_pyproject_toml_in);
        let kind = if pyproject
            .and_then(|pyproject| pyproject.tool)
            .and_then(|t| t.uv)
            .and_then(|uv| uv.workspace)
            .is_some()
        {
            PythonEnvironmentKind::UvWorkspace
        } else {
            PythonEnvironmentKind::Uv
        };

        Some(
            PythonEnvironmentBuilder::new(Some(kind))
                .name(Some(uv_venv.prompt))
                .executable(Some(env.executable.clone()))
                .version(Some(uv_venv.python_version))
                .symlinks(prefix.as_ref().map(find_executables))
                .prefix(prefix)
                .build(),
        )
    }

    fn find(&self, reporter: &dyn Reporter) {
        // Discover globally-installed Python versions from `uv python install`
        if let Some(ref install_dir) = self.uv_install_dir {
            for env in find_managed_python_installs(install_dir) {
                reporter.report_environment(&env);
            }
        }

        // look through workspace directories for uv-managed projects and any of their workspaces
        let workspaces = self
            .workspace_directories
            .lock()
            .expect("workspace_directories mutex poisoned")
            .clone();
        for workspace in &workspaces {
            for env in list_envs_in_directory(workspace) {
                reporter.report_environment(&env);
            }
        }
    }
}

impl Uv {
    /// Check if a Python executable is from a uv-managed global installation.
    fn try_from_managed_install(&self, env: &PythonEnv) -> Option<PythonEnvironment> {
        let install_dir = self.uv_install_dir.as_ref()?;
        let executable = &env.executable;

        // Check if the executable lives under the uv install directory.
        // Both paths are normalized (install_dir via norm_case at construction,
        // executable via PythonEnv normalization), but symlinks/junctions that
        // resolve outside install_dir won't match — consistent with other locators.
        if !executable.starts_with(install_dir) {
            return None;
        }

        // Determine the version-specific subdirectory.
        // Path: <install_dir>/<cpython-X.Y.Z-os-arch-libc>/bin/python
        let relative = executable.strip_prefix(install_dir).ok()?;
        let version_dir_name = relative.iter().next()?.to_string_lossy();
        let version = parse_version_from_uv_dir_name(&version_dir_name)?;
        let prefix = install_dir.join(version_dir_name.as_ref());

        // Skip minor-version junction/symlink directories (e.g., cpython-3.12-*)
        // to avoid duplicating the actual patch-version directories they point to.
        if is_symlink_or_junction(&prefix) {
            return None;
        }

        trace!(
            "uv-managed Python {} found at {}",
            version,
            executable.display()
        );

        Some(
            PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::Uv))
                .executable(Some(executable.clone()))
                .version(Some(version))
                .prefix(Some(prefix.clone()))
                .symlinks(Some(find_executables(&prefix)))
                .build(),
        )
    }
}

/// Determine the directory where uv stores managed Python installations.
fn get_uv_python_install_dir(environment: &dyn Environment) -> Option<PathBuf> {
    // 1. Check UV_PYTHON_INSTALL_DIR env var
    if let Some(dir) = environment.get_env_var("UV_PYTHON_INSTALL_DIR".to_string()) {
        let path = PathBuf::from(dir);
        if path.is_dir() {
            return Some(norm_case(path));
        }
    }

    // 2. Platform-specific defaults
    get_default_uv_python_install_dir(environment)
}

#[cfg(windows)]
fn get_default_uv_python_install_dir(environment: &dyn Environment) -> Option<PathBuf> {
    // Windows: %APPDATA%\uv\python
    let appdata = environment.get_env_var("APPDATA".to_string())?;
    let path = PathBuf::from(appdata).join("uv").join("python");
    if path.is_dir() {
        Some(norm_case(path))
    } else {
        None
    }
}

#[cfg(unix)]
fn get_default_uv_python_install_dir(environment: &dyn Environment) -> Option<PathBuf> {
    // Unix: $XDG_DATA_HOME/uv/python or ~/.local/share/uv/python
    if let Some(xdg) = environment.get_env_var("XDG_DATA_HOME".to_string()) {
        let path = PathBuf::from(xdg).join("uv").join("python");
        if path.is_dir() {
            return Some(norm_case(path));
        }
    }
    let home = environment.get_user_home()?;
    let path = home.join(".local").join("share").join("uv").join("python");
    if path.is_dir() {
        Some(norm_case(path))
    } else {
        None
    }
}

/// Scan the uv Python install directory for managed Python installations.
/// Skips symlinks and junctions (minor-version aliases like `cpython-3.12-*`)
/// to avoid duplicating the actual patch-version directories they point to.
fn find_managed_python_installs(install_dir: &Path) -> Vec<PythonEnvironment> {
    let mut envs = Vec::new();
    let entries = match fs::read_dir(install_dir) {
        Ok(entries) => entries,
        Err(_) => return envs,
    };

    for entry in entries.filter_map(Result::ok) {
        let path = entry.path();
        if !path.is_dir() {
            continue;
        }

        // Skip symlinks (Unix) and junctions (Windows) — these are minor-version
        // aliases (e.g., cpython-3.12-*) pointing to full patch-version directories.
        if is_symlink_or_junction(&path) {
            trace!("Skipping symlink/junction directory {}", path.display());
            continue;
        }

        let dir_name = match path.file_name() {
            Some(name) => name.to_string_lossy().to_string(),
            None => continue,
        };

        let version = match parse_version_from_uv_dir_name(&dir_name) {
            Some(v) => v,
            None => continue,
        };

        if let Some(executable) = find_executable(&path) {
            trace!("uv-managed Python {} found in {}", version, path.display());
            let env = PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::Uv))
                .executable(Some(executable))
                .version(Some(version))
                .prefix(Some(path.clone()))
                .symlinks(Some(find_executables(&path)))
                .build();
            envs.push(env);
        }
    }

    envs
}

/// Check if a path is a symlink (Unix) or junction/symlink (Windows).
#[cfg(windows)]
fn is_symlink_or_junction(path: &Path) -> bool {
    use std::os::windows::fs::MetadataExt;
    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
    fs::symlink_metadata(path)
        .map(|m| m.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0)
        .unwrap_or(false)
}

#[cfg(unix)]
fn is_symlink_or_junction(path: &Path) -> bool {
    fs::symlink_metadata(path)
        .map(|m| m.file_type().is_symlink())
        .unwrap_or(false)
}

/// Parse version from a uv Python install directory name.
/// Directory names follow the pattern: `cpython-3.14.3-linux-x86_64-gnu`
/// Returns the version string (e.g., "3.14.3").
fn parse_version_from_uv_dir_name(dir_name: &str) -> Option<String> {
    // Format: <implementation>-<version>-<os>-<arch>-<libc>
    // e.g., cpython-3.14.3-linux-x86_64-gnu, pypy-3.10.14-linux-x86_64-gnu
    let mut parts = dir_name.splitn(3, '-');
    let _impl = parts.next()?;
    let version = parts.next()?;
    // Require the platform segment to exist (rejects bare "<impl>-<version>").
    let platform = parts.next()?;
    if platform.is_empty() {
        return None;
    }
    // Verify at minimum X.Y format (e.g., "3.12" or "3.12.3").
    // Major and minor must always be purely numeric.
    // Only the patch component (3rd+) may have a pre-release suffix (e.g., "0a4", "0rc1").
    let components: Vec<&str> = version.split('.').collect();
    if components.len() < 2 {
        return None;
    }

    let is_numeric = |c: &str| !c.is_empty() && c.chars().all(|ch| ch.is_ascii_digit());

    // Major and minor must be purely numeric.
    if !is_numeric(components[0]) || !is_numeric(components[1]) {
        return None;
    }

    // For X.Y versions (no patch), we're done.
    if components.len() == 2 {
        return Some(version.to_string());
    }

    // Any components between minor and the last must be purely numeric.
    let middle = &components[2..components.len() - 1];
    if !middle.iter().all(|c| is_numeric(c)) {
        return None;
    }

    // The last component (patch or beyond) must start with a digit
    // (allows pre-release suffix like "0a4").
    let last = components.last()?;
    if last.is_empty() || !last.starts_with(|ch: char| ch.is_ascii_digit()) {
        return None;
    }
    Some(version.to_string())
}

/// Walks up from `project_path` looking for a workspace that this project belongs to.
/// Starts from `project_path` itself because a project can also define `[tool.uv.workspace]`
/// alongside `[project]` (i.e. the workspace root is itself a package).
/// Returns the workspace environment if found and the project is a valid member.
fn find_workspace_for_project(project_path: &Path) -> Option<PythonEnvironment> {
    for candidate in project_path.ancestors() {
        let pyproject = parse_pyproject_toml_in(candidate);
        let workspace = pyproject
            .as_ref()
            .and_then(|pp| pp.tool.as_ref())
            .and_then(|tool| tool.uv.as_ref())
            .and_then(|uv| uv.workspace.as_ref());
        let Some(workspace) = workspace else {
            continue;
        };
        if !is_workspace_member(candidate, project_path, workspace) {
            trace!(
                "Path {} is not a member of workspace at {}",
                project_path.display(),
                candidate.display()
            );
            // The first workspace found walking upward is the authoritative one;
            // if the project isn't a member, it's not part of any workspace.
            return None;
        }
        trace!(
            "Found workspace at {:?} for project {:?}",
            candidate,
            project_path
        );
        return build_workspace_env(candidate);
    }
    None
}

/// Builds a `PythonEnvironment` for a uv workspace root if it has a `.venv` with a valid
/// uv-managed pyvenv.cfg.
fn build_workspace_env(workspace_root: &Path) -> Option<PythonEnvironment> {
    let prefix = workspace_root.join(".venv");
    let pyvenv_cfg = prefix.join("pyvenv.cfg");
    if !pyvenv_cfg.exists() {
        trace!(
            "Workspace at {} does not have a virtual environment",
            workspace_root.display()
        );
        return None;
    }
    let unix_executable = prefix.join("bin/python");
    let windows_executable = prefix.join("Scripts/python.exe");
    let executable = if unix_executable.exists() {
        Some(unix_executable)
    } else if windows_executable.exists() {
        Some(windows_executable)
    } else {
        None
    };
    if let Some(uv_venv) = UvVenv::maybe_from_file(&pyvenv_cfg) {
        Some(
            PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::UvWorkspace))
                .name(Some(uv_venv.prompt))
                .executable(executable)
                .version(Some(uv_venv.python_version))
                .symlinks(Some(find_executables(&prefix)))
                .prefix(Some(prefix))
                .build(),
        )
    } else {
        trace!(
            "Workspace at {} does not have a uv-managed virtual environment",
            workspace_root.display()
        );
        None
    }
}

fn list_envs_in_directory(path: &Path) -> Vec<PythonEnvironment> {
    let mut envs = Vec::new();
    let pyproject = parse_pyproject_toml_in(path);
    let Some(pyproject) = pyproject else {
        return envs;
    };
    let pyvenv_cfg = path.join(".venv/pyvenv.cfg");
    let prefix = path.join(".venv");
    let unix_executable = prefix.join("bin/python");
    let windows_executable = prefix.join("Scripts/python.exe");
    let executable = if unix_executable.exists() {
        Some(unix_executable)
    } else if windows_executable.exists() {
        Some(windows_executable)
    } else {
        None
    };
    if pyproject
        .tool
        .and_then(|t| t.uv)
        .and_then(|uv| uv.workspace)
        .is_some()
    {
        trace!("Workspace found in {}", path.display());
        if let Some(uv_venv) = UvVenv::maybe_from_file(&pyvenv_cfg) {
            trace!("uv-managed venv found for workspace in {}", path.display());
            let env = PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::UvWorkspace))
                .name(Some(uv_venv.prompt))
                .symlinks(Some(find_executables(&prefix)))
                .prefix(Some(prefix))
                .executable(executable)
                .version(Some(uv_venv.python_version))
                .build();
            envs.push(env);
        } else {
            trace!(
                "No uv-managed venv found for workspace in {}",
                path.display()
            );
        }
    // prioritize the workspace over the project if it's the same venv
    } else if let Some(project) = pyproject.project {
        if let Some(uv_venv) = UvVenv::maybe_from_file(&pyvenv_cfg) {
            trace!("uv-managed venv found for project in {}", path.display());
            let env = PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::Uv))
                .name(Some(uv_venv.prompt))
                .symlinks(Some(find_executables(&prefix)))
                .prefix(Some(prefix))
                .version(Some(uv_venv.python_version))
                .display_name(project.name)
                .executable(executable)
                .build();
            envs.push(env);
        } else {
            trace!("No uv-managed venv found in {}", path.display());
        }
        if let Some(workspace) = find_workspace_for_project(path) {
            envs.push(workspace);
        }
    }

    envs
}

fn parse_pyproject_toml_in(path: &Path) -> Option<PyProjectToml> {
    let contents = fs::read_to_string(path.join("pyproject.toml")).ok()?;
    toml::from_str(&contents).ok()
}

/// Checks whether `project_path` is a workspace member of the workspace rooted at
/// `workspace_root` according to the given `members` and `exclude` globs.
///
/// If `members` is empty (or absent), uv treats all subdirectories as implicit members.
/// A project that matches an `exclude` pattern is never a member.
///
/// Patterns are evaluated relative to the workspace root. For example,
/// `members = ["packages/*"]` matches `<workspace_root>/packages/foo`.
fn is_workspace_member(
    workspace_root: &Path,
    project_path: &Path,
    workspace: &UvWorkspace,
) -> bool {
    // The project must be underneath the workspace root
    let relative = match project_path.strip_prefix(workspace_root) {
        Ok(r) => r,
        Err(_) => return false,
    };

    // The workspace root itself is always a member of its own workspace
    if relative.as_os_str().is_empty() {
        return true;
    }

    // Normalise to forward slashes for glob matching
    let relative_str = relative.to_string_lossy().replace('\\', "/");

    // Use require_literal_separator so `*` matches a single path component only
    let match_options = MatchOptions {
        require_literal_separator: true,
        ..MatchOptions::new()
    };

    // Check excludes first — an excluded path is never a member
    for exclude in &workspace.exclude {
        match Pattern::new(exclude) {
            Ok(pattern) => {
                if pattern.matches_with(&relative_str, match_options) {
                    trace!(
                        "Path {} excluded from workspace by pattern '{}'",
                        project_path.display(),
                        exclude
                    );
                    return false;
                }
            }
            Err(e) => {
                trace!("Invalid exclude glob pattern '{}': {}", exclude, e);
            }
        }
    }

    // If no members are specified, all subdirectories are implicit members
    if workspace.members.is_empty() {
        return true;
    }

    // Check if the path matches any member pattern
    for member in &workspace.members {
        match Pattern::new(member) {
            Ok(pattern) => {
                if pattern.matches_with(&relative_str, match_options) {
                    return true;
                }
            }
            Err(e) => {
                trace!("Invalid member glob pattern '{}': {}", member, e);
            }
        }
    }

    false
}

#[derive(Deserialize, Debug)]
struct PyProjectToml {
    project: Option<Project>,
    tool: Option<Tool>,
}

#[derive(Deserialize, Debug)]
struct Project {
    name: Option<String>,
}

#[derive(Deserialize, Debug)]
struct Tool {
    uv: Option<ToolUv>,
}

#[derive(Deserialize, Debug)]
struct ToolUv {
    workspace: Option<UvWorkspace>,
}

#[derive(Deserialize, Debug, Default)]
struct UvWorkspace {
    #[serde(default)]
    members: Vec<String>,
    #[serde(default)]
    exclude: Vec<String>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn test_uv_venv_parse_valid_pyvenv_cfg() {
        let temp_dir = TempDir::new().unwrap();
        let cfg_path = temp_dir.path().join("pyvenv.cfg");

        let contents = r#"home = /usr/bin
include-system-site-packages = false
version = 3.11.0
executable = /usr/bin/python3.11
uv = 0.1.0
version_info = 3.11.0
prompt = test-env"#;

        std::fs::write(&cfg_path, contents).unwrap();

        let uv_venv = UvVenv::maybe_from_file(&cfg_path);
        assert!(uv_venv.is_some());

        let uv_venv = uv_venv.unwrap();
        assert_eq!(uv_venv.uv_version, "0.1.0");
        assert_eq!(uv_venv.python_version, "3.11.0");
        assert_eq!(uv_venv.prompt, "test-env");
    }

    #[test]
    fn test_uv_venv_parse_missing_uv_field() {
        let temp_dir = TempDir::new().unwrap();
        let cfg_path = temp_dir.path().join("pyvenv.cfg");

        let contents = r#"home = /usr/bin
version_info = 3.11.0
prompt = test-env"#;

        std::fs::write(&cfg_path, contents).unwrap();

        let uv_venv = UvVenv::maybe_from_file(&cfg_path);
        assert!(
            uv_venv.is_none(),
            "Should return None when 'uv' field is missing"
        );
    }

    #[test]
    fn test_uv_venv_parse_missing_version_info() {
        let temp_dir = TempDir::new().unwrap();
        let cfg_path = temp_dir.path().join("pyvenv.cfg");

        let contents = r#"home = /usr/bin
uv = 0.1.0
prompt = test-env"#;

        std::fs::write(&cfg_path, contents).unwrap();

        let uv_venv = UvVenv::maybe_from_file(&cfg_path);
        assert!(
            uv_venv.is_none(),
            "Should return None when 'version_info' field is missing"
        );
    }

    #[test]
    fn test_uv_venv_parse_missing_prompt() {
        let temp_dir = TempDir::new().unwrap();
        let cfg_path = temp_dir.path().join("pyvenv.cfg");

        let contents = r#"home = /usr/bin
uv = 0.1.0
version_info = 3.11.0"#;

        std::fs::write(&cfg_path, contents).unwrap();

        let uv_venv = UvVenv::maybe_from_file(&cfg_path);
        assert!(
            uv_venv.is_none(),
            "Should return None when 'prompt' field is missing"
        );
    }

    #[test]
    fn test_uv_venv_parse_with_whitespace() {
        let temp_dir = TempDir::new().unwrap();
        let cfg_path = temp_dir.path().join("pyvenv.cfg");

        let contents = r#"  uv = 0.2.5
  version_info = 3.12.1
  prompt = my-project  "#;

        std::fs::write(&cfg_path, contents).unwrap();

        let uv_venv = UvVenv::maybe_from_file(&cfg_path);
        assert!(uv_venv.is_some());

        let uv_venv = uv_venv.unwrap();
        assert_eq!(uv_venv.uv_version, "0.2.5");
        assert_eq!(uv_venv.python_version, "3.12.1");
        assert_eq!(uv_venv.prompt, "my-project");
    }

    #[test]
    fn test_uv_venv_parse_nonexistent_file() {
        let uv_venv = UvVenv::maybe_from_file(Path::new("/nonexistent/path/pyvenv.cfg"));
        assert!(uv_venv.is_none());
    }

    #[test]
    fn test_parse_pyproject_toml_with_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let pyproject_path = temp_dir.path().join("pyproject.toml");

        let contents = r#"[project]
name = "my-workspace"

[tool.uv.workspace]
members = ["packages/*"]"#;

        std::fs::write(&pyproject_path, contents).unwrap();

        let pyproject = parse_pyproject_toml_in(temp_dir.path());
        assert!(pyproject.is_some());

        let pyproject = pyproject.unwrap();
        assert!(pyproject.project.is_some());
        assert_eq!(
            pyproject.project.unwrap().name,
            Some("my-workspace".to_string())
        );
        assert!(pyproject.tool.is_some());
        assert!(pyproject.tool.unwrap().uv.is_some());
    }

    #[test]
    fn test_parse_pyproject_toml_without_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let pyproject_path = temp_dir.path().join("pyproject.toml");

        let contents = r#"[project]
name = "my-project"

[tool.uv]
dev-dependencies = ["pytest"]"#;

        std::fs::write(&pyproject_path, contents).unwrap();

        let pyproject = parse_pyproject_toml_in(temp_dir.path());
        assert!(pyproject.is_some());

        let pyproject = pyproject.unwrap();
        assert!(pyproject.project.is_some());
        assert_eq!(
            pyproject.project.unwrap().name,
            Some("my-project".to_string())
        );
    }

    #[test]
    fn test_parse_pyproject_toml_missing_file() {
        let temp_dir = TempDir::new().unwrap();
        let pyproject = parse_pyproject_toml_in(temp_dir.path());
        assert!(pyproject.is_none());
    }

    #[test]
    fn test_parse_pyproject_toml_invalid_toml() {
        let temp_dir = TempDir::new().unwrap();
        let pyproject_path = temp_dir.path().join("pyproject.toml");

        let contents = r#"[project
name = "invalid"#;

        std::fs::write(&pyproject_path, contents).unwrap();

        let pyproject = parse_pyproject_toml_in(temp_dir.path());
        assert!(pyproject.is_none());
    }

    #[test]
    fn test_list_envs_in_directory_with_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();

        // Create pyproject.toml with workspace
        let pyproject_path = project_path.join("pyproject.toml");
        let pyproject_contents = r#"[tool.uv.workspace]
members = ["packages/*"]"#;
        std::fs::write(&pyproject_path, pyproject_contents).unwrap();

        // Create .venv directory
        let venv_path = project_path.join(".venv");
        std::fs::create_dir_all(&venv_path).unwrap();

        // Create pyvenv.cfg
        let pyvenv_cfg_path = venv_path.join("pyvenv.cfg");
        let pyvenv_contents = r#"uv = 0.1.0
version_info = 3.11.0
prompt = workspace-env"#;
        std::fs::write(&pyvenv_cfg_path, pyvenv_contents).unwrap();

        // Create executables directory (Unix style for testing)
        let bin_path = venv_path.join("bin");
        std::fs::create_dir_all(&bin_path).unwrap();
        let python_path = bin_path.join("python");
        std::fs::File::create(&python_path).unwrap();

        let envs = list_envs_in_directory(project_path);
        assert_eq!(envs.len(), 1);
        assert_eq!(envs[0].kind, Some(PythonEnvironmentKind::UvWorkspace));
        assert_eq!(envs[0].name, Some("workspace-env".to_string()));
    }

    #[test]
    fn test_list_envs_in_directory_with_project() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();

        // Create pyproject.toml with project (no workspace)
        let pyproject_path = project_path.join("pyproject.toml");
        let pyproject_contents = r#"[project]
name = "my-project"

[tool.uv]
dev-dependencies = []"#;
        std::fs::write(&pyproject_path, pyproject_contents).unwrap();

        // Create .venv directory
        let venv_path = project_path.join(".venv");
        std::fs::create_dir_all(&venv_path).unwrap();

        // Create pyvenv.cfg
        let pyvenv_cfg_path = venv_path.join("pyvenv.cfg");
        let pyvenv_contents = r#"uv = 0.1.0
version_info = 3.11.0
prompt = my-project"#;
        std::fs::write(&pyvenv_cfg_path, pyvenv_contents).unwrap();

        // Create executables directory
        let bin_path = venv_path.join("bin");
        std::fs::create_dir_all(&bin_path).unwrap();
        let python_path = bin_path.join("python");
        std::fs::File::create(&python_path).unwrap();

        let envs = list_envs_in_directory(project_path);
        assert_eq!(envs.len(), 1);
        assert_eq!(envs[0].kind, Some(PythonEnvironmentKind::Uv));
        assert_eq!(envs[0].display_name, Some("my-project".to_string()));
    }

    #[test]
    fn test_list_envs_in_directory_no_pyproject() {
        let temp_dir = TempDir::new().unwrap();
        let envs = list_envs_in_directory(temp_dir.path());
        assert_eq!(envs.len(), 0);
    }

    #[test]
    fn test_list_envs_in_directory_no_venv() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();

        // Create pyproject.toml but no .venv
        let pyproject_path = project_path.join("pyproject.toml");
        let pyproject_contents = r#"[project]
name = "my-project""#;
        std::fs::write(&pyproject_path, pyproject_contents).unwrap();

        let envs = list_envs_in_directory(project_path);
        assert_eq!(envs.len(), 0);
    }

    #[test]
    fn test_is_workspace_member_matches_glob() {
        let root = Path::new("/workspace");
        let project = Path::new("/workspace/packages/foo");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec![],
        };
        assert!(is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_is_workspace_member_no_match() {
        let root = Path::new("/workspace");
        let project = Path::new("/workspace/other/bar");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec![],
        };
        assert!(!is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_is_workspace_member_excluded() {
        let root = Path::new("/workspace");
        let project = Path::new("/workspace/packages/excluded");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec!["packages/excluded".to_string()],
        };
        assert!(!is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_is_workspace_member_empty_members_implies_all() {
        let root = Path::new("/workspace");
        let project = Path::new("/workspace/anything/here");
        let ws = UvWorkspace {
            members: vec![],
            exclude: vec![],
        };
        assert!(is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_is_workspace_member_outside_workspace() {
        let root = Path::new("/workspace");
        let project = Path::new("/other/project");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec![],
        };
        assert!(!is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_is_workspace_member_workspace_root_is_always_member() {
        let root = Path::new("/workspace");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec![],
        };
        assert!(is_workspace_member(root, root, &ws));
    }

    #[test]
    fn test_is_workspace_member_exclude_takes_precedence() {
        let root = Path::new("/workspace");
        let project = Path::new("/workspace/packages/foo");
        let ws = UvWorkspace {
            members: vec!["packages/*".to_string()],
            exclude: vec!["packages/foo".to_string()],
        };
        assert!(!is_workspace_member(root, project, &ws));
    }

    #[test]
    fn test_find_workspace_for_project_discovers_parent() {
        let temp_dir = TempDir::new().unwrap();
        let workspace_root = temp_dir.path();

        // Create workspace pyproject.toml
        let pyproject_contents = r#"[project]
name = "my-workspace"

[tool.uv.workspace]
members = ["packages/*"]"#;
        std::fs::write(workspace_root.join("pyproject.toml"), pyproject_contents).unwrap();

        // Create workspace .venv with uv pyvenv.cfg
        let venv_path = workspace_root.join(".venv");
        std::fs::create_dir_all(&venv_path).unwrap();
        let pyvenv_contents = r#"uv = 0.5.0
version_info = 3.12.0
prompt = my-workspace"#;
        std::fs::write(venv_path.join("pyvenv.cfg"), pyvenv_contents).unwrap();

        // Create a member project directory
        let member_path = workspace_root.join("packages").join("foo");
        std::fs::create_dir_all(&member_path).unwrap();

        // find_workspace_for_project should find the workspace
        let env = find_workspace_for_project(&member_path);
        assert!(env.is_some());
        let env = env.unwrap();
        assert_eq!(env.kind, Some(PythonEnvironmentKind::UvWorkspace));
        assert_eq!(env.name, Some("my-workspace".to_string()));
    }

    #[test]
    fn test_find_workspace_for_project_self_workspace() {
        // Edge case: project_path itself defines both [project] and [tool.uv.workspace]
        let temp_dir = TempDir::new().unwrap();
        let workspace_root = temp_dir.path();

        // Create pyproject.toml with both [project] and [tool.uv.workspace]
        let pyproject_contents = r#"[project]
name = "mono-repo"

[tool.uv.workspace]
members = ["packages/*"]"#;
        std::fs::write(workspace_root.join("pyproject.toml"), pyproject_contents).unwrap();

        // Create workspace .venv with uv pyvenv.cfg
        let venv_path = workspace_root.join(".venv");
        std::fs::create_dir_all(&venv_path).unwrap();
        let pyvenv_contents = r#"uv = 0.5.0
version_info = 3.12.0
prompt = mono-repo"#;
        std::fs::write(venv_path.join("pyvenv.cfg"), pyvenv_contents).unwrap();

        // find_workspace_for_project should find the workspace at project_path itself
        let env = find_workspace_for_project(workspace_root);
        assert!(
            env.is_some(),
            "Should discover workspace at project_path itself"
        );
        let env = env.unwrap();
        assert_eq!(env.kind, Some(PythonEnvironmentKind::UvWorkspace));
        assert_eq!(env.name, Some("mono-repo".to_string()));
    }

    #[test]
    fn test_find_workspace_for_project_excluded_member() {
        let temp_dir = TempDir::new().unwrap();
        let workspace_root = temp_dir.path();

        // Create workspace pyproject.toml that excludes our project
        let pyproject_contents = r#"[project]
name = "my-workspace"

[tool.uv.workspace]
members = ["packages/*"]
exclude = ["packages/excluded"]"#;
        std::fs::write(workspace_root.join("pyproject.toml"), pyproject_contents).unwrap();

        // Create workspace .venv
        let venv_path = workspace_root.join(".venv");
        std::fs::create_dir_all(&venv_path).unwrap();
        let pyvenv_contents = r#"uv = 0.5.0
version_info = 3.12.0
prompt = my-workspace"#;
        std::fs::write(venv_path.join("pyvenv.cfg"), pyvenv_contents).unwrap();

        // Create the excluded project
        let excluded_path = workspace_root.join("packages").join("excluded");
        std::fs::create_dir_all(&excluded_path).unwrap();

        // Should NOT find a workspace for the excluded project
        let env = find_workspace_for_project(&excluded_path);
        assert!(env.is_none());
    }

    #[test]
    fn test_parse_workspace_members_and_excludes() {
        let temp_dir = TempDir::new().unwrap();
        let pyproject_path = temp_dir.path().join("pyproject.toml");

        let contents = r#"[project]
name = "my-workspace"

[tool.uv.workspace]
members = ["packages/*", "libs/*"]
exclude = ["packages/legacy"]"#;

        std::fs::write(&pyproject_path, contents).unwrap();

        let pyproject = parse_pyproject_toml_in(temp_dir.path());
        assert!(pyproject.is_some());
        let pyproject = pyproject.unwrap();
        let workspace = pyproject.tool.unwrap().uv.unwrap().workspace.unwrap();
        assert_eq!(workspace.members, vec!["packages/*", "libs/*"]);
        assert_eq!(workspace.exclude, vec!["packages/legacy"]);
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_cpython() {
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.14.3-linux-x86_64-gnu"),
            Some("3.14.3".to_string())
        );
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_minor_only() {
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.12-macos-aarch64-none"),
            Some("3.12".to_string())
        );
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_pypy() {
        assert_eq!(
            parse_version_from_uv_dir_name("pypy-3.10.14-linux-x86_64-gnu"),
            Some("3.10.14".to_string())
        );
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_invalid() {
        assert_eq!(parse_version_from_uv_dir_name("not-a-version"), None);
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_single_segment() {
        assert_eq!(parse_version_from_uv_dir_name("cpython"), None);
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_rejects_single_number() {
        // "9" is a digit but not a valid X.Y version
        assert_eq!(parse_version_from_uv_dir_name("cpython-9-linux"), None);
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_rejects_non_numeric_components() {
        // Version components must start with a digit — "3.abc.def" should be rejected.
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.abc.def-linux"),
            None
        );
        // Empty component after dot.
        assert_eq!(parse_version_from_uv_dir_name("cpython-3.12.-linux"), None);
        // Non-numeric middle component must be rejected even if it starts with a digit.
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.12abc.1-linux"),
            None
        );
        // 2-component version with non-numeric minor must be rejected.
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.12abc-linux-x86_64-gnu"),
            None
        );
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_rejects_missing_platform() {
        // Bare "<impl>-<version>" without platform segment should be rejected.
        assert_eq!(parse_version_from_uv_dir_name("cpython-3.12"), None);
    }

    #[test]
    fn test_parse_version_from_uv_dir_name_accepts_prerelease() {
        // Pre-release versions like "3.14.0a4" are valid uv install dirs.
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.14.0a4-linux-x86_64-gnu"),
            Some("3.14.0a4".to_string())
        );
        assert_eq!(
            parse_version_from_uv_dir_name("cpython-3.13.0rc1-linux-x86_64-gnu"),
            Some("3.13.0rc1".to_string())
        );
    }

    #[test]
    fn test_find_managed_python_installs_discovers_versions() {
        let temp_dir = TempDir::new().unwrap();
        let install_dir = temp_dir.path();

        // Create a cpython-3.12.3-... directory with a Python executable.
        // On Windows, find_executable looks for python.exe at root; on Unix, bin/python.
        let version_dir = install_dir.join("cpython-3.12.3-linux-x86_64-gnu");
        if cfg!(windows) {
            std::fs::create_dir_all(&version_dir).unwrap();
            std::fs::File::create(version_dir.join("python.exe")).unwrap();
        } else {
            let bin_dir = version_dir.join("bin");
            std::fs::create_dir_all(&bin_dir).unwrap();
            std::fs::File::create(bin_dir.join("python")).unwrap();
            std::fs::File::create(bin_dir.join("python3")).unwrap();
            std::fs::File::create(bin_dir.join("python3.12")).unwrap();
        }

        let envs = find_managed_python_installs(install_dir);
        assert_eq!(envs.len(), 1);
        assert_eq!(envs[0].kind, Some(PythonEnvironmentKind::Uv));
        assert_eq!(envs[0].version, Some("3.12.3".to_string()));
    }

    #[test]
    fn test_find_managed_python_installs_multiple_versions() {
        let temp_dir = TempDir::new().unwrap();
        let install_dir = temp_dir.path();

        // Create two version directories
        for dir_name in &[
            "cpython-3.12.3-linux-x86_64-gnu",
            "cpython-3.14.3-linux-x86_64-gnu",
        ] {
            let version_dir = install_dir.join(dir_name);
            if cfg!(windows) {
                std::fs::create_dir_all(&version_dir).unwrap();
                std::fs::File::create(version_dir.join("python.exe")).unwrap();
            } else {
                let bin_dir = version_dir.join("bin");
                std::fs::create_dir_all(&bin_dir).unwrap();
                std::fs::File::create(bin_dir.join("python")).unwrap();
            }
        }

        let envs = find_managed_python_installs(install_dir);
        assert_eq!(envs.len(), 2);
    }

    #[test]
    fn test_find_managed_python_installs_empty_dir() {
        let temp_dir = TempDir::new().unwrap();
        let envs = find_managed_python_installs(temp_dir.path());
        assert_eq!(envs.len(), 0);
    }

    #[test]
    fn test_find_managed_python_installs_nonexistent_dir() {
        let envs = find_managed_python_installs(Path::new("/nonexistent/path"));
        assert_eq!(envs.len(), 0);
    }

    #[test]
    fn test_find_managed_python_installs_skips_non_version_dirs() {
        let temp_dir = TempDir::new().unwrap();
        let install_dir = temp_dir.path();

        // Create a directory that doesn't match the version pattern
        let non_version_dir = install_dir.join("some-random-dir");
        std::fs::create_dir_all(&non_version_dir).unwrap();

        let envs = find_managed_python_installs(install_dir);
        assert_eq!(envs.len(), 0);
    }

    #[test]
    fn test_try_from_managed_install_identifies_uv_python() {
        use pet_core::env::PythonEnv;

        let temp_dir = TempDir::new().unwrap();
        // Normalize install_dir the same way get_uv_python_install_dir does,
        // so the path casing matches the norm_case applied by PythonEnv::new().
        let install_dir = norm_case(temp_dir.path());

        // Create a uv-managed Python install
        let version_dir = install_dir.join("cpython-3.12.3-linux-x86_64-gnu");
        let executable = if cfg!(windows) {
            std::fs::create_dir_all(&version_dir).unwrap();
            let exe = version_dir.join("python.exe");
            std::fs::File::create(&exe).unwrap();
            exe
        } else {
            let bin_dir = version_dir.join("bin");
            std::fs::create_dir_all(&bin_dir).unwrap();
            let exe = bin_dir.join("python");
            std::fs::File::create(&exe).unwrap();
            exe
        };

        let uv = Uv {
            workspace_directories: Arc::new(Mutex::new(Vec::new())),
            uv_install_dir: Some(install_dir),
        };

        let python_env = PythonEnv::new(executable, Some(version_dir.clone()), None);
        let result = uv.try_from_managed_install(&python_env);
        assert!(
            result.is_some(),
            "Should identify uv-managed Python install"
        );
        let env = result.unwrap();
        assert_eq!(env.kind, Some(PythonEnvironmentKind::Uv));
        assert_eq!(env.version, Some("3.12.3".to_string()));
    }

    #[test]
    fn test_try_from_managed_install_rejects_non_uv_python() {
        use pet_core::env::PythonEnv;

        let temp_dir = TempDir::new().unwrap();
        let install_dir = temp_dir.path().join("uv_python");
        std::fs::create_dir_all(&install_dir).unwrap();

        // Create a Python executable *outside* the uv install dir
        let other_dir = temp_dir.path().join("other");
        std::fs::create_dir_all(&other_dir).unwrap();
        let exe = other_dir.join(if cfg!(windows) {
            "python.exe"
        } else {
            "python"
        });
        std::fs::File::create(&exe).unwrap();

        let uv = Uv {
            workspace_directories: Arc::new(Mutex::new(Vec::new())),
            uv_install_dir: Some(install_dir),
        };

        let python_env = PythonEnv::new(exe, Some(other_dir), None);
        let result = uv.try_from_managed_install(&python_env);
        assert!(
            result.is_none(),
            "Should not identify Python outside uv install dir"
        );
    }
}