tree-type-proc-macro 0.4.3

//! Legacy codegen that is limited to one or two nested dynamic ids

use crate::core::Attribute;
use crate::core::Child;
use crate::core::DefaultValue;
use crate::core::TreeDef;
use quote::format_ident;
use quote::quote;
use syn::Ident;

// Generic dynamic ID information for arbitrary nesting depth
#[derive(Debug, Clone)]
#[expect(dead_code)]
struct DynamicIdInfo {
    id_type: proc_macro2::TokenStream,
}

// Collect all dynamic ancestor IDs from root to current level
#[allow(dead_code)]
fn collect_dynamic_ancestors(
    children: &[Child],
    target_name: &str,
    current_path: &mut Vec<DynamicIdInfo>,
    result: &mut Option<Vec<DynamicIdInfo>>,
) {
    for child in children {
        match child {
            Child::DynamicId {
                id_type,
                child_type,
                children,
                ..
            } => {
                // Add this dynamic ID to the path
                current_path.push(DynamicIdInfo {
                    id_type: quote! { #id_type },
                });

                // Check if this is our target
                if *child_type == target_name {
                    *result = Some(current_path.clone());
                    current_path.pop();
                    return;
                }

                // Recurse into children
                collect_dynamic_ancestors(children, target_name, current_path, result);

                // Remove this ID from path when backtracking
                current_path.pop();
            }
            Child::Directory { children, .. } => {
                // For non-dynamic children, recurse without adding to path
                collect_dynamic_ancestors(children, target_name, current_path, result);
            }
            Child::File { .. } => {
                // Files don't have children, nothing to recurse into
            }
        }
    }
}

/// Get parameter type and conversion for dynamic ID methods
fn get_param_type_and_conversion(
    id_type: &syn::Type,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    // Use impl Display for ergonomic API that accepts both &str and String
    (
        quote! { impl std::fmt::Display },
        quote! { id.to_string().parse::<#id_type>().expect("Failed to parse ID") },
    )
}

/// Generate serde derives - uses cfg!() at proc-macro compile time
pub fn get_serde_derives() -> proc_macro2::TokenStream {
    if cfg!(feature = "serde") {
        quote! {
            #[derive(serde::Serialize, serde::Deserialize)]
        }
    } else {
        quote! {}
    }
}

/// Generate serde derives for simple tuple structs (single field)
pub fn get_serde_derives_transparent() -> proc_macro2::TokenStream {
    if cfg!(feature = "serde") {
        quote! {
            #[derive(serde::Serialize, serde::Deserialize)]
            #[serde(transparent)]
        }
    } else {
        quote! {}
    }
}

/// Resolve a symlink target path by looking up identities in the tree structure
fn resolve_symlink_target_path(
    target_path: &str,
    root_children: &[Child],
    up_dirs: &str,
    _current_depth: usize,
) -> Option<proc_macro2::TokenStream> {
    // Handle absolute paths by stripping leading slash
    let path_to_resolve = target_path.strip_prefix('/').unwrap_or(target_path);

    // Split path into components
    let path_parts: Vec<&str> = path_to_resolve
        .split('/')
        .filter(|s| !s.is_empty())
        .collect();

    if path_parts.is_empty() {
        return None;
    }

    // Try to find the target identity in the root children
    if let Some(target_child) = find_child_by_identity(&path_parts, root_children) {
        // Check if the target has a custom filename
        let target_filename = match target_child {
            Child::File {
                custom_filename: Some(filename_lit),
                ..
            } => filename_lit.value(),
            Child::File {
                name,
                custom_filename: None,
                ..
            }
            | Child::Directory { name, .. } => {
                name.to_string() // Use identity name directly
            }
            Child::DynamicId { .. } => {
                // Dynamic IDs can't be resolved at compile time
                return None;
            }
        };

        // Build the relative path with the correct filename
        let path_prefix = if path_parts.len() > 1 {
            path_parts[..path_parts.len() - 1].join("/")
        } else {
            String::new()
        };

        let full_path = if path_prefix.is_empty() {
            format!("{up_dirs}{target_filename}")
        } else {
            format!("{up_dirs}{path_prefix}/{target_filename}")
        };

        return Some(quote! { #full_path });
    }

    None
}

/// Find a child by following the identity path
fn find_child_by_identity<'a>(path_parts: &[&str], children: &'a [Child]) -> Option<&'a Child> {
    if path_parts.is_empty() {
        return None;
    }

    let first_part = path_parts[0];
    let remaining_parts = &path_parts[1..];

    // Find the child with matching identity name
    for child in children {
        let child_name = match child {
            Child::File { name, .. } | Child::Directory { name, .. } => name.to_string(),
            Child::DynamicId { id_name, .. } => id_name.to_string(),
        };

        if child_name == first_part {
            if remaining_parts.is_empty() {
                // Found the target
                return Some(child);
            }
            // Continue searching in child's children
            if let Child::Directory {
                children: dir_children,
                ..
            } = child
            {
                return find_child_by_identity(remaining_parts, dir_children);
            }
        }
    }

    None
}

pub fn generate_code(tree: &TreeDef) -> proc_macro2::TokenStream {
    let root_name = &tree.name;
    let mut structs = Vec::new();

    // Generate root struct with full method set
    structs.push(generate_root_struct(root_name, &tree.children));

    // Generate child structs recursively
    generate_child_structs(root_name, &tree.children, &mut structs, 0, &tree.children);

    quote! {
        #(#structs)*
    }
}

#[allow(clippy::too_many_lines)]
fn generate_root_struct(name: &Ident, children: &[Child]) -> proc_macro2::TokenStream {
    let nav_methods = children
        .iter()
        .map(|child| generate_nav_method(name, child));

    let children_method = generate_children_method(children, false, false);
    let parent_method = generate_parent_method(None);

    let validate_impl = generate_validate_method(children);
    let setup_impl = generate_setup_method(children, 0, children); // Pass root children
    let ensure_impl = generate_ensure_method(children);
    let sync_impl = generate_sync_method(children);

    // Skip From impl for GenericDir to avoid conflict with reflexive impl
    let from_impl = if name == "GenericDir" {
        quote! {}
    } else {
        quote! {
            pub fn from_generic(dir: ::tree_type::GenericDir) -> Self {
                Self { path: dir.as_path().to_path_buf() }
            }
        }
    };

    let from_trait = if name == "GenericDir" {
        quote! {}
    } else {
        quote! {
            impl From<#name> for ::tree_type::GenericDir {
                fn from(dir: #name) -> Self {
                    Self::new(dir.path).expect("Path validation already performed")
                }
            }
        }
    };

    let serde_derives = get_serde_derives();
    let walk_fns = build_walk_fns();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericDir {
                ::tree_type::GenericDir::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn create(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir(&self.path)
            }

            pub fn create_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir_all(&self.path)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir(&self.path)
            }

            pub fn remove_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir_all(&self.path)
            }

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.path)
                    .map(|read_dir| read_dir.map(|result| result.and_then(::tree_type::GenericPath::try_from)))
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Returns the final component of the path as a String.
            /// For root paths like "/", returns an empty string.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            #walk_fns

            #validate_impl
            #setup_impl
            #ensure_impl
            #sync_impl

            #from_impl

            #(#nav_methods)*

            #children_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        #from_trait
    }
}

pub fn build_walk_fns() -> proc_macro2::TokenStream {
    // Use cfg!() at proc-macro compile time to decide whether to generate walk methods.
    // This ensures the decision is based on tree-type's features, not the consumer's.
    if cfg!(feature = "walk") {
        quote! {
            /// Create a WalkDir iterator for the given path
            pub fn walk_dir(&self) -> ::tree_type::deps::walk::WalkDir {
                self.as_generic().walk_dir()
            }

            /// Walk directory and return iterator of paths
            pub fn walk(&self) -> impl Iterator<Item = std::io::Result<::tree_type::GenericPath>> {
                ::tree_type::deps::walk::WalkDir::new(&self.path)
                    .into_iter()
                    .map(|r| r.map_err(|e| e.into()).and_then(::tree_type::GenericPath::try_from))
            }

            /// Calculate total size in bytes of directory contents
            pub fn size_in_bytes(&self) -> std::io::Result<u64> {
                self.as_generic().size_in_bytes()
            }

            /// List directory contents with metadata
            pub fn lsl(
                &self
            ) -> std::io::Result<Vec<(std::path::PathBuf, std::fs::Metadata)>> {
                self.as_generic().lsl()
            }
        }
    } else {
        quote! {}
    }
}

fn generate_child_structs(
    parent_name: &Ident,
    children: &[Child],
    structs: &mut Vec<proc_macro2::TokenStream>,
    depth: usize,
    root_children: &[Child],
) {
    generate_child_structs_with_parent_info(
        parent_name,
        children,
        structs,
        depth,
        root_children,
        None,
        false, // Root level, no grandparent
    );
}

