cargo_e/

e_target.rs

// src/e_target.rs
use anyhow::{Context, Result};
use log::{debug, trace};
use std::{
    collections::HashMap,
    ffi::OsString,
    fs,
    path::{Path, PathBuf},
};
use toml::Value;

#[derive(Debug, Clone)]
pub enum TargetOrigin {
    DefaultBinary(PathBuf),
    SingleFile(PathBuf),
    MultiFile(PathBuf),
    SubProject(PathBuf),
    Named(OsString),
}

#[derive(Debug, Clone, PartialEq, Hash, Eq, Copy)]
pub enum TargetKind {
    Unknown,
    Example,
    ExtendedExample,
    Binary,
    ExtendedBinary,
    Bench,
    Test,
    Manifest, // For browsing the entire Cargo.toml or package-level targets.
    ManifestTauri,
    ManifestTauriExample,
    ManifestDioxusExample,
    ManifestDioxus,
    ManifestLeptos,
}

#[derive(Debug, Clone)]
pub struct CargoTarget {
    pub name: String,
    pub display_name: String,
    pub manifest_path: PathBuf,
    pub kind: TargetKind,
    pub extended: bool,
    pub toml_specified: bool,
    pub origin: Option<TargetOrigin>,
}

impl CargoTarget {
    /// Constructs a CargoTarget from a source file.
    ///
    /// Reads the file at `file_path` and determines the target kind based on:
    /// - Tauri configuration (e.g. if the manifest's parent is "src-tauri" or a Tauri config exists),
    /// - Dioxus markers in the file contents,
    /// - And finally, if the file contains "fn main", using its parent directory (examples vs bin) to decide.
    ///
    /// If none of these conditions are met, returns None.
    pub fn from_source_file(
        stem: &std::ffi::OsStr,
        file_path: &Path,
        manifest_path: &Path,
        example: bool,
        extended: bool,
    ) -> Option<Self> {
        let file_path = fs::canonicalize(&file_path).unwrap_or(file_path.to_path_buf());
        let file_contents = std::fs::read_to_string(&file_path).unwrap_or_default();
        let (kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            manifest_path,
            &file_path,
            &file_contents,
            example,
            extended,
            None,
        );
        if kind == TargetKind::Unknown {
            return None;
        }
        let name = stem.to_string_lossy().to_string();
        Some(CargoTarget {
            name: name.clone(),
            display_name: name,
            manifest_path: new_manifest.to_path_buf(),
            kind,
            extended,
            toml_specified: false,
            origin: Some(TargetOrigin::SingleFile(file_path.to_path_buf())),
        })
    }

    //     /// Updates the target's name and display_name by interrogating the candidate file and its manifest.
    //     pub fn figure_main_name(&mut self) {
    //         // Only operate if we have a candidate file path.
    //         let candidate = match &self.origin {
    //             Some(TargetOrigin::SingleFile(path)) | Some(TargetOrigin::DefaultBinary(path)) => path,
    //             _ => {
    //                 debug!("No candidate file found in target.origin; skipping name determination");
    //                 return;
    //             }
    //         };
    // println!("figure_main: {}", &candidate.display());
    //         // Get the candidate file's stem in lowercase.
    //         let candidate_stem = candidate
    //             .file_stem()
    //             .and_then(|s| s.to_str())
    //             .map(|s| s.to_lowercase())
    //             .unwrap_or_default();
    //         debug!("Candidate stem: {}", candidate_stem);

    //         // Start with folder-based logic.
    //         let mut name = if candidate_stem == "main"  {
    //             if let Some(parent_dir) = candidate.parent() {
    //                 if let Some(parent_name) = parent_dir.file_name().and_then(|s| s.to_str()) {
    //                     debug!("Candidate parent folder: {}", parent_name);
    //                     if parent_name.eq_ignore_ascii_case("src") {
    //                         // If candidate is src/main.rs, take the parent of "src".
    //                         parent_dir
    //                             .parent()
    //                             .and_then(|proj_dir| proj_dir.file_name())
    //                             .and_then(|s| s.to_str())
    //                             .map(|s| s.to_string())
    //                             .unwrap_or(candidate_stem.clone())
    //                     } else if parent_name.eq_ignore_ascii_case("examples") {
    //                         // If candidate is in an examples folder, use the candidate's parent folder's name.
    //                         candidate
    //                             .parent()
    //                             .and_then(|p| p.file_name())
    //                             .and_then(|s| s.to_str())
    //                             .map(|s| s.to_string())
    //                             .unwrap_or(candidate_stem.clone())
    //                     } else {
    //                         candidate_stem.clone()
    //                     }
    //                 } else {
    //                     candidate_stem.clone()
    //                 }
    //             } else {
    //                 candidate_stem.clone()
    //             }
    //         } else {
    //             candidate_stem.clone()
    //         };

