tree-type-proc-macro 0.1.0

//! Code generation for `::tree_type` structures

use crate::core::{Attribute, Child, DefaultValue, TreeDef};
use quote::quote;
use syn::Ident;

/// 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 Display since it works for all types (strings, numbers, custom types)
    (quote! { impl std::fmt::Display }, quote! { id })
}

/// 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)*
    }
}

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);
    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);

    // 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(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.0).expect("Path validation already performed")
                }
            }
        }
    };

    let serde_derives = if cfg!(feature = "serde") {
        quote! { #[derive(tree_type::deps::serde::Serialize, tree_type::deps::serde::Deserialize)] }
    } else {
        quote! {}
    };
    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(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_buf))
            }

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

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

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

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

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

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

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

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.0)
                    .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.0)
            }

            /// 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.0.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            #walk_fns

            #validate_impl
            #setup_impl
            #ensure_impl

            #from_impl

            #(#nav_methods)*

            #children_method

            #parent_method
        }

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

        #display_impl

        #debug_impl

        #from_trait
    }
}

pub fn build_walk_fns() -> proc_macro2::TokenStream {
    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>> {
                // can't use `as_generic` because the GenericDir would go out-of-scope when we
                // return the iterator it returned
                ::tree_type::deps::walk::WalkDir::new(&self.0)
                    .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],
) {
    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());
                structs.push(generate_file_struct(
                    &struct_name,
                    attributes,
                    Some(parent_name),
                ));
            }
            Child::Directory {
                name,
                custom_type,
                children,
                ..
            } => {
                let struct_name = get_child_type_name(parent_name, name, custom_type.as_ref());
                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);
            }
            Child::DynamicId {
                child_type,
                children,
                attributes,
                is_directory,
                ..
            } => {
                if *is_directory {
                    structs.push(generate_dir_struct(
                        child_type,
                        children,
                        depth + 1,
                        root_children,
                        Some(parent_name),
                    ));
                    generate_child_structs(child_type, children, structs, depth + 1, root_children);
                } else {
                    structs.push(generate_file_struct(
                        child_type,
                        attributes,
                        Some(parent_name),
                    ));
                }
            }
        }
    }
}

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(self.0.join(#filename))
                }
            }
        }
        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(self.0.join(#dirname))
                }
            }
        }
        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 {
                    #child_type(self.0.join(#conversion.to_string()))
                }
            }
        }
    }
}

fn generate_children_method(children: &[Child]) -> 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,
                ..
            } = child
            {
                Some((child_type, *is_directory))
            } 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) = dynamic_children[0];

    // Validate that all dynamic ID children have the same is_directory value
    // This ensures consistent behavior when multiple dynamic ID types exist
    if dynamic_children.len() > 1 {
        let all_same_type = dynamic_children.iter().all(|(_, dir)| *dir == is_directory);
        // This is a compile-time validation - if mixed file/directory dynamic IDs exist,
        // the children() method behavior would be ambiguous
        assert!(
            all_same_type,
            "Mixed file and directory dynamic ID types in the same parent are not supported"
        );
    }

    // 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() }
    };

    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.0.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 {
                            Some(#dynamic_child::new(entry_path).map_err(std::io::Error::from))
                        } 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.0.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.0.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(
    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 = if cfg!(feature = "serde") {
        quote! { #[derive(tree_type::deps::serde::Serialize, tree_type::deps::serde::Deserialize)] }
    } else {
        quote! {}
    };

    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(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_buf))
            }

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

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

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

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

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

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

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

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

            /// 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.0.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(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.0
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericFile {
            fn from(file: #name) -> Self {
                Self::new(file.0).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);
    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 serde_derives = if cfg!(feature = "serde") {
        quote! { #[derive(tree_type::deps::serde::Serialize, tree_type::deps::serde::Deserialize)] }
    } else {
        quote! {}
    };
    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(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_buf))
            }

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

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

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

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

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

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

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

            pub fn read_dir(&self) -> std::io::Result<impl Iterator<Item = std::io::Result<::tree_type::GenericPath>>> {
                ::tree_type::fs::read_dir(&self.0)
                    .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.0)
            }

            /// 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

            /// 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.0.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_default()
            }

            pub fn from_generic(dir: ::tree_type::GenericDir) -> Self {
                Self(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.0
            }
        }

        #display_impl

        #debug_impl

        impl From<#name> for ::tree_type::GenericDir {
            fn from(dir: #name) -> Self {
                Self::new(dir.0).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()
}

#[expect(clippy::too_many_lines)]
fn generate_validate_method(children: &[Child]) -> proc_macro2::TokenStream {
    let validations = children.iter().map(|child| {
        if let Child::DynamicId { child_type, attributes, is_directory, .. } = child {
            // 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
            let pattern_validation = pattern.map(|pattern_lit| {
                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;
                            }
                        }
                    }
                }
            });

            let validator_call = custom_validator.map(|_validator| {
                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,
                        });
                    }
                }
            });

            let recursive_validation = if *is_directory {
                quote! {
                    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.0);

                    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

                                        // Create child instance once for both validator and recursive validation
                                        let child_instance = #child_type(entry_path.clone());

                                        #validator_call

                                        // Only recursively validate if it's a directory
                                        #recursive_validation
                                    }
                                    Err(e) => {
                                        report.errors.push(tree_type::ValidationError {
                                            path: self.0.clone(),
                                            message: format!("Failed to read directory entry: {}", e),
                                        });
                                    }
                                }
                            }
                        }
                        Err(e) => {
                            report.errors.push(tree_type::ValidationError {
                                path: self.0.clone(),
                                message: format!("Failed to read directory: {}", e),
                            });
                        }
                    }
                }
            }
        } 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! {}
                        }
                    }
    });

    // 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() {
                let child_report = self.#name().validate();
                report.merge(child_report);
            }
        }),
        _ => None,
    });

    quote! {
        #[allow(clippy::regex_creation_in_loops)]
        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.0.clone(),
                    message: "Directory does not exist".to_string(),
                });
            }

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

            report
        }
    }
}

#[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! {
                    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! {
        pub fn setup(&self) -> std::result::Result<Vec<::tree_type::BuildError>, Vec<::tree_type::BuildError>> {
            let mut errors = Vec::new();

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

                if let Err(e) = create_result {
                    errors.push(tree_type::BuildError::Directory(
                        self.0.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! {
        pub fn ensure(&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.0.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.0.display())
            }
        }
    }
}