fn generate_child_structs_with_parent_info(
    parent_name: &Ident,
    children: &[Child],
    structs: &mut Vec<proc_macro2::TokenStream>,
    depth: usize,
    root_children: &[Child],
    parent_dynamic_id_info: Option<&syn::Type>,
    grandparent_is_dynamic: bool,
) {
    for child in children {
        match child {
            Child::File {
                name,
                custom_type,
                attributes,
                ..
            } => generate_child_file_structs_with_parent_info(
                parent_name,
                structs,
                parent_dynamic_id_info,
                grandparent_is_dynamic,
                name,
                custom_type.as_ref(),
                attributes,
            ),
            Child::Directory {
                name,
                custom_type,
                children,
                ..
            } => generate_child_directory_structs_with_parent_info(
                parent_name,
                structs,
                depth,
                root_children,
                parent_dynamic_id_info,
                grandparent_is_dynamic,
                name,
                custom_type.as_ref(),
                children,
            ),
            Child::DynamicId {
                child_type,
                children,
                attributes,
                is_directory,
                id_name,
                id_type,
                ..
            } => generate_child_dynamic_id_structs_with_parent_info(
                parent_name,
                structs,
                depth,
                root_children,
                parent_dynamic_id_info,
                grandparent_is_dynamic,
                child_type,
                children,
                attributes,
                *is_directory,
                id_name,
                id_type,
            ),
        }
    }
}

#[expect(clippy::too_many_arguments)]
fn generate_child_dynamic_id_structs_with_parent_info(
    parent_name: &Ident,
    structs: &mut Vec<proc_macro2::TokenStream>,
    depth: usize,
    root_children: &[Child],
    parent_dynamic_id_info: Option<&syn::Type>,
    grandparent_is_dynamic: bool,
    child_type: &Ident,
    children: &[Child],
    attributes: &[Attribute],
    is_directory: bool,
    id_name: &Ident,
    id_type: &syn::Type,
) {
    if is_directory {
        if let Some(parent_id_type) = parent_dynamic_id_info {
            // Parent is a dynamic ID type, generate special directory struct with 3 parameters
            structs.push(generate_dynamic_dir_struct_with_dynamic_parent(
                child_type,
                children,
                depth + 1,
                root_children,
                parent_name,
                id_name,
                id_type,
                parent_id_type,
                grandparent_is_dynamic,
            ));
        } else {
            // Regular parent type, generate normal dynamic directory struct with 2 parameters
            structs.push(generate_dynamic_dir_struct(
                child_type,
                children,
                depth + 1,
                root_children,
                Some(parent_name),
                id_name,
                id_type,
            ));
        }
        // Pass dynamic ID info to children - dynamic ID directories always pass their ID to children
        generate_child_structs_with_parent_info(
            child_type,
            children,
            structs,
            depth + 1,
            root_children,
            Some(id_type),
            parent_dynamic_id_info.is_some(), // This dynamic ID is nested if its parent is also dynamic
        );
    } else if let Some(parent_id_type) = parent_dynamic_id_info {
        // Parent is a dynamic ID type, generate special file struct
        structs.push(generate_dynamic_file_struct_with_dynamic_parent(
            child_type,
            attributes,
            parent_name,
            id_name,
            id_type,
            parent_id_type,
            grandparent_is_dynamic,
        ));
    } else {
        // Regular parent type
        structs.push(generate_dynamic_file_struct(
            child_type,
            attributes,
            Some(parent_name),
            id_name,
            id_type,
        ));
    }
}

#[expect(clippy::too_many_arguments)]
fn generate_child_directory_structs_with_parent_info(
    parent_name: &Ident,
    structs: &mut Vec<proc_macro2::TokenStream>,
    depth: usize,
    root_children: &[Child],
    parent_dynamic_id_info: Option<&syn::Type>,
    grandparent_is_dynamic: bool,
    name: &Ident,
    custom_type: Option<&Ident>,
    children: &[Child],
) {
    let struct_name = get_child_type_name(parent_name, name, custom_type);
    if let Some(parent_id_type) = parent_dynamic_id_info {
        // Parent is a dynamic ID type, generate special directory struct
        structs.push(generate_dir_struct_with_dynamic_parent(
            &struct_name,
            children,
            depth + 1,
            root_children,
            parent_name,
            parent_id_type,
        ));
        // Propagate dynamic parent info to children so they can store parent ID for their parent methods
        generate_child_structs_with_parent_info(
            &struct_name,
            children,
            structs,
            depth + 1,
            root_children,
            Some(parent_id_type),
            grandparent_is_dynamic,
        );
    } else {
        // Regular parent type
        structs.push(generate_dir_struct(
            &struct_name,
            children,
            depth + 1,
            root_children,
            Some(parent_name),
        ));
        generate_child_structs(&struct_name, children, structs, depth + 1, root_children);
    }
}

fn generate_child_file_structs_with_parent_info(
    parent_name: &Ident,
    structs: &mut Vec<proc_macro2::TokenStream>,
    parent_dynamic_id_info: Option<&syn::Type>,
    grandparent_is_dynamic: bool,
    name: &Ident,
    custom_type: Option<&Ident>,
    attributes: &[Attribute],
) {
    let struct_name = get_child_type_name(parent_name, name, custom_type);
    if let Some(parent_id_type) = parent_dynamic_id_info {
        // Parent is a dynamic ID type, generate special file struct
        structs.push(generate_file_struct_with_dynamic_parent(
            &struct_name,
            attributes,
            parent_name,
            parent_id_type,
            grandparent_is_dynamic,
        ));
    } else {
        // Regular parent type
        structs.push(generate_file_struct(
            &struct_name,
            attributes,
            Some(parent_name),
        ));
    }
}

fn generate_nav_method_for_dynamic_id_parent(
    parent_name: &Ident,
    child: &Child,
    _parent_id_name: &Ident,
) -> proc_macro2::TokenStream {
    match child {
        Child::File {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let filename = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#filename), self.id.clone()).expect("Path validation already performed")
                }
            }
        }
        Child::Directory {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let filename = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#filename), self.id.clone()).expect("Path validation already performed")
                }
            }
        }
        Child::DynamicId { .. } => {
            // Dynamic ID children are handled by the existing generate_nav_method
            generate_nav_method_with_parent_info(parent_name, child, true)
        }
    }
}

fn generate_nav_method(parent_name: &Ident, child: &Child) -> proc_macro2::TokenStream {
    match child {
        Child::File {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let filename = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#filename)).expect("Path validation already performed")
                }
            }
        }
        Child::Directory {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let dirname = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#dirname)).expect("Path validation already performed")
                }
            }
        }
        Child::DynamicId {
            id_name,
            id_type,
            child_type,
            ..
        } => {
            // Generate parameterized method for type-safe access
            let method_name = id_name;

            // Generate type-specific reference signature based on ID type
            let (param_type, conversion) = get_param_type_and_conversion(id_type);

            quote! {
                /// Access a dynamic ID instance by reference.
                ///
                /// This method takes a reference to avoid consuming the parameter,
                /// allowing for better ergonomics and parameter reuse.
                pub fn #method_name(&self, id: #param_type) -> #child_type {
                    let id_value = #conversion;
                    #child_type::new(self.path.join(id_value.to_string()), id_value).expect("Path validation already performed")
                }
            }
        }
    }
}

fn generate_nav_method_with_parent_info(
    parent_name: &Ident,
    child: &Child,
    parent_is_dynamic_id: bool,
) -> proc_macro2::TokenStream {
    match child {
        Child::File {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let filename = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            if parent_is_dynamic_id {
                quote! {
                    pub fn #method_name(&self) -> #return_type {
                        #return_type::new(self.path.join(#filename), self.id.clone()).expect("Path validation already performed")
                    }
                }
            } else {
                quote! {
                    pub fn #method_name(&self) -> #return_type {
                        #return_type::new(self.path.join(#filename)).expect("Path validation already performed")
                    }
                }
            }
        }
        Child::Directory {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let dirname = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            if parent_is_dynamic_id {
                quote! {
                    pub fn #method_name(&self) -> #return_type {
                        #return_type::new(self.path.join(#dirname), self.id.clone()).expect("Path validation already performed")
                    }
                }
            } else {
                quote! {
                    pub fn #method_name(&self) -> #return_type {
                        #return_type::new(self.path.join(#dirname)).expect("Path validation already performed")
                    }
                }
            }
        }
        Child::DynamicId {
            id_name,
            id_type,
            child_type,
            ..
        } => {
            // Generate parameterized method for type-safe access
            let method_name = id_name;

            // Generate type-specific reference signature based on ID type
            let (param_type, conversion) = get_param_type_and_conversion(id_type);

            if parent_is_dynamic_id {
                quote! {
                    /// Access a dynamic ID instance by reference.
                    ///
                    /// This method takes a reference to avoid consuming the parameter,
                    /// allowing for better ergonomics and parameter reuse.
                    pub fn #method_name(&self, id: #param_type) -> #child_type {
                        let id_value = #conversion;
                        #child_type::new(self.path.join(id_value.to_string()), id_value, self.id.clone()).expect("Path validation already performed")
                    }
                }
            } else {
                quote! {
                    /// Access a dynamic ID instance by reference.
                    ///
                    /// This method takes a reference to avoid consuming the parameter,
                    /// allowing for better ergonomics and parameter reuse.
                    pub fn #method_name(&self, id: #param_type) -> #child_type {
                        let id_value = #conversion;
                        #child_type::new(self.path.join(id_value.to_string()), id_value).expect("Path validation already performed")
                    }
                }
            }
        }
    }
}