    //         let mut package_manifest_name = String::new();
    //         // If the candidate stem is "main", interrogate the manifest.
    //         let manifest_contents = fs::read_to_string(&self.manifest_path).unwrap_or_default();
    //         if let Ok(manifest_toml) = manifest_contents.parse::<Value>() {
    //             if let Ok(manifest_toml) = manifest_contents.parse::<toml::Value>() {
    //                 // Then try to retrieve the bin section.
    //                 if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
    //                     debug!("Found {} [[bin]] entries {:?}", bins.len(), bins);
    //                 } else {
    //                     debug!("No [[bin]] array found in manifest");
    //                 }
    //             } else {
    //                 debug!("Failed to parse manifest TOML");
    //             }
    //             debug!("Opened manifest {:?}",&self.manifest_path);
    //             // Check for any [[bin]] entries.
    //             if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
    //                 debug!("Found {} [[bin]] entries", bins.len());
    //                 if let Some(bin_name) = bins.iter().find_map(|bin| {
    //                     if let Some(path_str) = bin.get("path").and_then(|p| p.as_str()) {
    //                         let bp = bin
    //                         .get("path")
    //                         .and_then(|n| n.as_str())
    //                         .map(|s| s.to_string());
    //                     let bn = bin
    //                                 .get("name")
    //                                 .and_then(|n| n.as_str())
    //                                 .map(|s| s.to_string());
    //                             debug!("Checking bin entry with path: {} {:?}", path_str, bp);
    //                             if bp.as_deref().unwrap_or("") == path_str
    //                             // && bn.as_deref().unwrap_or("") == candidate_stem
    //                         {
    //                             debug!("Found matching bin with name: {:?} {:?}=={:?}", bn,bp.as_deref().unwrap_or(""), path_str);
    //                             name = bn.clone().unwrap_or_default();
    //                             return bn.clone();
    //                         }
    //                     }
    //                     None
    //                 }) {
    //                     //debug!("Using bin name from manifest: {} as {} ", name, bin_name);
    //                     //name = bin_name;
    //                 } else if let Some(pkg) = manifest_toml.get("package") {
    //                     debug!("No matching [[bin]] entry; checking [package] section");
    //                     name = pkg
    //                         .get("name")
    //                         .and_then(|n| n.as_str())
    //                         .unwrap_or(&name)
    //                         .to_string();
    //                     debug!("Using package name from manifest: {}", name);
    //                 }
    //             } else if let Some(pkg) = manifest_toml.get("package") {
    //                 debug!("No [[bin]] section found; using [package] section");
    //                 package_manifest_name = pkg
    //                 .get("name")
    //                 .and_then(|n| n.as_str())
    //                 .unwrap_or(&name)
    //                 .to_string();
    //                 debug!("Using package name from manifest: {}", name);
    //             } else {
    //                 debug!(
    //                     "Manifest does not contain [[bin]] or [package] sections; keeping name: {}",
    //                     name
    //                 );
    //             }
    //         } else {
    //             debug!("Failed to open manifest {:?}",&self.manifest_path);
    //             debug!("Failed to parse manifest TOML; keeping name: {}", name);
    //         }

    //         debug!("Name after folder-based logic: {}", name);

    //         debug!("Final determined name: {}", name);
    //         if name.eq("main") {
    //             panic!("Name is main");
    //         }
    //         self.name = name.clone();
    //         self.display_name = name;
    //     }