fn generate_nav_method_for_dynamic_parent_children(
    parent_name: &Ident,
    child: &Child,
) -> proc_macro2::TokenStream {
    match child {
        Child::File {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let filename = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#filename), self.parent_id.clone()).expect("Path validation already performed")
                }
            }
        }
        Child::Directory {
            name,
            custom_filename,
            custom_type,
            ..
        } => {
            let method_name = name;
            let dirname = custom_filename
                .as_ref()
                .map_or_else(|| name.to_string(), syn::LitStr::value);
            let return_type = get_child_type_name(parent_name, name, custom_type.as_ref());

            quote! {
                pub fn #method_name(&self) -> #return_type {
                    #return_type::new(self.path.join(#dirname), self.parent_id.clone()).expect("Path validation already performed")
                }
            }
        }
        Child::DynamicId {
            id_name,
            id_type,
            child_type,
            ..
        } => {
            // Generate parameterized method for type-safe access
            let method_name = id_name;
            let param_type = quote! { impl std::fmt::Display };
            let conversion =
                quote! { id.to_string().parse::<#id_type>().expect("Failed to parse ID") };

            quote! {
                /// Access a dynamic ID instance by reference.
                ///
                /// This method takes a reference to avoid consuming the parameter,
                /// allowing for better ergonomics and parameter reuse.
                pub fn #method_name(&self, id: #param_type) -> #child_type {
                    let id_value = #conversion;
                    #child_type::new(self.path.join(id_value.to_string()), id_value, self.parent_id.clone()).expect("Path validation already performed")
                }
            }
        }
    }
}

fn generate_children_method(
    children: &[Child],
    parent_has_dynamic_id: bool,
    current_is_dynamic_id: bool,
) -> Option<proc_macro2::TokenStream> {
    // Find all dynamic ID children to determine the return type and validate consistency
    let dynamic_children: Vec<_> = children
        .iter()
        .filter_map(|child| {
            if let Child::DynamicId {
                child_type,
                is_directory,
                id_type,
                ..
            } = child
            {
                Some((child_type, *is_directory, id_type))
            } else {
                None
            }
        })
        .collect();

    if dynamic_children.is_empty() {
        return None;
    }

    // Use the first dynamic ID child for the return type
    let (dynamic_child, is_directory, id_type) = &dynamic_children[0];

    // Validate that multiple dynamic ID children are not supported
    // The children() method can only return one type, so we cannot disambiguate
    // which type any given filesystem entry should be instantiated as
    assert!(
        dynamic_children.len() <= 1,
        "Multiple dynamic ID types in the same parent directory are not supported. \
         Found {} dynamic ID children. The children() method can only return a single type, \
         making it impossible to determine which type any filesystem entry should be. \
         Consider using separate subdirectories for different dynamic ID types.",
        dynamic_children.len()
    );

    // Generate the appropriate file type check based on whether it's a directory or file
    let file_type_check = if *is_directory {
        quote! { entry_path.is_dir() }
    } else {
        quote! { entry_path.is_file() }
    };

    // Generate the constructor call based on whether parent has dynamic ID or current is dynamic ID
    let constructor_call = if parent_has_dynamic_id {
        // Current struct has parent_id field, pass it to children
        quote! { #dynamic_child::new(entry_path, id, self.parent_id.clone()).map_err(std::io::Error::from) }
    } else if current_is_dynamic_id {
        // Current struct is dynamic ID type, pass its ID to children
        quote! { #dynamic_child::new(entry_path, id, self.id.clone()).map_err(std::io::Error::from) }
    } else {
        // Regular case, no parent ID needed
        quote! { #dynamic_child::new(entry_path, id).map_err(std::io::Error::from) }
    };

    Some(quote! {
        /// Iterate over dynamic ID children in this directory.
        ///
        /// Performs `read_dir()` on the filesystem and converts directory entries
        /// into correctly typed dynamic ID instances, returning them via an Iterator.
        pub fn children(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<#dynamic_child>>> {
            let path = self.path.clone();
            let read_dir = ::tree_type::fs::read_dir(&path)?;
            Ok(read_dir.filter_map(move |entry| {
                match entry {
                    Ok(entry) => {
                        let entry_path = entry.path();
                        if #file_type_check {
                            // Parse ID from filename for dynamic ID reconstruction
                            if let Some(filename) = entry_path.file_name() {
                                if let Some(id_str) = filename.to_str() {
                                    match id_str.parse::<#id_type>() {
                                        Ok(id) => Some(#constructor_call),
                                        Err(_) => None, // Skip entries that can't be parsed as the expected ID type
                                    }
                                } else {
                                    None // Skip non-UTF8 filenames
                                }
                            } else {
                                None // Skip entries without filenames
                            }
                        } else {
                            None
                        }
                    }
                    Err(e) => Some(Err(e))
                }
            }))
        }
    })
}

fn generate_parent_method(parent_type: Option<&Ident>) -> proc_macro2::TokenStream {
    match parent_type {
        Some(parent_type) => {
            // Type-safe parent method for non-root types
            quote! {
                /// Get the parent directory with type-safe return type.
                pub fn parent(&self) -> #parent_type {
                    let parent_path = self.path.parent().expect("Non-root type must have parent");
                    #parent_type::new(parent_path).expect("Parent path should be valid")
                }
            }
        }
        None => {
            // Root type returns Option<GenericDir>
            quote! {
                /// Get the parent directory as GenericDir.
                /// Returns None for root directories or if parent cannot be determined.
                pub fn parent(&self) -> Option<::tree_type::GenericDir> {
                    self.path.parent().and_then(|parent_path| {
                        ::tree_type::GenericDir::new(parent_path).ok()
                    })
                }
            }
        }
    }
}

fn get_child_type_name(
    parent_name: &Ident,
    child_name: &Ident,
    custom_type: Option<&Ident>,
) -> Ident {
    custom_type.cloned().unwrap_or_else(|| {
        Ident::new(
            &format!("{}{}", parent_name, capitalize(&child_name.to_string())),
            child_name.span(),
        )
    })
}

fn generate_create_default_method(default_val: &DefaultValue) -> proc_macro2::TokenStream {
    match default_val {
        DefaultValue::DefaultTrait => {
            quote! {
                pub fn create_default<E>(&self) -> std::result::Result<::tree_type::CreateDefaultOutcome, E>
                where
                    E: From<std::io::Error>,
                {
                    if self.exists() {
                        return Ok(tree_type::CreateDefaultOutcome::AlreadyExists);
                    }
                    self.write(&String::default())?;
                    Ok(tree_type::CreateDefaultOutcome::Created)
                }
            }
        }
        DefaultValue::Literal(lit) => {
            quote! {
                pub fn create_default<E>(&self) -> std::result::Result<::tree_type::CreateDefaultOutcome, E>
                where
                    E: From<std::io::Error>,
                {
                    if self.exists() {
                        return Ok(tree_type::CreateDefaultOutcome::AlreadyExists);
                    }
                    self.write(&#lit.to_string())?;
                    Ok(tree_type::CreateDefaultOutcome::Created)
                }
            }
        }
        DefaultValue::Function(expr) => {
            quote! {
                pub fn create_default<E>(&self) -> std::result::Result<::tree_type::CreateDefaultOutcome, E>
                where
                    E: From<std::io::Error>,
                {
                    if self.exists() {
                        return Ok(tree_type::CreateDefaultOutcome::AlreadyExists);
                    }
                    let content = (#expr)(self)?;
                    self.write(&content)?;
                    Ok(tree_type::CreateDefaultOutcome::Created)
                }
            }
        }
    }
}

fn generate_file_struct_with_dynamic_parent(
    name: &Ident,
    attributes: &[Attribute],
    parent_type: &Ident,
    parent_id_type: &syn::Type,
    parent_is_nested: bool,
) -> proc_macro2::TokenStream {
    // Find default attribute if present
    let default_method = attributes.iter().find_map(|attr| {
        if let Attribute::Default(val) = attr {
            Some(generate_create_default_method(val))
        } else {
            None
        }
    });

    let parent_method = if parent_is_nested {
        // Parent is nested inside another dynamic ID, needs 3 parameters
        quote! {
            /// Get the parent directory with type-safe return type.
            pub fn parent(&self) -> #parent_type {
                let parent_path = self.path.parent().expect("Non-root type must have parent");

                // Extract grandparent ID from path for nested dynamic IDs
                // Path structure: .../grandparent_id/parent_id/file
                let grandparent_path = parent_path.parent().expect("Parent should have a grandparent");
                let grandparent_id = grandparent_path.file_name()
                    .expect("Grandparent path should have a filename")
                    .to_string_lossy()
                    .to_string();

                #parent_type::new(parent_path, self.parent_id.clone(), grandparent_id).expect("Parent path should be valid")
            }
        }
    } else {
        // Parent is not nested, needs 2 parameters
        quote! {
            /// Get the parent directory with type-safe return type.
            pub fn parent(&self) -> #parent_type {
                let parent_path = self.path.parent().expect("Non-root type must have parent");
                #parent_type::new(parent_path, self.parent_id.clone()).expect("Parent path should be valid")
            }
        }
    };

    let serde_derives = get_serde_derives();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            parent_id: #parent_id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, parent_id: #parent_id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, parent_id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericFile {
                ::tree_type::GenericFile::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn read(&self) -> std::io::Result<Vec<u8>> {
                ::tree_type::fs::read(&self.path)
            }

            pub fn read_to_string(&self) -> std::io::Result<String> {
                ::tree_type::fs::read_to_string(&self.path)
            }

            pub fn write<C: AsRef<[u8]>>(&self, contents: C) -> std::io::Result<()> {
                if let Some(parent) = self.path.parent() {
                    ::tree_type::fs::create_dir_all(parent)?;
                }
                ::tree_type::fs::write(&self.path, contents)
            }

            pub fn file_name(&self) -> Option<std::ffi::OsString> {
                self.path.file_name().map(|name| name.to_os_string())
            }

            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            pub fn from_generic(file: ::tree_type::GenericFile, parent_id: #parent_id_type) -> Self {
                Self { path: file.as_path().to_path_buf(), parent_id }
            }

            #default_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl
        #debug_impl

        impl From<#name> for ::tree_type::GenericFile {
            fn from(file: #name) -> Self {
                Self::new(file.path).expect("Path validation already performed")
            }
        }
    }
}

#[expect(clippy::too_many_lines)]
fn generate_dir_struct_with_dynamic_parent(
    name: &Ident,
    children: &[Child],
    depth: usize,
    root_children: &[Child],
    parent_type: &Ident,
    parent_id_type: &syn::Type,
) -> proc_macro2::TokenStream {
    let nav_methods = children
        .iter()
        .map(|child| generate_nav_method_for_dynamic_parent_children(name, child));

    let children_method = generate_children_method(children, true, false);

    let parent_method = quote! {
        /// Get the parent directory with type-safe return type.
        pub fn parent(&self) -> #parent_type {
            let parent_path = self.path.parent().expect("Non-root type must have parent");
            #parent_type::new(parent_path, self.parent_id.clone()).expect("Parent path should be valid")
        }
    };

    let validate_impl = generate_validate_method_with_parent_info(children, true, false);
    let setup_impl = generate_setup_method(children, depth, root_children);
    let ensure_impl = generate_ensure_method(children);
    let sync_impl = generate_sync_method(children);

    let serde_derives = get_serde_derives();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            parent_id: #parent_id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, parent_id: #parent_id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, parent_id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericDir {
                ::tree_type::GenericDir::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn create(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir(&self.path)
            }

            pub fn create_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir_all(&self.path)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir(&self.path)
            }

            pub fn remove_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir_all(&self.path)
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            #[cfg(feature = "walk")]
            pub fn walk_dir(&self) -> ::tree_type::deps::walk::WalkDir {
                ::tree_type::deps::walk::WalkDir::new(&self.path)
            }

            #[cfg(feature = "walk")]
            pub fn walk(&self) -> impl Iterator<Item = std::io::Result<::tree_type::GenericPath>> {
                ::tree_type::deps::walk::WalkDir::new(&self.path)
                    .into_iter()
                    .map(|r| r.map_err(|e| e.into()).and_then(::tree_type::GenericPath::try_from))
            }

            #[cfg(feature = "walk")]
            pub fn size_in_bytes(&self) -> std::io::Result<u64> {
                let mut total = 0u64;
                for entry in ::tree_type::deps::walk::WalkDir::new(&self.path) {
                    let entry = entry?;
                    if entry.file_type().is_file() {
                        total += entry.metadata()?.len();
                    }
                }
                Ok(total)
            }

            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            pub fn rename(self, new_path: impl AsRef<std::path::Path>) -> Result<Self, (std::io::Error, Self)> {
                let new_path = new_path.as_ref();
                if let Some(parent) = new_path.parent() {
                    if !parent.exists() {
                        if let Err(e) = std::fs::create_dir_all(parent) {
                            return Err((e, self));
                        }
                    }
                }
                match ::tree_type::fs::rename(&self.path, new_path) {
                    Ok(()) => Self::new(new_path, self.parent_id.clone()).map_err(|e| (e, self)),
                    Err(e) => Err((e, self)),
                }
            }

            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            pub fn from_generic(dir: ::tree_type::GenericDir, parent_id: #parent_id_type) -> Self {
                Self { path: dir.as_path().to_path_buf(), parent_id }
            }

            #(#nav_methods)*

            #children_method

            #parent_method

            #validate_impl

            #setup_impl

            #ensure_impl

            #sync_impl
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericDir {
            fn from(dir: #name) -> Self {
                Self::new(dir.path).expect("Path validation already performed")
            }
        }
    }
}

fn generate_file_struct(
    name: &Ident,
    attributes: &[Attribute],
    parent_type: Option<&Ident>,
) -> proc_macro2::TokenStream {
    // Find default attribute if present
    let default_method = attributes.iter().find_map(|attr| {
        if let Attribute::Default(val) = attr {
            Some(generate_create_default_method(val))
        } else {
            None
        }
    });

    let parent_method = generate_parent_method(parent_type);

    let serde_derives = get_serde_derives();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericFile {
                ::tree_type::GenericFile::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn read(&self) -> std::io::Result<Vec<u8>> {
                ::tree_type::fs::read(&self.path)
            }

            pub fn read_to_string(&self) -> std::io::Result<String> {
                ::tree_type::fs::read_to_string(&self.path)
            }

            pub fn write<C: AsRef<[u8]>>(&self, contents: C) -> std::io::Result<()> {
                if let Some(parent) = self.path.parent() {
                    if !parent.exists() {
                        ::tree_type::fs::create_dir_all(parent)?;
                    }
                }
                ::tree_type::fs::write(&self.path, contents)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_file(&self.path)
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Returns the final component of the path as a String.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .expect("validated in new")
                    .to_string_lossy()
                    .to_string()
            }

            /// Set file permissions to 0o600 (read/write for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            pub fn from_generic(file: ::tree_type::GenericFile) -> Self {
                Self { path: file.as_path().to_path_buf() }
            }

            #default_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericFile {
            fn from(file: #name) -> Self {
                Self::new(file.path).expect("Path validation already performed")
            }
        }
    }
}

fn generate_dir_struct(
    name: &Ident,
    children: &[Child],
    depth: usize,
    root_children: &[Child],
    parent_type: Option<&Ident>,
) -> proc_macro2::TokenStream {
    let nav_methods = children
        .iter()
        .map(|child| generate_nav_method(name, child));

    let children_method = generate_children_method(children, false, false);
    let parent_method = generate_parent_method(parent_type);

    let validate_impl = generate_validate_method(children);
    let setup_impl = generate_setup_method(children, depth, root_children);
    let ensure_impl = generate_ensure_method(children);
    let sync_impl = generate_sync_method(children);

    let serde_derives = get_serde_derives();
    let walk_fns = build_walk_fns();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericDir {
                ::tree_type::GenericDir::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn create(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir(&self.path)
            }

            pub fn create_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir_all(&self.path)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir(&self.path)
            }

            pub fn remove_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir_all(&self.path)
            }

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.path)
                    .map(|read_dir| read_dir.map(|result| result.and_then(::tree_type::GenericPath::try_from)))
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Set directory permissions to 0o700 (read/write/execute for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            #walk_fns

            #validate_impl
            #setup_impl
            #ensure_impl
            #sync_impl

            /// Returns the final component of the path as a String.
            /// For root paths like "/", returns an empty string.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            pub fn from_generic(dir: ::tree_type::GenericDir) -> Self {
                Self { path: dir.as_path().to_path_buf() }
            }

            #(#nav_methods)*

            #children_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericDir {
            fn from(dir: #name) -> Self {
                Self::new(dir.path).expect("Path validation already performed")
            }
        }
    }
}

fn capitalize(s: &str) -> String {
    // Convert snake_case to PascalCase
    s.split('_')
        .filter(|part| !part.is_empty())
        .map(|part| {
            let mut chars = part.chars();
            match chars.next() {
                None => String::new(),
                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
            }
        })
        .collect()
}

fn generate_validate_method(children: &[Child]) -> proc_macro2::TokenStream {
    generate_validate_method_with_parent_info(children, false, false)
}

fn generate_validate_method_with_parent_info(
    children: &[Child],
    parent_has_dynamic_id: bool,
    current_is_dynamic_id: bool,
) -> proc_macro2::TokenStream {
    let validations = children.iter().map(|child| {
        generate_child_validate_method_with_parent_info(
            parent_has_dynamic_id,
            current_is_dynamic_id,
            child,
        )
    });

    // Add recursive validation for child directories
    let recursive_validations = children.iter().filter_map(|child| match child {
        Child::Directory { name, .. } => Some(quote! {
            if self.#name().exists() {
                #[expect(deprecated)]
                let child_report = self.#name().validate();
                report.merge(child_report);
            }
        }),
        _ => None,
    });

    quote! {
        #[allow(clippy::regex_creation_in_loops)]
        #[deprecated(since = "0.2.0", note = "Use `sync()` instead. This method will be removed in v0.6.0")]
        #[expect(deprecated)]
        pub fn validate(&self) -> ::tree_type::ValidationReport {
            let mut report = ::tree_type::ValidationReport::new();

            // Validate root directory exists
            if !self.exists() {
                report.errors.push(tree_type::ValidationError {
                    path: self.path.clone(),
                    message: "Directory does not exist".to_string(),
                });
            }

            #(#validations)*
            #(#recursive_validations)*

            report
        }
    }
}