    pub fn figure_main_name(&mut self) {
        let mut is_toml_specified = false;
        // Only operate if we have a candidate file path.
        let candidate = match &self.origin {
            Some(TargetOrigin::SingleFile(path)) | Some(TargetOrigin::DefaultBinary(path)) => path,
            _ => {
                debug!("No candidate file found in target.origin; skipping name determination");
                return;
            }
        };

        trace!("figure_main: {:?}", &self.origin);

        // Get the candidate file's stem in lowercase.
        let mut candidate_stem = candidate
            .file_stem()
            .and_then(|s| s.to_str())
            .map(|s| s.to_lowercase())
            .unwrap_or_default();
        trace!("Candidate stem: {}", candidate_stem);

        // First, check if the manifest path from self matches what we find upward.
        let candidate_dir = candidate.parent().unwrap_or(candidate);
        let found_manifest_dir = crate::e_manifest::find_manifest_dir_from(candidate_dir);
        if let Ok(found_dir) = found_manifest_dir {
            let found_manifest = found_dir.join("Cargo.toml");
            if found_manifest == self.manifest_path {
                trace!(
                    "{} Manifest path matches candidate's upward search result: {:?}",
                    candidate.display(),
                    found_manifest
                );
            } else {
                trace!(
                "{} Manifest path mismatch. Found upward: {:?} but target.manifest_path is: {:?}"
                , candidate.display(), found_manifest, self.manifest_path
            );
                // Compare depths.
                let found_depth = found_manifest.components().count();
                let target_depth = self.manifest_path.components().count();
                if found_depth > target_depth {
                    // Before switching, compare the candidate's relative paths.
                    let orig_parent = self.manifest_path.parent().unwrap_or_else(|| Path::new(""));
                    let found_parent = found_manifest.parent().unwrap_or_else(|| Path::new(""));
                    let orig_rel = candidate.strip_prefix(orig_parent).ok();
                    let found_rel = candidate.strip_prefix(found_parent).ok();
                    if orig_rel == found_rel {
                        trace!(
                            "{} Relative path matches: {:?}",
                            candidate.display(),
                            orig_rel
                        );
                        self.manifest_path = found_manifest;
                    } else {
                        trace!(
                            "{} Relative path mismatch: original: {:?}, found: {:?}",
                            candidate.display(),
                            orig_rel,
                            found_rel
                        );
                    }
                } else {
                    trace!(
                        "{} Keeping target manifest path (deeper or equal): {:?}",
                        candidate.display(),
                        self.manifest_path
                    );
                }
            }
        } else {
            trace!(
                "Could not locate Cargo.toml upward from candidate: {:?}",
                candidate
            );
        }

        // Determine name via manifest processing.
        let mut name = candidate_stem.clone();
        let manifest_contents = fs::read_to_string(&self.manifest_path).unwrap_or_default();
        if let Ok(manifest_toml) = manifest_contents.parse::<Value>() {
            trace!(
                "{} Opened manifest {:?}",
                candidate.display(),
                &self.manifest_path
            );

            // // First, check for any [[bin]] entries.
            // if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
            //     trace!("Found {} [[bin]] entries", bins.len());
            //     // Iterate over the bin entries and use absolute paths for comparison.
            //     if let Some(bin_name) = bins.iter().find_map(|bin| {
            //         if let (Some(rel_path_str), Some(bn)) = (
            //             bin.get("path").and_then(|p| p.as_str()),
            //             bin.get("name").and_then(|n| n.as_str()),
            //         ) {
            //             // Construct the expected absolute path for the candidate file.
            //             let manifest_parent =
            //                 self.manifest_path.parent().unwrap_or_else(|| Path::new(""));
            //             let expected_path =
            //                 fs::canonicalize(manifest_parent.join(rel_path_str)).ok()?;
            //             let candidate_abs = fs::canonicalize(candidate).ok()?;
            //             trace!(
            //                 "\n{}\n{:?}\nactual candidate absolute path:\n{:?}",
            //                 candidate.display(),
            //                 expected_path,
            //                 candidate_abs
            //             );
            //             if expected_path == candidate_abs {
            //                 trace!(
            //                     "{} Found matching bin with name: {}",
            //                     candidate.display(),
            //                     bn
            //                 );
            //                 return Some(bn.to_string());
            //             }
            //         }
            //         None
            //     }) {
            //         trace!(
            //             "{} Using bin name from manifest: {}",
            //             candidate.display(),
            //             bin_name
            //         );
            //         name = bin_name.clone();
            //         candidate_stem = bin_name.into();
            //     }
            //        }
            if let Some(bin_name) = crate::e_manifest::find_candidate_name(
                &manifest_toml,
                "bin",
                candidate,
                &self.manifest_path,
            ) {
                trace!(
                    "{} Using bin name from manifest: {}",
                    candidate.display(),
                    bin_name
                );
                is_toml_specified = true;
                name = bin_name.clone();
                candidate_stem = bin_name.into();
            } else if let Some(example_name) = crate::e_manifest::find_candidate_name(
                &manifest_toml,
                "example",
                candidate,
                &self.manifest_path,
            ) {
                is_toml_specified = true;
                trace!(
                    "{} Using example name from manifest: {}",
                    candidate.display(),
                    example_name
                );
                name = example_name.clone();
                candidate_stem = example_name.into();
            } else {
                match &self.origin {
                    Some(TargetOrigin::DefaultBinary(_path)) => {
                        // Check for any [package] section.
                        if let Some(pkg) = manifest_toml.get("package") {
                            trace!("Found [package] section in manifest");
                            if let Some(name_value) = pkg.get("name").and_then(|v| v.as_str()) {
                                trace!("Using package name from manifest: {}", name_value);
                                name = name_value.to_string();
                                candidate_stem = name.clone();
                            } else {
                                trace!("No package name found in manifest; keeping name: {}", name);
                            }
                        }
                    }
                    _ => {}
                };
            }

            // if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
            //     trace!("Found {} [[bin]] entries", bins.len());
            //     // Iterate over the bin entries and use absolute paths for comparison.
            //     if let Some(bin_name) = bins.iter().find_map(|bin| {
            //         if let (Some(rel_path_str), Some(bn)) = (
            //             bin.get("path").and_then(|p| p.as_str()),
            //             bin.get("name").and_then(|n| n.as_str()),
            //         ) {
            //             // Construct the expected absolute path for the candidate file.
            //             let manifest_parent = self.manifest_path.parent().unwrap_or_else(|| Path::new(""));
            //             let expected_path = fs::canonicalize(manifest_parent.join(rel_path_str)).ok()?;
            //             let candidate_abs = fs::canonicalize(candidate).ok()?;
            //             trace!(
            //                 "{} Expected candidate absolute path: {:?}, actual candidate absolute path: {:?}",
            //                 candidate.display(),
            //                 expected_path,
            //                 candidate_abs
            //             );
            //             if expected_path == candidate_abs {
            //                 trace!(
            //                     "{} Found matching bin with name: {}",
            //                     candidate.display(),
            //                     bn
            //                 );
            //                 return Some(bn.to_string());
            //             }
            //         }
            //         None
            //     }) {
            //         trace!("{} Using bin name from manifest: {}", candidate.display(), bin_name);
            //         name = bin_name;
            //     }
            //}
        } else {
            trace!("Failed to open manifest {:?}", &self.manifest_path);
            trace!("Failed to parse manifest TOML; keeping name: {}", name);
        }

        // Only if the candidate stem is "main", apply folder-based logic after manifest processing.
        if candidate_stem == "main" {
            let folder_name = if let Some(parent_dir) = candidate.parent() {
                if let Some(parent_name) = parent_dir.file_name().and_then(|s| s.to_str()) {
                    trace!("Candidate parent folder: {}", parent_name);
                    if parent_name.eq_ignore_ascii_case("src")
                        || parent_name.eq_ignore_ascii_case("src-tauri")
                    {
                        // If candidate is src/main.rs, take the parent of "src".
                        let p = parent_dir
                            .parent()
                            .and_then(|proj_dir| proj_dir.file_name())
                            .and_then(|s| s.to_str())
                            .map(|s| s.to_string())
                            .unwrap_or(candidate_stem.clone());
                        if p.eq("src-tauri") {
                            let maybe_name = parent_dir
                                .parent()
                                .and_then(|proj_dir| proj_dir.parent())
                                .and_then(|proj_dir| proj_dir.file_name())
                                .and_then(|s| s.to_str())
                                .map(String::from);
                            match maybe_name {
                                Some(name) => name,
                                None => candidate_stem.clone(),
                            }
                        } else {
                            p
                        }
                    } else if parent_name.eq_ignore_ascii_case("examples") {
                        // If candidate is in an examples folder, use the candidate's parent folder's name.
                        candidate
                            .parent()
                            .and_then(|p| p.file_name())
                            .and_then(|s| s.to_str())
                            .map(|s| s.to_string())
                            .unwrap_or(candidate_stem.clone())
                    } else {
                        parent_name.into()
                    }
                } else {
                    candidate_stem.clone()
                }
            } else {
                candidate_stem.clone()
            };
            trace!("Folder-based name: {}-{}", candidate.display(), folder_name);
            // Only override if the folder-based name is different from "main".
            if folder_name != "main" {
                name = folder_name;
            }
        }

        trace!("Final determined name: {}", name);
        if name.eq("main") {
            panic!("Name is main");
        }
        if is_toml_specified {
            self.toml_specified = true;
        }
        self.name = name.clone();
        self.display_name = name;
    }
    /// Constructs a CargoTarget from a folder by trying to locate a runnable source file.
    ///
    /// The function attempts the following candidate paths in order:
    /// 1. A file named `<folder_name>.rs` in the folder.
    /// 2. `src/main.rs` inside the folder.
    /// 3. `main.rs` at the folder root.
    /// 4. Otherwise, it scans the folder for any `.rs` file containing `"fn main"`.
    ///
    /// Once a candidate is found, it reads its contents and calls `determine_target_kind`
    /// to refine the target kind based on Tauri or Dioxus markers. The `extended` flag
    /// indicates whether the target should be marked as extended (for instance, if the folder
    /// is a subdirectory of the primary "examples" or "bin" folder).
    ///
    /// Returns Some(CargoTarget) if a runnable file is found, or None otherwise.
    pub fn from_folder(
        folder: &Path,
        manifest_path: &Path,
        example: bool,
        _extended: bool,
    ) -> Option<Self> {
        // If the folder contains its own Cargo.toml, treat it as a subproject.
        let sub_manifest = folder.join("Cargo.toml");
        if sub_manifest.exists() {
            // Use the folder's name as the candidate target name.
            let folder_name = folder.file_name()?.to_string_lossy().to_string();
            // Determine the display name from the parent folder.
            let display_name = if let Some(parent) = folder.parent() {
                let parent_name = parent.file_name()?.to_string_lossy();
                if parent_name == folder_name {
                    // If the parent's name equals the folder's name, try using the grandparent.
                    if let Some(grandparent) = parent.parent() {
                        grandparent.file_name()?.to_string_lossy().to_string()
                    } else {
                        folder_name.clone()
                    }
                } else {
                    parent_name.to_string()
                }
            } else {
                folder_name.clone()
            };

            let sub_manifest =
                fs::canonicalize(&sub_manifest).unwrap_or(sub_manifest.to_path_buf());
            trace!("Subproject found: {}", sub_manifest.display());
            trace!("{}", &folder_name);
            return Some(CargoTarget {
                name: folder_name.clone(),
                display_name,
                manifest_path: sub_manifest.clone(),
                // For a subproject, we initially mark it as Manifest;
                // later refinement may resolve it further.
                kind: TargetKind::Manifest,
                toml_specified: true,
                extended: true,
                origin: Some(TargetOrigin::SubProject(sub_manifest)),
            });
        }
        // Extract the folder's name.
        let folder_name = folder.file_name()?.to_str()?;

        /// Returns Some(candidate) only if the file exists and its contents contain "fn main".
        fn candidate_with_main(candidate: PathBuf) -> Option<PathBuf> {
            if candidate.exists() {
                let contents = fs::read_to_string(&candidate).unwrap_or_default();
                if contents.contains("fn main") {
                    return Some(candidate);
                }
            }
            None
        }

        // In your from_folder function, for example:
        let candidate = if let Some(candidate) =
            candidate_with_main(folder.join(format!("{}.rs", folder_name)))
        {
            candidate
        } else if let Some(candidate) = candidate_with_main(folder.join("src/main.rs")) {
            candidate
        } else if let Some(candidate) = candidate_with_main(folder.join("main.rs")) {
            candidate
        } else {
            // Otherwise, scan the folder for any .rs file containing "fn main"
            let mut found = None;
            if let Ok(entries) = fs::read_dir(folder) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("rs") {
                        if let Some(candidate) = candidate_with_main(path) {
                            found = Some(candidate);
                            break;
                        }
                    }
                }
            }
            found?
        };

        let candidate = fs::canonicalize(&candidate).unwrap_or(candidate.to_path_buf());
        // Compute the extended flag based on the candidate file location.
        let extended = crate::e_discovery::is_extended_target(manifest_path, &candidate);

        // Read the candidate file's contents.
        let file_contents = std::fs::read_to_string(&candidate).unwrap_or_default();

        // Use our helper to determine if any special configuration applies.
        let (kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            manifest_path,
            &candidate,
            &file_contents,
            example,
            extended,
            None,
        );
        if kind == TargetKind::Unknown {
            return None;
        }

        // Determine the candidate file's stem in lowercase.
        let name = candidate.file_stem()?.to_str()?.to_lowercase();
        //         let name = if candidate_stem == "main" {
        //     if let Some(parent_dir) = candidate.parent() {
        //         if let Some(parent_name) = parent_dir.file_name().and_then(|s| s.to_str()) {
        //             if parent_name.eq_ignore_ascii_case("src") {
        //                 // If candidate is src/main.rs, take the parent of "src".
        //                 parent_dir.parent()
        //                     .and_then(|proj_dir| proj_dir.file_name())
        //                     .and_then(|s| s.to_str())
        //                     .map(|s| s.to_string())
        //                     .unwrap_or(candidate_stem.clone())
        //             } else if parent_name.eq_ignore_ascii_case("examples") {
        //                 // If candidate is in the examples folder (e.g. examples/main.rs),
        //                 // use the candidate's parent folder's name.
        //                 candidate.parent()
        //                     .and_then(|p| p.file_name())
        //                     .and_then(|s| s.to_str())
        //                     .map(|s| s.to_string())
        //                     .unwrap_or(candidate_stem.clone())
        //             } else {
        //                 // Fall back to the candidate_stem if no special case matches.
        //                 candidate_stem.clone()
        //             }
        //         } else {
        //             candidate_stem.clone()
        //         }
        //     } else {
        //         candidate_stem.clone()
        //     }
        // } else {
        //     candidate_stem.clone()
        // };
        // let name = if candidate_stem.clone() == "main" {
        //     // Read the manifest contents.
        //     let manifest_contents = fs::read_to_string(manifest_path).unwrap_or_default();
        //     if let Ok(manifest_toml) = manifest_contents.parse::<toml::Value>() {
        //         // Look for any [[bin]] entries.
        //         if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
        //             if let Some(bin_name) = bins.iter().find_map(|bin| {
        //                 if let Some(path_str) = bin.get("path").and_then(|p| p.as_str()) {
        //                     if path_str == "src/bin/main.rs" {
        //                         return bin.get("name").and_then(|n| n.as_str()).map(|s| s.to_string());
        //                     }
        //                 }
        //                 None
        //             }) {
        //                 // Found a bin with the matching path; use its name.
        //                 bin_name
        //             } else if let Some(pkg) = manifest_toml.get("package") {
        //                 // No matching bin entry, so use the package name.
        //                 pkg.get("name").and_then(|n| n.as_str()).unwrap_or(&candidate_stem).to_string()
        //             } else {
        //                 candidate_stem.to_string()
        //             }
        //         } else if let Some(pkg) = manifest_toml.get("package") {
        //             // No [[bin]] section; use the package name.
        //             pkg.get("name").and_then(|n| n.as_str()).unwrap_or(&candidate_stem).to_string()
        //         } else {
        //             candidate_stem.to_string()
        //         }
        //     } else {
        //         candidate_stem.to_string()
        //     }
        // } else {
        //     candidate_stem.to_string()
        // };
        let mut target = CargoTarget {
            name: name.clone(),
            display_name: name,
            manifest_path: new_manifest.to_path_buf(),
            kind,
            extended,
            toml_specified: false,
            origin: Some(TargetOrigin::SingleFile(candidate)),
        };
        // Call the method to update name based on the candidate and manifest.
        target.figure_main_name();
        Some(target)
    }
    /// Returns a refined CargoTarget based on its file contents and location.
    /// This function is pure; it takes an immutable CargoTarget and returns a new one.
    /// If the target's origin is either SingleFile or DefaultBinary, it reads the file and uses
    /// `determine_target_kind` to update the kind accordingly.
    pub fn refined_target(target: &CargoTarget) -> CargoTarget {
        let mut refined = target.clone();

        // Operate only if the target has a file to inspect.
        let file_path = match &refined.origin {
            Some(TargetOrigin::SingleFile(path)) | Some(TargetOrigin::DefaultBinary(path)) => path,
            _ => return refined,
        };

        let file_path = fs::canonicalize(&file_path).unwrap_or(file_path.to_path_buf());
        let file_contents = std::fs::read_to_string(&file_path).unwrap_or_default();

        let (new_kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            &refined.manifest_path,
            &file_path,
            &file_contents,
            refined.is_example(),
            refined.extended,
            Some(refined.kind),
        );
        refined.kind = new_kind;
        refined.manifest_path = new_manifest;
        refined.figure_main_name();
        refined
    }

    /// Expands a subproject CargoTarget into multiple runnable targets.
    ///
    /// If the given target's origin is a subproject (i.e. its Cargo.toml is in a subfolder),
    /// this function loads that Cargo.toml and uses `get_runnable_targets` to discover its runnable targets.
    /// It then flattens and returns them as a single `Vec<CargoTarget>`.
    pub fn expand_subproject(target: &CargoTarget) -> Result<Vec<CargoTarget>> {
        // Ensure the target is a subproject.
        if let Some(TargetOrigin::SubProject(sub_manifest)) = &target.origin {
            // Use get_runnable_targets to get targets defined in the subproject.
            let (bins, examples, benches, tests) =
                crate::e_manifest::get_runnable_targets(sub_manifest).with_context(|| {
                    format!(
                        "Failed to get runnable targets from {}",
                        sub_manifest.display()
                    )
                })?;
            let mut sub_targets = Vec::new();
            sub_targets.extend(bins);
            sub_targets.extend(examples);
            sub_targets.extend(benches);
            sub_targets.extend(tests);

            // Optionally mark these targets as extended.
            for t in &mut sub_targets {
                t.extended = true;
                match t.kind {
                    TargetKind::Example => t.kind = TargetKind::ExtendedExample,
                    TargetKind::Binary => t.kind = TargetKind::ExtendedBinary,
                    _ => {} // For other kinds, you may leave them unchanged.
                }
            }
            Ok(sub_targets)
        } else {
            // If the target is not a subproject, return an empty vector.
            Ok(vec![])
        }
    }

    /// Expands subproject targets in the given map.
    /// For every target with a SubProject origin, this function removes the original target,
    /// expands it using `expand_subproject`, and then inserts the expanded targets.
    /// The expanded targets have their display names modified to include the original folder name as a prefix.
    /// This version replaces any existing target with the same key.
    pub fn expand_subprojects_in_place(
        targets_map: &mut HashMap<(String, String), CargoTarget>,
    ) -> Result<()> {
        // Collect keys for targets that are subprojects.
        let sub_keys: Vec<(String, String)> = targets_map
            .iter()
            .filter_map(|(key, target)| {
                if let Some(TargetOrigin::SubProject(_)) = target.origin {
                    Some(key.clone())
                } else {
                    None
                }
            })
            .collect();

        for key in sub_keys {
            if let Some(sub_target) = targets_map.remove(&key) {
                // Expand the subproject target.
                let expanded_targets = Self::expand_subproject(&sub_target)?;
                for mut new_target in expanded_targets {
                    // Update the display name to include the subproject folder name.
                    // For example, if sub_target.display_name was "foo" and new_target.name is "bar",
                    // the new display name becomes "foo > bar".
                    new_target.display_name =
                        format!("{} > {}", sub_target.display_name, new_target.name);
                    // Create a key for the expanded target.
                    let new_key = Self::target_key(&new_target);
                    // Replace any existing target with the same key.
                    targets_map.insert(new_key, new_target);
                }
            }
        }
        Ok(())
    }
    // /// Expands subproject targets in `targets`. Any target whose origin is a SubProject
    // /// is replaced by the targets returned by `expand_subproject`. If the expansion fails,
    // /// you can choose to log the error and keep the original target, or remove it.
    // pub fn expand_subprojects_in_place(
    //     targets_map: &mut HashMap<(String, String), CargoTarget>
    // ) -> anyhow::Result<()> {
    //     // Collect keys for subproject targets.
    //     let sub_keys: Vec<(String, String)> = targets_map
    //         .iter()
    //         .filter_map(|(key, target)| {
    //             if let Some(crate::e_target::TargetOrigin::SubProject(_)) = target.origin {
    //                 Some(key.clone())
    //             } else {
    //                 None
    //             }
    //         })
    //         .collect();

    //     // For each subproject target, remove it from the map, expand it, and insert the new targets.
    //     for key in sub_keys {
    //         if let Some(sub_target) = targets_map.remove(&key) {
    //             let expanded = Self::expand_subproject(&sub_target)?;
    //             for new_target in expanded {
    //                 let new_key = CargoTarget::target_key(&new_target);
    //                 targets_map.entry(new_key).or_insert(new_target);
    //             }
    //         }
    //     }
    //     Ok(())
    // }

    /// Creates a unique key for a target based on its manifest path and name.
    pub fn target_key(target: &CargoTarget) -> (String, String) {
        let manifest = target
            .manifest_path
            .canonicalize()
            .unwrap_or_else(|_| target.manifest_path.clone())
            .to_string_lossy()
            .into_owned();
        let name = target.name.clone();
        (manifest, name)
    }

    /// Expands a subproject target into multiple targets and inserts them into the provided HashMap,
    /// using (manifest, name) as a key to avoid duplicates.
    pub fn expand_subproject_into_map(
        target: &CargoTarget,
        map: &mut std::collections::HashMap<(String, String), CargoTarget>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        // Only operate if the target is a subproject.
        if let Some(crate::e_target::TargetOrigin::SubProject(sub_manifest)) = &target.origin {
            // Discover targets in the subproject.
            let (bins, examples, benches, tests) =
                crate::e_manifest::get_runnable_targets(sub_manifest)?;
            let mut new_targets = Vec::new();
            new_targets.extend(bins);
            new_targets.extend(examples);
            new_targets.extend(benches);
            new_targets.extend(tests);
            // Mark these targets as extended.
            for t in &mut new_targets {
                t.extended = true;
            }
            // Insert each new target if not already present.
            for new in new_targets {
                let key = CargoTarget::target_key(&new);
                map.entry(key).or_insert(new.clone());
            }
        }
        Ok(())
    }

    /// Returns true if the target is an example.
    pub fn is_example(&self) -> bool {
        matches!(
            self.kind,
            TargetKind::Example
                | TargetKind::ExtendedExample
                | TargetKind::ManifestDioxusExample
                | TargetKind::ManifestTauriExample
        )
    }
}

/// Returns the "depth" of a path, i.e. the number of components.
pub fn path_depth(path: &Path) -> usize {
    path.components().count()
}

/// Deduplicates targets that share the same (name, origin key). If duplicates are found,
/// the target with the manifest path of greater depth is kept.
pub fn dedup_targets(targets: Vec<CargoTarget>) -> Vec<CargoTarget> {
    let mut grouped: HashMap<(String, Option<String>), CargoTarget> = HashMap::new();

    for target in targets {
        // We'll group targets by (target.name, origin_key)
        // Create an origin key if available by canonicalizing the origin path.
        let origin_key = target.origin.as_ref().and_then(|origin| match origin {
            TargetOrigin::SingleFile(path)
            | TargetOrigin::DefaultBinary(path)
            | TargetOrigin::SubProject(path) => path
                .canonicalize()
                .ok()
                .map(|p| p.to_string_lossy().into_owned()),
            _ => None,
        });
        let key = (target.name.clone(), origin_key);

        grouped
            .entry(key)
            .and_modify(|existing| {
                let current_depth = path_depth(&target.manifest_path);
                let existing_depth = path_depth(&existing.manifest_path);
                // If the current target's manifest path is deeper, replace the existing target.
                if current_depth > existing_depth {
                    *existing = target.clone();
                }
            })
            .or_insert(target);
    }

    grouped.into_values().collect()
}