fn generate_child_validate_method_with_parent_info(
    parent_has_dynamic_id: bool,
    current_is_dynamic_id: bool,
    child: &Child,
) -> proc_macro2::TokenStream {
    if let Child::DynamicId {
        child_type,
        attributes,
        is_directory,
        id_type,
        ..
    } = child
    {
        generate_child_dynamic_id_validate_method_with_parent_info(
            parent_has_dynamic_id,
            current_is_dynamic_id,
            child_type,
            attributes,
            *is_directory,
            id_type,
        )
    } else {
        let name = child.name();

        // Check for pattern validation
        let pattern = child.attributes().iter().find_map(|attr| {
            if let Attribute::Pattern(lit) = attr {
                Some(lit)
            } else {
                None
            }
        });

        // Check for custom validator
        let custom_validator = child.attributes().iter().find_map(|attr| {
            if let Attribute::Validate(expr) = attr {
                Some(expr)
            } else {
                None
            }
        });

        if let Some(pattern_lit) = pattern {
            // Pattern validation
            quote! {
                {
                    if self.#name().exists() {
                        match self.#name().read_to_string() {
                            Ok(content) => {
                                match ::tree_type::deps::pattern_validation::Regex::new(#pattern_lit) {
                                    Ok(re) => {
                                        if !re.is_match(&content) {
                                            report.errors.push(tree_type::ValidationError {
                                                path: self.#name().as_path().to_path_buf(),
                                                message: format!("File content does not match pattern: {}", #pattern_lit),
                                            });
                                        }
                                    }
                                    Err(e) => {
                                        report.errors.push(tree_type::ValidationError {
                                            path: self.#name().as_path().to_path_buf(),
                                            message: format!("Invalid regex pattern: {}", e),
                                        });
                                    }
                                }
                            }
                            Err(e) => {
                                report.errors.push(tree_type::ValidationError {
                                    path: self.#name().as_path().to_path_buf(),
                                    message: format!("Failed to read file: {}", e),
                                });
                            }
                        }
                    }
                }
            }
        } else if let Some(validator) = custom_validator {
            // Call custom validation function
            quote! {
                let result = (#validator)(&self.#name());
                for error in result.errors {
                    report.errors.push(tree_type::ValidationError {
                        path: self.#name().as_path().to_path_buf(),
                        message: error,
                    });
                }
                for warning in result.warnings {
                    report.warnings.push(tree_type::ValidationWarning {
                        path: self.#name().as_path().to_path_buf(),
                        message: warning,
                    });
                }
            }
        } else if child.is_required() {
            // Standard required validation
            quote! {
                if !self.#name().exists() {
                    report.errors.push(tree_type::ValidationError {
                        path: self.#name().as_path().to_path_buf(),
                        message: "Required path does not exist".to_string(),
                    });
                }
            }
        } else {
            quote! {}
        }
    }
}

fn generate_child_dynamic_id_validate_method_with_parent_info(
    parent_has_dynamic_id: bool,
    current_is_dynamic_id: bool,
    child_type: &Ident,
    attributes: &[Attribute],
    is_directory: bool,
    id_type: &syn::Type,
) -> proc_macro2::TokenStream {
    // Check for pattern validation
    let pattern = attributes.iter().find_map(|attr| {
        if let Attribute::Pattern(lit) = attr {
            Some(lit)
        } else {
            None
        }
    });

    // Check for custom validator
    let custom_validator = attributes.iter().find_map(|attr| {
        if let Attribute::Validate(expr) = attr {
            Some(expr)
        } else {
            None
        }
    });

    // Generate validation for dynamic IDs - always recurse into instances

    // Generate the constructor call based on parent type information
    let constructor_call = if parent_has_dynamic_id {
        quote! { #child_type::new(entry_path.clone(), id, self.parent_id.clone()).expect("Path validation already performed") }
    } else if current_is_dynamic_id {
        quote! { #child_type::new(entry_path.clone(), id, self.id.clone()).expect("Path validation already performed") }
    } else {
        quote! { #child_type::new(entry_path.clone(), id).expect("Path validation already performed") }
    };

    let pattern_validation =
        pattern.map(generate_child_dynamic_id_pattern_validate_method_with_parent_info);

    let validator_call = custom_validator
        .map(generate_child_dynamic_id_custom_validator_validate_method_with_parent_info);

    let recursive_validation = if is_directory {
        quote! {
            #[expect(deprecated)]
            let child_report = child_instance.validate();
            report.merge(child_report);
        }
    } else {
        quote! {
            // File types don't have validate() method
        }
    };

    quote! {
        // Validate dynamic ID instances in current directory
        if self.exists() {
            let read_result = ::tree_type::fs::read_dir(&self.path);

            match read_result {
                Ok(entries) => {
                    for entry in entries {
                        match entry {
                            Ok(entry) => {
                                let entry_path = entry.path();

                                // Check if entry matches expected type (file or directory)
                                let is_expected_type = if #is_directory {
                                    entry_path.is_dir()
                                } else {
                                    entry_path.is_file()
                                };

                                if !is_expected_type {
                                    continue;
                                }

                                #pattern_validation

                                // Parse ID from filename and create child instance for validation
                                if let Some(filename) = entry_path.file_name() {
                                    if let Some(id_str) = filename.to_str() {
                                        match id_str.parse::<#id_type>() {
                                            Ok(id) => {
                                                let child_instance = #constructor_call;

                                                #validator_call

                                                // Only recursively validate if it's a directory
                                                #recursive_validation
                                            }
                                            Err(_) => {
                                                // Skip entries that can't be parsed as the expected ID type
                                                continue;
                                            }
                                        }
                                    }
                                }
                            }
                            Err(e) => {
                                report.errors.push(tree_type::ValidationError {
                                    path: self.path.clone(),
                                    message: format!("Failed to read directory entry: {}", e),
                                });
                            }
                        }
                    }
                }
                Err(e) => {
                    report.errors.push(tree_type::ValidationError {
                        path: self.path.clone(),
                        message: format!("Failed to read directory: {}", e),
                    });
                }
            }
        }
    }
}

fn generate_child_dynamic_id_custom_validator_validate_method_with_parent_info(
    _validator: &syn::Expr,
) -> proc_macro2::TokenStream {
    quote! {
        let result = (#_validator)(&child_instance);
        for error in result.errors {
            report.errors.push(tree_type::ValidationError {
                path: entry_path.clone(),
                message: error,
            });
        }
        for warning in result.warnings {
            report.warnings.push(tree_type::ValidationWarning {
                path: entry_path.clone(),
                message: warning,
            });
        }
    }
}

fn generate_child_dynamic_id_pattern_validate_method_with_parent_info(
    pattern_lit: &syn::LitStr,
) -> proc_macro2::TokenStream {
    quote! {
        {
            let dir_name = entry.file_name();
            let name_str = dir_name.to_string_lossy();
            match ::tree_type::deps::pattern_validation::Regex::new(#pattern_lit) {
                Ok(re) => {
                    if !re.is_match(&name_str) {
                        report.errors.push(tree_type::ValidationError {
                            path: entry_path.clone(),
                            message: format!("Directory name '{}' does not match pattern: {}", name_str, #pattern_lit),
                        });
                        continue;
                    }
                }
                Err(e) => {
                    report.errors.push(tree_type::ValidationError {
                        path: entry_path.clone(),
                        message: format!("Invalid regex pattern: {}", e),
                    });
                    continue;
                }
            }
        }
    }
}

#[expect(clippy::too_many_lines)]
fn generate_setup_method(
    children: &[Child],
    depth: usize,
    root_children: &[Child],
) -> proc_macro2::TokenStream {
    let setups = children.iter().filter_map(|child| {
        let name = child.name();

        // Check for symlink attribute
        if let Some(target_path) = child.get_symlink_target() {
            let target_str = target_path.value();

            // Check if this is a same-directory symlink (identifier-based, no path separators)
            if !target_str.contains('/') {
                // Same-directory symlink: use self.target().as_path()
                let target_ident = syn::Ident::new(&target_str, target_path.span());
                return Some(quote! {
                    if !self.#name().as_path().exists() {
                        // Use relative filename for symlink target
                        let target_filename = self.#target_ident().as_path().file_name().unwrap().to_string_lossy().to_string();

                        #[cfg(unix)]
                        if let Err(e) = std::os::unix::fs::symlink(&target_filename, self.#name().as_path()) {
                            errors.push(tree_type::BuildError::File(
                                self.#name().as_path().to_path_buf(),
                                Box::new(e)
                            ));
                        }
                        #[cfg(windows)]
                        {
                            let result = if self.#target_ident().as_path().is_dir() {
                                std::os::windows::fs::symlink_dir(&target_filename, self.#name().as_path())
                            } else {
                                std::os::windows::fs::symlink_file(&target_filename, self.#name().as_path())
                            };
                            if let Err(e) = result {
                                errors.push(tree_type::BuildError::File(
                                    self.#name().as_path().to_path_buf(),
                                    Box::new(e)
                                ));
                            }
                        }
                    }
                });
            }
            // Cross-directory symlink: resolve identities in path
            let up_dirs_str = "../".repeat(depth);

            // Try to resolve identities in the target path
            if let Some(resolved_code) = resolve_symlink_target_path(&target_str, root_children, &up_dirs_str, depth) {
                return Some(quote! {
                    if !self.#name().as_path().exists() {
                        let relative_target = #resolved_code;

                        #[cfg(unix)]
                        if let Err(e) = std::os::unix::fs::symlink(&relative_target, self.#name().as_path()) {
                            errors.push(tree_type::BuildError::File(
                                self.#name().as_path().to_path_buf(),
                                Box::new(e)
                            ));
                        }
                        #[cfg(windows)]
                        {
                            let result = std::os::windows::fs::symlink_file(&relative_target, self.#name().as_path());
                            if let Err(e) = result {
                                errors.push(tree_type::BuildError::File(
                                    self.#name().as_path().to_path_buf(),
                                    Box::new(e)
                                ));
                            }
                        }
                    }
                });
            }
            // Fallback to original behavior for paths that can't be resolved
            return Some(quote! {
                if !self.#name().as_path().exists() {
                    let target_str = #target_str;

                    let relative_target = if let Some(path_without_slash) = target_str.strip_prefix('/') {
                        // Absolute path (like "/config/main") - convert to relative
                        let up_dirs = #up_dirs_str;
                        format!("{}{}", up_dirs, path_without_slash)
                    } else if target_str.contains('.') {
                        // File path (like "config/config.toml") - needs relative path calculation
                        let up_dirs = #up_dirs_str;
                        format!("{}{}", up_dirs, target_str)
                    } else {
                        // Identity path - use as-is
                        let up_dirs = #up_dirs_str;
                        format!("{}{}", up_dirs, target_str)
                    };

                    #[cfg(unix)]
                    if let Err(e) = std::os::unix::fs::symlink(&relative_target, self.#name().as_path()) {
                        errors.push(tree_type::BuildError::File(
                            self.#name().as_path().to_path_buf(),
                            Box::new(e)
                        ));
                    }
                    #[cfg(windows)]
                    {
                        let result = std::os::windows::fs::symlink_file(&relative_target, self.#name().as_path());
                        if let Err(e) = result {
                            errors.push(tree_type::BuildError::File(
                                self.#name().as_path().to_path_buf(),
                                Box::new(e)
                            ));
                        }
                    }
                }
            });
        }

        match child {
            Child::Directory { .. } => {
                // Recursively call setup() on child directories (matches legacy behavior)
                Some(quote! {
                    #[expect(deprecated)]
                    if let Err(child_errors) = self.#name().setup() {
                        errors.extend(child_errors);
                    }
                })
            }
            Child::File { attributes, .. } => {
                // Find default attribute if present
                let has_default = attributes.iter().any(|attr| matches!(attr, Attribute::Default(_)));

                if has_default {
                    Some(quote! {
                        if let Err(e) = self.#name().create_default::<std::io::Error>() {
                            errors.push(tree_type::BuildError::File(
                                self.#name().as_path().to_path_buf(),
                                Box::new(e)
                            ));
                        }
                    })
                } else {
                    None
                }
            }
            Child::DynamicId { .. } => None
        }
    });

    // Generate identity symlinks for files with different actual filenames
    let identity_symlinks = children.iter().filter_map(|child| {
        match child {
            Child::File { name, custom_filename, attributes, .. } => {
                // Skip files that have symlink attributes - they handle their own symlinks
                let has_symlink = attributes.iter().any(|attr| matches!(attr, Attribute::Symlink(_)));
                if has_symlink {
                    return None;
                }

                if let Some(filename_lit) = custom_filename {
                    let filename_str = filename_lit.value();
                    let identity_name = name.to_string();

                    // Only create identity symlink if identity name differs from actual filename
                    if identity_name != filename_str {
                        return Some(quote! {
                            // Create identity symlink: identity_name -> actual_filename
                            let identity_path = self.as_path().join(#identity_name);
                            if !identity_path.exists() {
                                #[cfg(unix)]
                                if let Err(e) = std::os::unix::fs::symlink(#filename_str, &identity_path) {
                                    errors.push(tree_type::BuildError::File(
                                        identity_path,
                                        Box::new(e)
                                    ));
                                }
                                #[cfg(windows)]
                                {
                                    let result = std::os::windows::fs::symlink_file(#filename_str, &identity_path);
                                    if let Err(e) = result {
                                        errors.push(tree_type::BuildError::File(
                                            identity_path,
                                            Box::new(e)
                                        ));
                                    }
                                }
                            }
                        });
                    }
                }
                None
            }
            _ => None
        }
    });

    quote! {
        #[deprecated(since = "0.2.0", note = "Use `sync()` instead. This method will be removed in v0.6.0")]
        #[expect(deprecated)]
        pub fn setup(&self) -> std::result::Result<Vec<::tree_type::BuildError>, Vec<::tree_type::BuildError>> {
            let mut errors = Vec::new();

            if !self.path.exists() {
                let create_result = ::tree_type::fs::create_dir_all(&self.path);

                if let Err(e) = create_result {
                    errors.push(tree_type::BuildError::Directory(
                        self.path.clone(),
                        e
                    ));
                    return Err(errors);
                }
            }

            #(#setups)*

            // Create identity symlinks for files
            #(#identity_symlinks)*

            if errors.is_empty() {
                Ok(Vec::new())
            } else {
                Err(errors)
            }
        }
    }
}

fn generate_ensure_method(_children: &[Child]) -> proc_macro2::TokenStream {
    quote! {
        #[deprecated(since = "0.2.0", note = "Use `sync()` instead. This method will be removed in v0.6.0")]
        #[expect(deprecated)]
        pub fn ensure(&self) -> std::result::Result<::tree_type::ValidationReport, Vec<::tree_type::BuildError>> {
            self.setup()?;
            Ok(self.validate())
        }
    }
}

fn generate_sync_method(_children: &[Child]) -> proc_macro2::TokenStream {
    quote! {
        /// Synchronizes the directory structure based on macro attributes.
        ///
        /// This method provides a unified interface for structure management by
        /// delegating to the existing setup() and validate() methods.
        ///
        /// Returns a validation report with any issues found.
        #[expect(deprecated)]
        pub fn sync(&self) -> std::result::Result<::tree_type::ValidationReport, Vec<::tree_type::BuildError>> {
            self.setup()?;
            Ok(self.validate())
        }
    }
}

/// Generates a `std::fmt::Display` implementation for a generated type.
///
/// The Display implementation outputs the path as a clean string using `Path::display()`,
/// matching the behavior of `std::path::Path` for consistent user experience.
fn generate_display_impl(name: &syn::Ident) -> proc_macro2::TokenStream {
    quote! {
        impl std::fmt::Display for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{}", self.path.display())
            }
        }
    }
}

/// Generates a `std::fmt::Debug` implementation for a generated type.
///
/// The Debug implementation outputs the type name followed by the path in parentheses,
/// providing type information for debugging while showing the underlying path.
fn generate_debug_impl(name: &syn::Ident) -> proc_macro2::TokenStream {
    quote! {
        impl std::fmt::Debug for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{}({})", stringify!(#name), self.path.display())
            }
        }
    }
}

fn generate_dynamic_file_struct(
    name: &Ident,
    attributes: &[Attribute],
    parent_type: Option<&Ident>,
    id_name: &Ident,
    id_type: &syn::Type,
) -> proc_macro2::TokenStream {
    // Find default attribute if present
    let default_method = attributes.iter().find_map(|attr| {
        if let Attribute::Default(val) = attr {
            Some(generate_create_default_method(val))
        } else {
            None
        }
    });

    let parent_method = generate_parent_method(parent_type);

    let serde_derives = get_serde_derives();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    // Generate ID getter method
    let id_getter = quote! {
        pub fn #id_name(&self) -> &#id_type {
            &self.id
        }
    };

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            id: #id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, id: #id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericFile {
                ::tree_type::GenericFile::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn read(&self) -> std::io::Result<Vec<u8>> {
                ::tree_type::fs::read(&self.path)
            }

            pub fn read_to_string(&self) -> std::io::Result<String> {
                ::tree_type::fs::read_to_string(&self.path)
            }

            pub fn write<C: AsRef<[u8]>>(&self, contents: C) -> std::io::Result<()> {
                if let Some(parent) = self.path.parent() {
                    if !parent.exists() {
                        ::tree_type::fs::create_dir_all(parent)?;
                    }
                }
                ::tree_type::fs::write(&self.path, contents)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_file(&self.path)
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Returns the final component of the path as a String.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .expect("validated in new")
                    .to_string_lossy()
                    .to_string()
            }

            /// Set file permissions to 0o600 (read/write for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            pub fn from_generic(file: ::tree_type::GenericFile, id: #id_type) -> Self {
                Self { path: file.as_path().to_path_buf(), id }
            }

            #id_getter

            #default_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericFile {
            fn from(file: #name) -> Self {
                Self::new(file.path).expect("Path validation already performed")
            }
        }
    }
}

fn generate_dynamic_file_struct_with_dynamic_parent(
    name: &Ident,
    attributes: &[Attribute],
    parent_type: &Ident,
    id_name: &Ident,
    id_type: &syn::Type,
    parent_id_type: &syn::Type,
    parent_is_nested: bool,
) -> proc_macro2::TokenStream {
    // Find default attribute if present
    let default_method = attributes.iter().find_map(|attr| {
        if let Attribute::Default(val) = attr {
            Some(generate_create_default_method(val))
        } else {
            None
        }
    });

    let serde_derives = get_serde_derives();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    // Generate ID getter method
    let id_getter = quote! {
        pub fn #id_name(&self) -> &#id_type {
            &self.id
        }
    };

    // Generate parent method that reconstructs the parent with its ID
    let parent_method = if parent_is_nested {
        generate_dynamic_file_with_nested_parent_struct_with_dynamic_parent(parent_type)
    } else {
        generate_dynamic_file_with_non_nested_parent_struct_with_dynamic_parent(parent_type)
    };

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            id: #id_type,
            parent_id: #parent_id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, id: #id_type, parent_id: #parent_id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, id, parent_id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericFile {
                ::tree_type::GenericFile::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn read(&self) -> std::io::Result<Vec<u8>> {
                ::tree_type::fs::read(&self.path)
            }

            pub fn read_to_string(&self) -> std::io::Result<String> {
                ::tree_type::fs::read_to_string(&self.path)
            }

            pub fn write<C: AsRef<[u8]>>(&self, contents: C) -> std::io::Result<()> {
                if let Some(parent) = self.path.parent() {
                    if !parent.exists() {
                        ::tree_type::fs::create_dir_all(parent)?;
                    }
                }
                ::tree_type::fs::write(&self.path, contents)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_file(&self.path)
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Returns the final component of the path as a String.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .expect("validated in new")
                    .to_string_lossy()
                    .to_string()
            }

            /// Set file permissions to 0o600 (read/write for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            pub fn from_generic(file: ::tree_type::GenericFile, id: #id_type, parent_id: #parent_id_type) -> Self {
                Self { path: file.as_path().to_path_buf(), id, parent_id }
            }

            #id_getter

            #default_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericFile {
            fn from(file: #name) -> Self {
                Self::new(file.path).expect("Path validation already performed")
            }
        }
    }
}

fn generate_dynamic_file_with_non_nested_parent_struct_with_dynamic_parent(
    parent_type: &Ident,
) -> proc_macro2::TokenStream {
    // Parent is not nested, needs 2 parameters
    quote! {
        /// Get the parent directory with type-safe return type.
        pub fn parent(&self) -> #parent_type {
            let parent_path = self.path.parent().expect("Path should have a parent");
            #parent_type::new(parent_path, self.parent_id.clone()).expect("Path validation already performed")
        }
    }
}

fn generate_dynamic_file_with_nested_parent_struct_with_dynamic_parent(
    parent_type: &Ident,
) -> proc_macro2::TokenStream {
    // Parent is nested inside another dynamic ID, needs 3 parameters
    quote! {
        /// Get the parent directory with type-safe return type.
        pub fn parent(&self) -> #parent_type {
            let parent_path = self.path.parent().expect("Path should have a parent");

            // Extract grandparent ID from path for nested dynamic IDs
            // Path structure: .../grandparent_id/parent_id/file
            let grandparent_path = parent_path.parent().expect("Parent should have a grandparent");
            let grandparent_id = grandparent_path.file_name()
                .expect("Grandparent path should have a filename")
                .to_string_lossy()
                .to_string();

            #parent_type::new(parent_path, self.parent_id.clone(), grandparent_id).expect("Path validation already performed")
        }
    }
}

fn generate_dynamic_dir_struct(
    name: &Ident,
    children: &[Child],
    depth: usize,
    root_children: &[Child],
    parent_type: Option<&Ident>,
    id_name: &Ident,
    id_type: &syn::Type,
) -> proc_macro2::TokenStream {
    let nav_methods = children
        .iter()
        .map(|child| generate_nav_method_for_dynamic_id_parent(name, child, id_name));

    let children_method = generate_children_method(children, false, true);
    let parent_method = generate_parent_method(parent_type);

    let validate_impl = generate_validate_method_with_parent_info(children, false, true);
    let setup_impl = generate_setup_method(children, depth, root_children);
    let ensure_impl = generate_ensure_method(children);
    let sync_impl = generate_sync_method(children);

    let serde_derives = get_serde_derives();
    let walk_fns = build_walk_fns();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    // Generate ID getter method
    let id_getter = quote! {
        pub fn #id_name(&self) -> &#id_type {
            &self.id
        }
    };

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            id: #id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, id: #id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericDir {
                ::tree_type::GenericDir::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn create(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir(&self.path)
            }

            pub fn create_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir_all(&self.path)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir(&self.path)
            }

            pub fn remove_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir_all(&self.path)
            }

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.path)
                    .map(|read_dir| read_dir.map(|result| result.and_then(::tree_type::GenericPath::try_from)))
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Set directory permissions to 0o700 (read/write/execute for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            #walk_fns

            #validate_impl
            #setup_impl
            #ensure_impl
            #sync_impl

            /// Returns the final component of the path as a String.
            /// For root paths like "/", returns an empty string.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            pub fn from_generic(dir: ::tree_type::GenericDir, id: #id_type) -> Self {
                Self { path: dir.as_path().to_path_buf(), id }
            }

            #id_getter

            #(#nav_methods)*

            #children_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericDir {
            fn from(dir: #name) -> Self {
                Self::new(dir.path).expect("Path validation already performed")
            }
        }
    }
}
#[allow(clippy::too_many_arguments)]
fn generate_dynamic_dir_struct_with_dynamic_parent(
    name: &Ident,
    children: &[Child],
    depth: usize,
    root_children: &[Child],
    parent_type: &Ident,
    id_name: &Ident,
    id_type: &syn::Type,
    parent_id_type: &syn::Type,
    parent_is_nested: bool,
) -> proc_macro2::TokenStream {
    let nav_methods = children
        .iter()
        .map(|child| generate_nav_method_for_dynamic_id_parent(name, child, id_name));

    let children_method = generate_children_method(children, false, true);

    let validate_impl = generate_validate_method_with_parent_info(children, false, true);
    let setup_impl = generate_setup_method(children, depth, root_children);
    let ensure_impl = generate_ensure_method(children);
    let sync_impl = generate_sync_method(children);

    let serde_derives = get_serde_derives();
    let walk_fns = build_walk_fns();

    let display_impl = generate_display_impl(name);
    let debug_impl = generate_debug_impl(name);

    let id_getter = generate_id_getter_method(id_name, id_type);

    // Generate parent method that reconstructs the parent with its ID
    let parent_method =
        generate_dynamic_dir_parent_struct_with_dynamic_parent(parent_type, parent_is_nested);

    quote! {
        #serde_derives
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #name {
            path: std::path::PathBuf,
            id: #id_type,
            parent_id: #parent_id_type,
        }

        impl #name {
            pub fn new(path: impl Into<std::path::PathBuf>, id: #id_type, parent_id: #parent_id_type) -> std::io::Result<Self> {
                let path_buf = path.into();
                // For directories, allow root paths and paths with filename components
                // Only reject empty paths or invalid paths like ".."
                if path_buf.as_os_str().is_empty() {
                    return Err(std::io::Error::from(std::io::ErrorKind::InvalidFilename));
                }
                Ok(Self { path: path_buf, id, parent_id })
            }

            pub fn as_path(&self) -> &std::path::Path {
                &self.path
            }

            pub fn exists(&self) -> bool {
                self.path.exists()
            }

            pub fn as_generic(&self) -> ::tree_type::GenericDir {
                ::tree_type::GenericDir::new(self.path.clone()).expect("Path validation already performed")
            }

            pub fn create(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir(&self.path)
            }

            pub fn create_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::create_dir_all(&self.path)
            }

            pub fn remove(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir(&self.path)
            }

            pub fn remove_all(&self) -> std::io::Result<()> {
                ::tree_type::fs::remove_dir_all(&self.path)
            }

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.path)
                    .map(|read_dir| read_dir.map(|result| result.and_then(::tree_type::GenericPath::try_from)))
            }

            pub fn fs_metadata(&self) -> std::io::Result<::tree_type::fs::Metadata> {
                ::tree_type::fs::metadata(&self.path)
            }

            /// Set directory permissions to 0o700 (read/write/execute for owner only).
            ///
            /// This method is only available on Unix systems.
            #[cfg(unix)]
            pub fn secure(&self) -> std::io::Result<()> {
                self.as_generic().secure()
            }

            #walk_fns

            #validate_impl
            #setup_impl
            #ensure_impl
            #sync_impl

            /// Returns the final component of the path as a String.
            /// For root paths like "/", returns an empty string.
            /// See [`std::path::Path::file_name`] for more details.
            pub fn file_name(&self) -> String {
                self.path.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            pub fn from_generic(dir: ::tree_type::GenericDir, id: #id_type, parent_id: #parent_id_type) -> Self {
                Self { path: dir.as_path().to_path_buf(), id, parent_id }
            }

            #id_getter

            #(#nav_methods)*

            #children_method

            #parent_method
        }

        impl AsRef<std::path::Path> for #name {
            fn as_ref(&self) -> &std::path::Path {
                &self.path
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericDir {
            fn from(dir: #name) -> Self {
                Self::new(dir.path).expect("Path validation already performed")
            }
        }
    }
}

fn generate_dynamic_dir_parent_struct_with_dynamic_parent(
    parent_type: &Ident,
    parent_is_nested: bool,
) -> proc_macro2::TokenStream {
    if parent_is_nested {
        generate_dynamic_dir_with_nested_parent_struct_with_dynamic_parent(parent_type)
    } else {
        generate_dynamic_dir_with_non_nested_parent_struct_with_dynamic_parent(parent_type)
    }
}

fn generate_id_getter_method(id_name: &Ident, id_type: &syn::Type) -> proc_macro2::TokenStream {
    quote! {
        pub fn #id_name(&self) -> &#id_type {
            &self.id
        }
    }
}

fn generate_dynamic_dir_with_non_nested_parent_struct_with_dynamic_parent(
    parent_type: &Ident,
) -> proc_macro2::TokenStream {
    // Parent is not nested, needs 2 parameters
    quote! {
        /// Get the parent directory with type-safe return type.
        pub fn parent(&self) -> #parent_type {
            let parent_path = self.path.parent().expect("Path should have a parent");
            #parent_type::new(parent_path, self.parent_id.clone()).expect("Path validation already performed")
        }
    }
}

fn generate_dynamic_dir_with_nested_parent_struct_with_dynamic_parent(
    parent_type: &Ident,
) -> proc_macro2::TokenStream {
    // Parent is nested inside another dynamic ID, needs 3 parameters
    quote! {
        /// Get the parent directory with type-safe return type.
        pub fn parent(&self) -> #parent_type {
            let parent_path = self.path.parent().expect("Path should have a parent");

            // Extract grandparent ID from path for nested dynamic IDs
            // Path structure: .../grandparent_id/parent_id/child_id
            let grandparent_path = parent_path.parent().expect("Parent should have a grandparent");
            let grandparent_id = grandparent_path.file_name()
                .expect("Grandparent path should have a filename")
                .to_string_lossy()
                .to_string();

            #parent_type::new(parent_path, self.parent_id.clone(), grandparent_id).expect("Path validation already performed")
        }
    }
}

// New generic approach for generating child structs with path-based dynamic ID collection
#[allow(dead_code)]
fn generate_child_structs_with_path(
    parent_name: &Ident,
    children: &[Child],
    structs: &mut Vec<proc_macro2::TokenStream>,
    root_children: &[Child],
) {
    for child in children {
        match child {
            Child::File {
                name,
                custom_type,
                attributes,
                ..
            } => {
                let struct_name = get_child_type_name(parent_name, name, custom_type.as_ref());

                // Collect dynamic ancestors for this file type
                let mut path = Vec::new();
                let mut result = None;
                collect_dynamic_ancestors(
                    root_children,
                    &struct_name.to_string(),
                    &mut path,
                    &mut result,
                );
                let ancestors = result.unwrap_or_default();

                // Generate using generic approach
                structs.push(generate_file_struct_generic(
                    &struct_name,
                    attributes,
                    parent_name,
                    &ancestors,
                ));
            }
            Child::Directory {
                name,
                custom_type,
                children,
                ..
            } => {
                let struct_name = get_child_type_name(parent_name, name, custom_type.as_ref());

                // For now, just generate a basic directory struct
                structs.push(quote! {
                    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
                    pub struct #struct_name {
                        path: std::path::PathBuf,
                    }

                    impl #struct_name {
                        pub fn new(path: impl Into<std::path::PathBuf>) -> std::io::Result<Self> {
                            Ok(Self { path: path.into() })
                        }
                    }
                });

                // Recurse into children
                generate_child_structs_with_path(&struct_name, children, structs, root_children);
            }
            Child::DynamicId {
                child_type,
                children,
                ..
            } => {
                // Recurse into dynamic ID children
                generate_child_structs_with_path(child_type, children, structs, root_children);
            }
        }
    }
}

// Generic file struct generation using collected dynamic ancestor info
fn generate_file_struct_generic(
    struct_name: &Ident,
    #[expect(unused)] attributes: &[Attribute],
    parent_name: &Ident,
    ancestors: &[DynamicIdInfo],
) -> proc_macro2::TokenStream {
    #[expect(unused)]
    let parent_name_lower = parent_name.to_string().to_lowercase();

    // Generate constructor parameters based on ancestor depth
    let constructor_params = match ancestors.len() {
        0 => quote! { path: impl Into<std::path::PathBuf>, parent_id: impl std::fmt::Display },
        1 => quote! {
            path: impl Into<std::path::PathBuf>,
            parent_id: impl std::fmt::Display,
            grandparent_id: impl std::fmt::Display
        },
        _ => {
            let mut params = vec![
                quote! { path: impl Into<std::path::PathBuf> },
                quote! { parent_id: impl std::fmt::Display },
            ];
            for i in 0..ancestors.len() {
                let param_name = format_ident!("ancestor_{}", i);
                params.push(quote! { #param_name: impl std::fmt::Display });
            }
            quote! { #(#params),* }
        }
    };

    // Generate constructor body
    let constructor_body = quote! {
        let path = path.into();
        Ok(Self { path })
    };

    // Generate navigation method to parent
    let parent_method = generate_nav_method_generic(parent_name, ancestors);

    quote! {
        #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
        pub struct #struct_name {
            path: std::path::PathBuf,
        }

        impl #struct_name {
            pub fn new(#constructor_params) -> std::io::Result<Self> {
                #constructor_body
            }

            #parent_method
        }
    }
}

// Generic navigation method generation
fn generate_nav_method_generic(
    parent_name: &Ident,
    ancestors: &[DynamicIdInfo],
) -> proc_macro2::TokenStream {
    let parent_name_lower = parent_name.to_string().to_lowercase();
    let method_name = format_ident!("{}", parent_name_lower);

    // Generate constructor call based on ancestor depth
    let constructor_call = match ancestors.len() {
        0 => quote! { #parent_name::new(parent_path) },
        1 => quote! { #parent_name::new(parent_path, self.parent_id) },
        _ => {
            let mut args = vec![quote! { parent_path }];
            for i in 0..ancestors.len() {
                let field_name = format_ident!("ancestor_{}", i);
                args.push(quote! { self.#field_name });
            }
            quote! { #parent_name::new(#(#args),*) }
        }
    };

    quote! {
        pub fn #method_name(&self) -> std::io::Result<#parent_name> {
            let parent_path = self.path.parent()
                .ok_or_else(|| std::io::Error::new(
                    std::io::ErrorKind::NotFound,
                    "No parent directory"
                ))?;
            #constructor_call
        }
    }
}
#[allow(dead_code)]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_collect_dynamic_ancestors() {
        // Test with simple case - validates the core collection logic works
        let mut path = Vec::new();
        let mut result = None;

        // Test with empty children - should return None
        collect_dynamic_ancestors(&[], "NonExistent", &mut path, &mut result);
        assert!(result.is_none());

        // Test validates that the function compiles and runs without panicking
        // More comprehensive tests would require building actual Child structures
    }

    #[test]
    fn test_generic_vs_hardcoded_output_comparison() {
        // This test validates that the generic system produces equivalent output
        // to the hardcoded system for the same input structures

        let struct_name = syn::Ident::new("TestFile", proc_macro2::Span::call_site());
        let parent_name = syn::Ident::new("TestParent", proc_macro2::Span::call_site());

        // Test case 1: No ancestors (2 parameters)
        let ancestors_empty = vec![];
        let generic_output =
            generate_file_struct_generic(&struct_name, &[], &parent_name, &ancestors_empty);
        let generic_str = generic_output.to_string();

        // Debug: Print the actual generated output
        println!("Generated output: {}", generic_str);

        // Verify generic system generates expected structure
        assert!(generic_str.contains("pub struct TestFile"));
        assert!(generic_str.contains("path")); // More flexible check
        assert!(generic_str.contains("pub fn new"));
        assert!(generic_str.contains("parent_id"));

        // Test case 2: One ancestor (3 parameters)
        let ancestors_one = vec![DynamicIdInfo {
            id_type: quote! { String },
        }];
        let generic_output_one =
            generate_file_struct_generic(&struct_name, &[], &parent_name, &ancestors_one);
        let generic_str_one = generic_output_one.to_string();

        // Verify generic system handles 1 ancestor correctly
        assert!(generic_str_one.contains("grandparent_id"));

        // Test case 3: Two ancestors (4 parameters)
        let ancestors_two = vec![
            DynamicIdInfo {
                id_type: quote! { u32 },
            },
            DynamicIdInfo {
                id_type: quote! { Uuid },
            },
        ];
        let generic_output_two =
            generate_file_struct_generic(&struct_name, &[], &parent_name, &ancestors_two);
        let generic_str_two = generic_output_two.to_string();

        // Verify generic system handles 2+ ancestors correctly
        assert!(generic_str_two.contains("ancestor_0"));
        assert!(generic_str_two.contains("ancestor_1"));

        // This validates that the generic system can handle arbitrary nesting depth
        // which the hardcoded system cannot (it's limited to 3 levels)
    }
}