deepmerge-derive 0.1.0

#![forbid(unsafe_code)]

use darling::{ast, FromDeriveInput, FromField, FromMeta};
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Attribute, WhereClause, WherePredicate};
use quote::ToTokens;
use std::collections::HashMap;

/// Policy constraint requirement for a specific type
#[derive(Debug, Clone)]
struct PolicyConstraint {
    /// The trait bounds required (e.g., "Eq + Hash")
    bounds: Vec<String>,
    /// Human-readable description of why these bounds are needed
    reason: String,
}

/// Constraint analyzer for policy requirements
struct ConstraintAnalyzer {
    /// Map from policy setting to required constraints
    sequence_constraints: HashMap<String, PolicyConstraint>,
    map_constraints: HashMap<String, PolicyConstraint>,
}

impl ConstraintAnalyzer {
    fn new() -> Self {
        let mut sequence_constraints = HashMap::new();
        let map_constraints = HashMap::new();
        
        // Sequence merge constraints
        sequence_constraints.insert(
            "union".to_string(),
            PolicyConstraint {
                bounds: vec!["Eq".to_string(), "std::hash::Hash".to_string()],
                reason: "Union operation requires elements to be comparable and hashable for deduplication".to_string(),
            }
        );
        
        sequence_constraints.insert(
            "intersect".to_string(),
            PolicyConstraint {
                bounds: vec!["Eq".to_string(), "std::hash::Hash".to_string()],
                reason: "Intersection operation requires elements to be comparable and hashable".to_string(),
            }
        );
        
        // Map merge constraints - most map operations work with any key/value types
        // but some advanced operations might need additional bounds in the future
        
        Self {
            sequence_constraints,
            map_constraints,
        }
    }
    
    /// Extract string value from typed policy value for constraint checking
    fn extract_policy_string(typed_value: &TypedPolicyValue) -> String {
        match typed_value {
            TypedPolicyValue::Literal(s) => s.clone(),
            TypedPolicyValue::Ident(ident) => ident.to_string(),
            TypedPolicyValue::Path(_) => "custom".to_string(), // Custom path expressions
        }
    }
    
    /// Check if a sequence merge policy requires additional bounds
    fn check_sequence_policy(&self, policy: &str) -> Option<&PolicyConstraint> {
        self.sequence_constraints.get(policy)
    }
    
    /// Check if a map merge policy requires additional bounds  
    fn check_map_policy(&self, policy: &str) -> Option<&PolicyConstraint> {
        self.map_constraints.get(policy)
    }
    
    /// Generate diagnostic error for incompatible policy combination
    fn emit_constraint_diagnostic(
        field_name: &syn::Ident,
        field_type: &syn::Type,
        policy_type: &str,
        policy_value: &str,
        constraint: &PolicyConstraint,
    ) -> darling::Error {
        let bounds_str = constraint.bounds.join(" + ");
        darling::Error::custom(format!(
            "Field `{}` with type `{}` uses {}=\"{}\" which requires `{}`: {}",
            field_name,
            quote!(#field_type).to_string(),
            policy_type,
            policy_value,
            bounds_str,
            constraint.reason
        ))
        .with_span(&field_name.span())
    }
}

/// Bound injection system for automatically adding required trait bounds
struct BoundInjector {
    /// Required bounds per field type (field_name -> bounds)
    field_bounds: HashMap<String, Vec<String>>,
}

impl BoundInjector {
    fn new() -> Self {
        Self {
            field_bounds: HashMap::new(),
        }
    }
    
    /// Add required bounds for a specific field
    fn add_bounds_for_field(&mut self, field_name: &str, bounds: Vec<String>) {
        self.field_bounds.entry(field_name.to_string())
            .or_insert_with(Vec::new)
            .extend(bounds);
    }
    
    /// Inject bounds into the where clause
    fn inject_bounds_into_where_clause(
        &self, 
        fields: &[MergeField],
        where_clause: Option<&WhereClause>
    ) -> syn::WhereClause {
        use syn::{punctuated::Punctuated, Token};
        
        let mut predicates = Punctuated::<WherePredicate, Token![,]>::new();
        
        // Start with existing where clause predicates if any
        if let Some(existing) = where_clause {
            predicates.extend(existing.predicates.iter().cloned());
        }
        
        // Add policy constraint bounds
        for field in fields {
            let field_name = field.ident.as_ref().unwrap().to_string();
            
            if let Some(bounds) = self.field_bounds.get(&field_name) {
                if !bounds.is_empty() {
                    // Parse bounds and create where predicate  
                    for bound_str in bounds {
                        // Parse the bound string which is already formatted as "Type: Trait"
                        if let Ok(predicate) = syn::parse_str::<WherePredicate>(bound_str) {
                            predicates.push(predicate);
                        }
                    }
                }
            }
        }
        
        syn::WhereClause {
            where_token: syn::Token![where](proc_macro2::Span::call_site()),
            predicates,
        }
    }
}

/// Field-level merge configuration
#[derive(Debug, Clone)]
struct FieldConfig {
    sequence: Option<TypedPolicyValue>,
    map: Option<TypedPolicyValue>,
    bool_config: Option<TypedPolicyValue>,
    number: Option<TypedPolicyValue>,
    option: Option<TypedPolicyValue>,
    string: Option<TypedPolicyValue>,
    condition: Option<ConditionPolicy>,
    with: Option<syn::Path>,
    skip: bool,
}

impl Default for FieldConfig {
    fn default() -> Self {
        Self {
            sequence: None,
            map: None,
            bool_config: None,
            number: None,
            option: None,
            string: None,
            condition: None,
            with: None,
            skip: false,
        }
    }
}

impl FromMeta for FieldConfig {
    fn from_list(items: &[darling::ast::NestedMeta]) -> darling::Result<Self> {
        let mut config = FieldConfig::default();
        
        for item in items {
            match item {
                darling::ast::NestedMeta::Meta(meta) => {
                    match meta {
                        syn::Meta::NameValue(nv) => {
                            let name = nv.path.get_ident()
                                .ok_or_else(|| darling::Error::custom("expected identifier"))?
                                .to_string();
                            
                            let typed_value = match &nv.value {
                                // String literal: "append"
                                syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Str(lit), .. }) => {
                                    TypedPolicyValue::Literal(lit.value())
                                },
                                // Path expression: StringMerge::Concat or just Concat
                                syn::Expr::Path(path_expr) => {
                                    if path_expr.path.segments.len() == 1 {
                                        // Simple identifier: append
                                        TypedPolicyValue::Ident(path_expr.path.segments[0].ident.clone())
                                    } else {
                                        // Complex path: StringMerge::Concat
                                        TypedPolicyValue::Path(nv.value.clone())
                                    }
                                },
                                // Other expressions like function calls: StringMerge::ConcatWithSep(", ")
                                _ => TypedPolicyValue::Path(nv.value.clone()),
                            };
                            
                            match name.as_str() {
                                "sequence" => config.sequence = Some(typed_value),
                                "map" => config.map = Some(typed_value),
                                "bool" => config.bool_config = Some(typed_value),
                                "number" => config.number = Some(typed_value),
                                "option" => config.option = Some(typed_value),
                                "string" => config.string = Some(typed_value),
                                "condition" => {
                                    config.condition = Some(ConditionPolicy {
                                        base: typed_value,
                                        changed_by: None,
                                    });
                                },
                                _ => {
                                    let available_configs = &["sequence", "map", "option", "number", "bool", "string", "condition", "skip", "with"];
                                    return Err(darling::Error::custom(get_unknown_policy_error(&name, available_configs))
                                        .with_span(&nv.path));
                                },
                            }
                        }
                        syn::Meta::Path(path) => {
                            if path.is_ident("skip") {
                                config.skip = true;
                            }
                        }
                        _ => {}
                    }
                }
                _ => {}
            }
        }
        
        Ok(config)
    }
}

/// Field-level attributes for customizing merge behavior
#[derive(Debug, FromField)]
#[darling(attributes(merge))]
struct MergeField {
    ident: Option<syn::Ident>,
    ty: syn::Type,
    
    /// Configuration for this field
    #[darling(default, multiple)]
    config: Vec<FieldConfig>,
    
    /// Custom merge function
    #[darling(default)]
    with: Option<syn::Path>,
    
    /// Skip this field during merge
    #[darling(default)]
    skip: bool,
    
    /// Sequence merge behavior (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    sequence: Option<TypedPolicyValue>,
    
    /// Map merge behavior (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    map: Option<TypedPolicyValue>,
    
    /// Bool merge behavior (supports typed values)
    #[darling(default, rename = "bool", with = "parse_typed_policy_value")]
    bool_config: Option<TypedPolicyValue>,
    
    /// Number merge behavior (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    number: Option<TypedPolicyValue>,
    
    /// Option merge behavior (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    option: Option<TypedPolicyValue>,
    
    /// String merge behavior (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    string: Option<TypedPolicyValue>,
    
    /// Condition for merging (supports typed values)
    #[darling(default, with = "parse_typed_policy_value")]
    condition: Option<TypedPolicyValue>,
}

/// Unified function to parse any expression into a TypedPolicyValue
/// Handles string literals, identifiers, paths, function calls, and complex expressions
fn parse_expr_to_typed_policy_value(expr: &syn::Expr) -> TypedPolicyValue {
    match expr {
        // String literal: "append"
        syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Str(lit), .. }) => {
            TypedPolicyValue::Literal(lit.value())
        },
        // Path expression: StringMerge::Concat or just concat  
        syn::Expr::Path(path_expr) => {
            if path_expr.path.segments.len() == 1 {
                // Simple identifier: append
                TypedPolicyValue::Ident(path_expr.path.segments[0].ident.clone())
            } else {
                // Complex path: StringMerge::Concat
                TypedPolicyValue::Path(expr.clone())
            }
        },
        // Function calls and other complex expressions: StringMerge::ConcatWithSep(", ")
        _ => TypedPolicyValue::Path(expr.clone()),
    }
}

/// Parse a TypedPolicyValue directly from a ParseStream for struct-level attributes
/// This handles the full range of syntax: literals, identifiers, paths, and function calls
fn parse_typed_policy_value_from_stream(input: syn::parse::ParseStream) -> syn::Result<TypedPolicyValue> {
    let expr: syn::Expr = input.parse()?;
    Ok(parse_expr_to_typed_policy_value(&expr))
}

/// Parse a TypedPolicyValue from darling meta for field-level attributes with enhanced diagnostics
fn parse_typed_policy_value(meta: &syn::Meta) -> darling::Result<Option<TypedPolicyValue>> {
    match meta {
        syn::Meta::NameValue(nv) => {
            let typed_value = parse_expr_to_typed_policy_value(&nv.value);
            
            // Get the policy type from the attribute path
            if let Some(policy_type) = nv.path.get_ident().map(|i| i.to_string()) {
                let adjusted_policy_type = match policy_type.as_str() {
                    "bool" => "bool", // handle the renamed field
                    other => other,
                };
                
                // Validate literal values for field-level attributes too
                if let TypedPolicyValue::Literal(ref lit_value) = typed_value {
                    if !is_valid_literal_value(adjusted_policy_type, lit_value) {
                        return Err(darling::Error::custom(get_invalid_value_error(adjusted_policy_type, lit_value))
                            .with_span(&nv.value));
                    }
                }
            }
            
            Ok(Some(typed_value))
        },
        syn::Meta::Path(_) => {
            // Just the attribute name without a value, treat as None
            Ok(None)
        },
        syn::Meta::List(_) => {
            Err(darling::Error::custom(
                "List values not supported for policy attributes. Use name = value syntax instead.\n\
                 Examples: #[merge(string = \"concat\")] or #[merge(string = concat)]"
            ).with_span(meta))
        }
    }
}

/// Typed policy value that can be a string literal, identifier, or path expression
#[derive(Debug, Clone)]
enum TypedPolicyValue {
    /// String literal: "append"
    Literal(String),
    /// Identifier: append
    Ident(syn::Ident),
    /// Path expression: StringMerge::ConcatWithSep(", ")
    Path(syn::Expr),
}

impl TypedPolicyValue {
    /// Generate code for this policy value
    fn to_token_stream(&self) -> proc_macro2::TokenStream {
        match self {
            TypedPolicyValue::Literal(s) => quote!(#s),
            TypedPolicyValue::Ident(ident) => quote!(#ident),
            TypedPolicyValue::Path(expr) => quote!(#expr),
        }
    }
}

/// Generate policy variant tokens from a TypedPolicyValue for different policy types
fn generate_policy_variant_tokens(
    policy_type: &str, 
    typed_value: &TypedPolicyValue
) -> proc_macro2::TokenStream {
    match policy_type {
        "sequence" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "append" => quote! { ::deepmerge::SequenceMerge::Append },
                "prepend" => quote! { ::deepmerge::SequenceMerge::Prepend },
                "extend" => quote! { ::deepmerge::SequenceMerge::Extend },
                "union" => quote! { ::deepmerge::SequenceMerge::Union },
                "intersect" => quote! { ::deepmerge::SequenceMerge::Intersect },
                _ => quote! { ::deepmerge::SequenceMerge::Append },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "append" => quote! { ::deepmerge::SequenceMerge::Append },
                    "prepend" => quote! { ::deepmerge::SequenceMerge::Prepend },
                    "extend" => quote! { ::deepmerge::SequenceMerge::Extend },
                    "union" => quote! { ::deepmerge::SequenceMerge::Union },
                    "intersect" => quote! { ::deepmerge::SequenceMerge::Intersect },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        "map" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "overlay" => quote! { ::deepmerge::MapMerge::Overlay },
                "union" => quote! { ::deepmerge::MapMerge::Union },
                "left" => quote! { ::deepmerge::MapMerge::Left },
                "right" => quote! { ::deepmerge::MapMerge::Right },
                _ => quote! { ::deepmerge::MapMerge::Overlay },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "overlay" => quote! { ::deepmerge::MapMerge::Overlay },
                    "union" => quote! { ::deepmerge::MapMerge::Union },
                    "left" => quote! { ::deepmerge::MapMerge::Left },
                    "right" => quote! { ::deepmerge::MapMerge::Right },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        "bool" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "replace" => quote! { ::deepmerge::BoolMerge::Replace },
                "keep" => quote! { ::deepmerge::BoolMerge::Keep },
                "true_wins" => quote! { ::deepmerge::BoolMerge::TrueWins },
                "false_wins" => quote! { ::deepmerge::BoolMerge::FalseWins },
                _ => quote! { ::deepmerge::BoolMerge::Replace },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "replace" => quote! { ::deepmerge::BoolMerge::Replace },
                    "keep" => quote! { ::deepmerge::BoolMerge::Keep },
                    "true_wins" => quote! { ::deepmerge::BoolMerge::TrueWins },
                    "false_wins" => quote! { ::deepmerge::BoolMerge::FalseWins },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        "number" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "replace" => quote! { ::deepmerge::NumberMerge::Replace },
                "keep" => quote! { ::deepmerge::NumberMerge::Keep },
                "max" => quote! { ::deepmerge::NumberMerge::Max },
                "min" => quote! { ::deepmerge::NumberMerge::Min },
                "sum" => quote! { ::deepmerge::NumberMerge::Sum },
                _ => quote! { ::deepmerge::NumberMerge::Replace },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "replace" => quote! { ::deepmerge::NumberMerge::Replace },
                    "keep" => quote! { ::deepmerge::NumberMerge::Keep },
                    "max" => quote! { ::deepmerge::NumberMerge::Max },
                    "min" => quote! { ::deepmerge::NumberMerge::Min },
                    "sum" => quote! { ::deepmerge::NumberMerge::Sum },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        "option" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "take" => quote! { ::deepmerge::OptionMerge::Take },
                "preserve" => quote! { ::deepmerge::OptionMerge::Preserve },
                "or_left" => quote! { ::deepmerge::OptionMerge::OrLeft },
                _ => quote! { ::deepmerge::OptionMerge::Take },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "take" => quote! { ::deepmerge::OptionMerge::Take },
                    "preserve" => quote! { ::deepmerge::OptionMerge::Preserve },
                    "or_left" => quote! { ::deepmerge::OptionMerge::OrLeft },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        "string" => match typed_value {
            TypedPolicyValue::Literal(s) => match s.as_str() {
                "replace" => quote! { ::deepmerge::StringMerge::Replace },
                "keep" => quote! { ::deepmerge::StringMerge::Keep },
                "concat" => quote! { ::deepmerge::StringMerge::Concat },
                s if s.starts_with("concat_with_sep:") => {
                    let sep = &s[16..]; // Remove "concat_with_sep:" prefix
                    quote! { ::deepmerge::StringMerge::ConcatWithSep(#sep) }
                },
                _ => quote! { ::deepmerge::StringMerge::Replace },
            },
            TypedPolicyValue::Ident(ident) => {
                let ident_str = ident.to_string();
                match ident_str.as_str() {
                    "replace" => quote! { ::deepmerge::StringMerge::Replace },
                    "keep" => quote! { ::deepmerge::StringMerge::Keep },
                    "concat" => quote! { ::deepmerge::StringMerge::Concat },
                    _ => quote! { #ident },
                }
            },
            TypedPolicyValue::Path(expr) => quote! { #expr },
        },
        _ => {
            // Unknown policy type, just use the typed value as-is
            typed_value.to_token_stream()
        }
    }
}

/// Consolidate field configuration from both typed attributes and FieldConfig objects
fn consolidate_field_config(field: &MergeField) -> FieldConfig {
    let mut config = FieldConfig::default();
    
    // Start with the first config object if any exists
    if let Some(first_config) = field.config.first() {
        config = first_config.clone();
    }
    
    // Override with direct typed attributes
    if let Some(ref sequence_value) = field.sequence {
        config.sequence = Some(sequence_value.clone());
    }
    if let Some(ref map_value) = field.map {
        config.map = Some(map_value.clone());
    }
    if let Some(ref bool_value) = field.bool_config {
        config.bool_config = Some(bool_value.clone());
    }
    if let Some(ref number_value) = field.number {
        config.number = Some(number_value.clone());
    }
    if let Some(ref option_value) = field.option {
        config.option = Some(option_value.clone());
    }
    if let Some(ref string_value) = field.string {
        config.string = Some(string_value.clone());
    }
    if let Some(ref condition_value) = field.condition {
        config.condition = Some(ConditionPolicy {
            base: condition_value.clone(),
            changed_by: None,
        });
    }
    
    // Copy other attributes
    if field.skip {
        config.skip = true;
    }
    if let Some(ref with_path) = field.with {
        config.with = Some(with_path.clone());
    }
    
    config
}

/// Condition policy with optional key extractor function
#[derive(Debug, Clone)]
struct ConditionPolicy {
    /// Base condition type (e.g., "changed")
    pub base: TypedPolicyValue,
    /// Optional key extractor function for custom equality
    pub changed_by: Option<syn::Path>,
}

/// Struct-level policy configuration with typed values
#[derive(Debug, Clone, Default)]
struct StructPolicy {
    /// Sequence merge behavior
    pub sequence: Option<TypedPolicyValue>,
    /// Map merge behavior  
    pub map: Option<TypedPolicyValue>,
    /// Option merge behavior
    pub option: Option<TypedPolicyValue>,
    /// Number merge behavior
    pub number: Option<TypedPolicyValue>,
    /// Boolean merge behavior
    pub bool_config: Option<TypedPolicyValue>,
    /// String merge behavior
    pub string: Option<TypedPolicyValue>,
    /// Condition for merging with optional key extractor
    pub condition: Option<ConditionPolicy>,
    /// Sequence deduplication
    pub sequence_dedupe: Option<bool>,
    /// Custom unique function for sequences
    pub unique_by: Option<syn::Path>,
}

/// Comprehensive allowed values for each policy type
fn get_allowed_values_for_policy(policy_type: &str) -> &'static str {
    match policy_type {
        "sequence" => "\"append\" | \"prepend\" | \"extend\" | \"union\" | \"intersect\" | append | prepend | extend | union | intersect | SequenceMerge::*",
        "map" => "\"overlay\" | \"union\" | \"left\" | \"right\" | overlay | union | left | right | MapMerge::*",
        "bool" => "\"replace\" | \"keep\" | \"true_wins\" | \"false_wins\" | replace | keep | true_wins | false_wins | BoolMerge::*",
        "number" => "\"replace\" | \"keep\" | \"max\" | \"min\" | \"sum\" | replace | keep | max | min | sum | NumberMerge::*",
        "option" => "\"take\" | \"preserve\" | \"or_left\" | take | preserve | or_left | OptionMerge::*",
        "string" => "\"replace\" | \"keep\" | \"concat\" | replace | keep | concat | StringMerge::* | StringMerge::ConcatWithSep(\"sep\")",
        "condition" => "\"always\" | \"non_empty\" | \"non_default\" | \"some\" | \"changed\" | always | non_empty | non_default | some | changed | Condition::*",
        _ => "unknown policy type",
    }
}

/// Get specific error message for unknown policy setting with detailed allowed values
fn get_unknown_policy_error(key: &str, available_policies: &[&str]) -> String {
    format!(
        "Unknown policy setting: '{}'. Available settings:\n{}", 
        key,
        available_policies.iter()
            .map(|policy| format!("  • {}: {}", policy, get_allowed_values_for_policy(policy)))
            .collect::<Vec<_>>()
            .join("\n")
    )
}

/// Get specific error message for invalid policy value with allowed values
fn get_invalid_value_error(policy_type: &str, invalid_value: &str) -> String {
    let suggestion = get_suggestion_for_invalid_value(policy_type, invalid_value);
    let suggestion_text = if !suggestion.is_empty() {
        format!("\n\nDid you mean: {}", suggestion)
    } else {
        String::new()
    };
    
    format!(
        "Invalid value '{}' for {} policy. Allowed values: {}{}", 
        invalid_value, 
        policy_type,
        get_allowed_values_for_policy(policy_type),
        suggestion_text
    )
}

/// Provide helpful suggestions for common typos
fn get_suggestion_for_invalid_value(policy_type: &str, invalid_value: &str) -> String {
    let lower = invalid_value.to_lowercase();
    match policy_type {
        "sequence" => match lower.as_str() {
            "add" | "push" => "append",
            "pre" => "prepend", 
            "merge" | "combine" => "extend",
            _ => "",
        },
        "string" => match lower.as_str() {
            "join" | "combine" => "concat",
            "override" => "replace",
            _ => "",
        },
        "bool" => match lower.as_str() {
            "override" => "replace",
            "preserve" => "keep",
            _ => "",
        },
        _ => "",
    }.to_string()
}

/// Validate that a literal value is valid for the given policy type
fn is_valid_literal_value(policy_type: &str, value: &str) -> bool {
    match policy_type {
        "sequence" => matches!(value, "append" | "prepend" | "extend" | "union" | "intersect"),
        "map" => matches!(value, "overlay" | "union" | "left" | "right"),
        "bool" => matches!(value, "replace" | "keep" | "true_wins" | "false_wins"),
        "number" => matches!(value, "replace" | "keep" | "max" | "min" | "sum"),
        "option" => matches!(value, "take" | "preserve" | "or_left"),
        "string" => matches!(value, "replace" | "keep" | "concat") || value.starts_with("concat_with_sep:"),
        "condition" => matches!(value, "always" | "non_empty" | "non_default" | "some" | "changed"),
        _ => false, // Unknown policy types are not validated at the literal level
    }
}

/// Helper function to assign a TypedPolicyValue to the appropriate StructPolicy field with enhanced diagnostics
fn assign_to_struct_policy(
    struct_policy: &mut StructPolicy, 
    key: &str, 
    typed_value: TypedPolicyValue,
    key_span: proc_macro2::Span
) -> syn::Result<()> {
    match key {
        "sequence" => struct_policy.sequence = Some(typed_value),
        "map" => struct_policy.map = Some(typed_value),
        "option" => struct_policy.option = Some(typed_value),
        "number" => struct_policy.number = Some(typed_value),
        "bool" => struct_policy.bool_config = Some(typed_value),
        "string" => struct_policy.string = Some(typed_value),
        "condition" => {
            struct_policy.condition = Some(ConditionPolicy {
                base: typed_value,
                changed_by: None,
            });
        },
        _ => {
            let available_policies = &["sequence", "map", "option", "number", "bool", "string", "condition", "sequence_dedupe", "unique_by", "changed_by"];
            return Err(syn::Error::new(
                key_span,
                get_unknown_policy_error(key, available_policies)
            ));
        }
    }
    Ok(())
}

impl StructPolicy {
    /// Parse struct-level policy from attributes using unified TypedPolicyValue parsing
    fn from_attributes(attrs: &[Attribute]) -> Result<Option<Self>, darling::Error> {
        for attr in attrs {
            if !attr.path().is_ident("merge") {
                continue;
            }
            
            let mut struct_policy = StructPolicy::default();
            let mut found_policy = false;
            
            let parse_result = attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("policy") {
                    found_policy = true;
                    
                    // Parse the policy(...) content
                    let content;
                    syn::parenthesized!(content in meta.input);
                    
                    // Parse comma-separated key=value pairs
                    while !content.is_empty() {
                        let key: syn::Ident = content.parse()?;
                        let key_str = key.to_string();
                        let _: syn::Token![=] = content.parse()?;
                        
                        // Handle special cases first
                        match key_str.as_str() {
                            "changed_by" => {
                                // changed_by = "function_name" - still uses string literal for function path
                                let func_name: syn::LitStr = content.parse().map_err(|_| {
                                    syn::Error::new(
                                        content.span(),
                                        "changed_by expects a string literal with function name. Example: changed_by = \"extract_key\""
                                    )
                                })?;
                                let func_path: syn::Path = syn::parse_str(&func_name.value()).map_err(|_| {
                                    syn::Error::new(
                                        func_name.span(),
                                        format!("Invalid function path '{}'. Must be a valid Rust identifier or path", func_name.value())
                                    )
                                })?;
                                // This should be used with a previous condition setting
                                if let Some(ref mut condition) = struct_policy.condition {
                                    condition.changed_by = Some(func_path);
                                } else {
                                    return Err(syn::Error::new(
                                        key.span(),
                                        "changed_by must be used after a condition policy (e.g., condition = \"changed\", changed_by = \"extract_key\")"
                                    ).into());
                                }
                            },
                            "sequence_dedupe" => {
                                // sequence_dedupe = true/false - boolean literal
                                let value: syn::LitBool = content.parse().map_err(|_| {
                                    syn::Error::new(
                                        content.span(),
                                        "sequence_dedupe expects a boolean literal. Allowed values: true | false"
                                    )
                                })?;
                                struct_policy.sequence_dedupe = Some(value.value);
                            },
                            "unique_by" => {
                                // unique_by = function_name - identifier becomes path
                                let value_span = content.span();
                                let typed_value = parse_typed_policy_value_from_stream(&content)?;
                                match typed_value {
                                    TypedPolicyValue::Ident(ident) => {
                                        struct_policy.unique_by = Some(syn::Path::from(ident));
                                    },
                                    TypedPolicyValue::Path(expr) => {
                                        if let syn::Expr::Path(path_expr) = expr {
                                            struct_policy.unique_by = Some(path_expr.path);
                                        } else {
                                            return Err(syn::Error::new(
                                                value_span,
                                                "unique_by must be an identifier or path. Examples: unique_by = my_function | unique_by = module::function"
                                            ).into());
                                        }
                                    },
                                    TypedPolicyValue::Literal(lit_value) => {
                                        return Err(syn::Error::new(
                                            value_span,
                                            format!("unique_by must be an identifier or path, not a string literal. Did you mean: unique_by = {} (without quotes)?", lit_value)
                                        ).into());
                                    }
                                }
                            },
                            _ => {
                                // Regular policy fields - use unified parsing with enhanced error messages
                                let value_span = content.span();
                                let typed_value = parse_typed_policy_value_from_stream(&content)?;
                                
                                // Validate the value for known policy types
                                if let TypedPolicyValue::Literal(ref lit_value) = typed_value {
                                    if !is_valid_literal_value(&key_str, lit_value) {
                                        return Err(syn::Error::new(
                                            value_span,
                                            get_invalid_value_error(&key_str, lit_value)
                                        ).into());
                                    }
                                }
                                
                                assign_to_struct_policy(&mut struct_policy, &key_str, typed_value, key.span())?;
                            }
                        }
                        
                        // Parse optional comma
                        if content.peek(syn::Token![,]) {
                            let _: syn::Token![,] = content.parse()?;
                        }
                    }
                    
                    Ok(())
                } else {
                    // Skip non-policy attributes
                    Ok(())
                }
            });
            
            // Handle parsing errors
            if let Err(syn_error) = parse_result {
                return Err(darling::Error::custom(format!(
                    "Failed to parse merge attribute: {}", 
                    syn_error
                )));
            }
            
            if found_policy {
                return Ok(Some(struct_policy));
            }
        }
        
        Ok(None)
    }
}

/// Container-level attributes
#[derive(Debug, FromDeriveInput)]
#[darling(attributes(merge), supports(struct_named, enum_any), forward_attrs(allow, doc, cfg))]
struct MergeInput {
    ident: syn::Ident,
    generics: syn::Generics,
    data: ast::Data<(), MergeField>,
}

#[proc_macro_derive(DeepMerge, attributes(merge))]
pub fn derive_deep_merge(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    
    // Parse struct-level policy manually
    let struct_policy = match StructPolicy::from_attributes(&input.attrs) {
        Ok(policy) => policy,
        Err(e) => return TokenStream::from(e.write_errors()),
    };
    
    // Create a temporary DeriveInput without the policy attribute for darling parsing
    let mut input_for_darling = input.clone();
    input_for_darling.attrs.retain(|attr| {
        !attr.path().is_ident("merge") || 
        !attr.to_token_stream().to_string().contains("policy")
    });
    
    let merge_input = match MergeInput::from_derive_input(&input_for_darling) {
        Ok(v) => v,
        Err(e) => return TokenStream::from(e.write_errors()),
    };
    
    let struct_name = &merge_input.ident;
    let (_, ty_generics, _) = merge_input.generics.split_for_impl();
    
    // Create impl generics with P added
    let mut impl_generics = merge_input.generics.clone();
    
    // Add P generic for Policy
    use syn::parse_quote;
    impl_generics.params.push(parse_quote!(P));
    
    // Get the impl pieces
    let (impl_generics_tokens, _, where_clause) = impl_generics.split_for_impl();
    
    match merge_input.data {
        ast::Data::Struct(fields) => {
            generate_struct_impl(struct_name, impl_generics_tokens, ty_generics, where_clause, fields.fields, struct_policy)
        }
        ast::Data::Enum(_variants) => {
            generate_enum_impl(struct_name, impl_generics_tokens, ty_generics, where_clause)
        }
    }
}

fn generate_struct_impl(
    struct_name: &syn::Ident,
    impl_generics_tokens: syn::ImplGenerics,
    ty_generics: syn::TypeGenerics,
    where_clause: Option<&syn::WhereClause>,
    fields: Vec<MergeField>,
    struct_policy: Option<StructPolicy>,
) -> TokenStream {
    let analyzer = ConstraintAnalyzer::new();
    let mut bound_injector = BoundInjector::new();
    let diagnostics: Vec<darling::Error> = Vec::new();
    // Collect field names for destructuring
    let field_names: Vec<_> = fields.iter().map(|f| &f.ident).collect();
    
    // Generate struct-level policy setup
    let struct_policy_setup = if let Some(ref sp) = struct_policy {
        let mut setup_calls = vec![];
        
        if let Some(ref seq) = sp.sequence {
            let variant = match seq {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "append" => quote! { ::deepmerge::SequenceMerge::Append },
                    "prepend" => quote! { ::deepmerge::SequenceMerge::Prepend },
                    "extend" => quote! { ::deepmerge::SequenceMerge::Extend },
                    "union" => quote! { ::deepmerge::SequenceMerge::Union },
                    "intersect" => quote! { ::deepmerge::SequenceMerge::Intersect },
                    _ => quote! { ::deepmerge::SequenceMerge::Append },
                },
                TypedPolicyValue::Ident(ident) => {
                    // Handle identifier: append -> SequenceMerge::Append
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "append" => quote! { ::deepmerge::SequenceMerge::Append },
                        "prepend" => quote! { ::deepmerge::SequenceMerge::Prepend },
                        "extend" => quote! { ::deepmerge::SequenceMerge::Extend },
                        "union" => quote! { ::deepmerge::SequenceMerge::Union },
                        "intersect" => quote! { ::deepmerge::SequenceMerge::Intersect },
                        _ => quote! { #ident }, // Use as-is for custom types
                    }
                },
                TypedPolicyValue::Path(expr) => {
                    // Use path expression directly: SequenceMerge::Union
                    quote! { #expr }
                },
            };
            setup_calls.push(quote! { .with_sequence_merge(#variant) });
        }
        
        if let Some(ref map) = sp.map {
            let variant = match map {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "overlay" => quote! { ::deepmerge::MapMerge::Overlay },
                    "union" => quote! { ::deepmerge::MapMerge::Union },
                    "left" => quote! { ::deepmerge::MapMerge::Left },
                    "right" => quote! { ::deepmerge::MapMerge::Right },
                    _ => quote! { ::deepmerge::MapMerge::Overlay },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "overlay" => quote! { ::deepmerge::MapMerge::Overlay },
                        "union" => quote! { ::deepmerge::MapMerge::Union },
                        "left" => quote! { ::deepmerge::MapMerge::Left },
                        "right" => quote! { ::deepmerge::MapMerge::Right },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_map_merge(#variant) });
        }
        
        if let Some(ref opt) = sp.option {
            let variant = match opt {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "take" => quote! { ::deepmerge::OptionMerge::Take },
                    "preserve" => quote! { ::deepmerge::OptionMerge::Preserve },
                    "or_left" => quote! { ::deepmerge::OptionMerge::OrLeft },
                    _ => quote! { ::deepmerge::OptionMerge::Take },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "take" => quote! { ::deepmerge::OptionMerge::Take },
                        "preserve" => quote! { ::deepmerge::OptionMerge::Preserve },
                        "or_left" => quote! { ::deepmerge::OptionMerge::OrLeft },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_option_merge(#variant) });
        }
        
        if let Some(ref num) = sp.number {
            let variant = match num {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "replace" => quote! { ::deepmerge::NumberMerge::Replace },
                    "keep" => quote! { ::deepmerge::NumberMerge::Keep },
                    "max" => quote! { ::deepmerge::NumberMerge::Max },
                    "min" => quote! { ::deepmerge::NumberMerge::Min },
                    "sum" => quote! { ::deepmerge::NumberMerge::Sum },
                    _ => quote! { ::deepmerge::NumberMerge::Replace },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "replace" => quote! { ::deepmerge::NumberMerge::Replace },
                        "keep" => quote! { ::deepmerge::NumberMerge::Keep },
                        "max" => quote! { ::deepmerge::NumberMerge::Max },
                        "min" => quote! { ::deepmerge::NumberMerge::Min },
                        "sum" => quote! { ::deepmerge::NumberMerge::Sum },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_number_merge(#variant) });
        }
        
        if let Some(ref bool_cfg) = sp.bool_config {
            let variant = match bool_cfg {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "replace" => quote! { ::deepmerge::BoolMerge::Replace },
                    "keep" => quote! { ::deepmerge::BoolMerge::Keep },
                    "true_wins" => quote! { ::deepmerge::BoolMerge::TrueWins },
                    "false_wins" => quote! { ::deepmerge::BoolMerge::FalseWins },
                    _ => quote! { ::deepmerge::BoolMerge::Replace },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "replace" => quote! { ::deepmerge::BoolMerge::Replace },
                        "keep" => quote! { ::deepmerge::BoolMerge::Keep },
                        "true_wins" => quote! { ::deepmerge::BoolMerge::TrueWins },
                        "false_wins" => quote! { ::deepmerge::BoolMerge::FalseWins },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_bool_merge(#variant) });
        }
        
        if let Some(ref str_cfg) = sp.string {
            let variant = match str_cfg {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "replace" => quote! { ::deepmerge::StringMerge::Replace },
                    "keep" => quote! { ::deepmerge::StringMerge::Keep },
                    "concat" => quote! { ::deepmerge::StringMerge::Concat },
                    s if s.starts_with("concat_with_sep:") => {
                        let sep = &s[16..]; // Remove "concat_with_sep:" prefix
                        quote! { ::deepmerge::StringMerge::ConcatWithSep(#sep) }
                    },
                    _ => quote! { ::deepmerge::StringMerge::Replace },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "replace" => quote! { ::deepmerge::StringMerge::Replace },
                        "keep" => quote! { ::deepmerge::StringMerge::Keep },
                        "concat" => quote! { ::deepmerge::StringMerge::Concat },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_string_merge(#variant) });
        }
        
        if let Some(ref cond) = sp.condition {
            let variant = match &cond.base {
                TypedPolicyValue::Literal(s) => match s.as_str() {
                    "always" => quote! { ::deepmerge::Condition::Always },
                    "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                    "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                    "some" => quote! { ::deepmerge::Condition::Some },
                    "changed" => {
                        if let Some(ref key_extractor) = cond.changed_by {
                            quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                        } else {
                            quote! { ::deepmerge::Condition::Changed }
                        }
                    },
                    _ => quote! { ::deepmerge::Condition::Always },
                },
                TypedPolicyValue::Ident(ident) => {
                    let ident_str = ident.to_string();
                    match ident_str.as_str() {
                        "always" => quote! { ::deepmerge::Condition::Always },
                        "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                        "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                        "some" => quote! { ::deepmerge::Condition::Some },
                        "changed" => {
                            if let Some(ref key_extractor) = cond.changed_by {
                                quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                            } else {
                                quote! { ::deepmerge::Condition::Changed }
                            }
                        },
                        _ => quote! { #ident },
                    }
                },
                TypedPolicyValue::Path(expr) => quote! { #expr },
            };
            setup_calls.push(quote! { .with_when_condition(#variant) });
        }
        
        if let Some(dedupe) = sp.sequence_dedupe {
            setup_calls.push(quote! { .with_sequence_dedupe(#dedupe) });
        }
        
        if setup_calls.is_empty() {
            quote! {
                let struct_policy = policy;
            }
        } else {
            quote! {
                let struct_policy = &::deepmerge::ComposedPolicy::new(::deepmerge::DefaultPolicy)#(#setup_calls)*;
            }
        }
    } else {
        quote! {
            let struct_policy = policy;
        }
    };
    
    // Validate policy constraints and collect required bounds for each field
    for field in &fields {
        let field_name = field.ident.as_ref().expect("Named field");
        
        // Check struct-level policy constraints
        if let Some(ref sp) = struct_policy {
            if let Some(ref seq) = sp.sequence {
                let seq_str = ConstraintAnalyzer::extract_policy_string(seq);
                if let Some(constraint) = analyzer.check_sequence_policy(&seq_str) {
                    if is_sequence_type(&field.ty) {
                        bound_injector.add_bounds_for_field(
                            &field_name.to_string(),
                            get_sequence_element_bounds(&field.ty, constraint.bounds.clone())
                        );
                    }
                }
            }
        }
        
        // TODO: Field-level constraint checking for typed attributes
        // This will be implemented when field attributes are migrated to typed values
    }
    
    // If we have diagnostics, return them as compilation errors
    if !diagnostics.is_empty() {
        // Just return the first error for now - multiple errors can be chained later
        return TokenStream::from(diagnostics.into_iter().next().unwrap().write_errors());
    }
    
    // Inject required bounds into the where clause
    let mut enhanced_where_clause = bound_injector.inject_bounds_into_where_clause(&fields, where_clause);
    
    // Add the Policy bound
    use syn::{parse_quote, WherePredicate};
    let policy_bound: WherePredicate = parse_quote! { P: ::deepmerge::Policy };
    enhanced_where_clause.predicates.push(policy_bound);
    
    let field_merges = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().expect("Named field");
        
        // Consolidate field configuration from both string attributes and TypedPolicyValue configs
        let config = consolidate_field_config(field);
        
        if config.skip {
            // Skip this field - consume but don't use
            return quote! {
                let _ = #field_name;
            };
        }
        
        if let Some(custom_fn) = &config.with {
            // Use custom merge function
            return quote! {
                #custom_fn(&mut self.#field_name, #field_name);
            };
        }
        
        // Build composed policy if field has any overrides
        let has_overrides = config.sequence.is_some() || 
                           config.map.is_some() || 
                           config.bool_config.is_some() || 
                           config.number.is_some() || 
                           config.option.is_some() || 
                           config.string.is_some() || 
                           config.condition.is_some();
        
        if has_overrides {
            let mut policy_setup = vec![
                quote! {
                    let field_policy = ::deepmerge::ComposedPolicy::new(::deepmerge::DefaultPolicy);
                }
            ];
            
            if let Some(sequence) = &config.sequence {
                let variant = generate_policy_variant_tokens("sequence", sequence);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_sequence_merge(#variant);
                });
            }
            
            if let Some(map) = &config.map {
                let variant = generate_policy_variant_tokens("map", map);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_map_merge(#variant);
                });
            }
            
            if let Some(bool_config) = &config.bool_config {
                let variant = generate_policy_variant_tokens("bool", bool_config);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_bool_merge(#variant);
                });
            }
            
            if let Some(number) = &config.number {
                let variant = generate_policy_variant_tokens("number", number);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_number_merge(#variant);
                });
            }
            
            if let Some(option) = &config.option {
                let variant = generate_policy_variant_tokens("option", option);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_option_merge(#variant);
                });
            }
            
            if let Some(string) = &config.string {
                let variant = generate_policy_variant_tokens("string", string);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_string_merge(#variant);
                });
            }
            
            if let Some(condition) = &config.condition {
                let variant = match &condition.base {
                    TypedPolicyValue::Literal(s) => match s.as_str() {
                        "always" => quote! { ::deepmerge::Condition::Always },
                        "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                        "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                        "some" => quote! { ::deepmerge::Condition::Some },
                        "changed" => {
                            if let Some(ref key_extractor) = condition.changed_by {
                                quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                            } else {
                                quote! { ::deepmerge::Condition::Changed }
                            }
                        },
                        _ => quote! { ::deepmerge::Condition::Always },
                    },
                    TypedPolicyValue::Ident(ident) => {
                        let ident_str = ident.to_string();
                        match ident_str.as_str() {
                            "always" => quote! { ::deepmerge::Condition::Always },
                            "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                            "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                            "some" => quote! { ::deepmerge::Condition::Some },
                            "changed" => {
                                if let Some(ref key_extractor) = condition.changed_by {
                                    quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                                } else {
                                    quote! { ::deepmerge::Condition::Changed }
                                }
                            },
                            _ => quote! { #ident },
                        }
                    },
                    TypedPolicyValue::Path(expr) => quote! { #expr },
                };
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_when_condition(#variant);
                });
            }
            
            quote! {
                {
                    #(#policy_setup)*
                    self.#field_name.merge_with_policy(#field_name, &field_policy);
                }
            }
        } else {
            // Use struct policy directly (no field-level overrides)
            quote! {
                self.#field_name.merge_with_policy(#field_name, struct_policy);
            }
        }
    });
    
    // We no longer generate field_merge_refs since we don't generate merge_ref
    // This allows non-Clone types to use the derive macro
    /*
    // Generate merge_ref field accessors for efficient per-field merging
    let field_merge_refs = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().expect("Named field");
        
        // Consolidate field configuration from both string attributes and TypedPolicyValue configs
        let config = consolidate_field_config(field);
        
        if config.skip {
            // Skip this field - no operation needed
            return quote! {};
        }
        
        if let Some(custom_fn) = &config.with {
            // Use custom merge function - need to clone the field value
            return quote! {
                #custom_fn(&mut self.#field_name, src.#field_name.clone());
            };
        }
        
        // Build composed policy if field has any overrides
        let has_overrides = config.sequence.is_some() || 
                           config.map.is_some() || 
                           config.bool_config.is_some() || 
                           config.number.is_some() || 
                           config.option.is_some() || 
                           config.string.is_some() || 
                           config.condition.is_some();
        
        if has_overrides {
            let mut policy_setup = vec![quote! {
                let field_policy = ::deepmerge::ComposedPolicy::new(struct_policy.clone());
            }];
            
            // Add field-specific policy overrides (same as in merge_with_policy)
            if let Some(seq) = &config.sequence {
                let variant = generate_policy_variant_tokens("sequence", seq);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_sequence_merge(#variant);
                });
            }
            
            if let Some(map) = &config.map {
                let variant = generate_policy_variant_tokens("map", map);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_map_merge(#variant);
                });
            }
            
            if let Some(bool_config) = &config.bool_config {
                let variant = generate_policy_variant_tokens("bool", bool_config);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_bool_merge(#variant);
                });
            }
            
            if let Some(number) = &config.number {
                let variant = generate_policy_variant_tokens("number", number);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_number_merge(#variant);
                });
            }
            
            if let Some(option) = &config.option {
                let variant = generate_policy_variant_tokens("option", option);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_option_merge(#variant);
                });
            }
            
            if let Some(string) = &config.string {
                let variant = generate_policy_variant_tokens("string", string);
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_string_merge(#variant);
                });
            }
            
            if let Some(condition) = &config.condition {
                let variant = match &condition.base {
                    TypedPolicyValue::Literal(s) => match s.as_str() {
                        "always" => quote! { ::deepmerge::Condition::Always },
                        "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                        "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                        "some" => quote! { ::deepmerge::Condition::Some },
                        "changed" => {
                            if let Some(ref key_extractor) = condition.changed_by {
                                quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                            } else {
                                quote! { ::deepmerge::Condition::Changed }
                            }
                        },
                        _ => quote! { ::deepmerge::Condition::Always },
                    },
                    TypedPolicyValue::Ident(ident) => {
                        let ident_str = ident.to_string();
                        match ident_str.as_str() {
                            "always" => quote! { ::deepmerge::Condition::Always },
                            "non_empty" => quote! { ::deepmerge::Condition::NonEmpty },
                            "non_default" => quote! { ::deepmerge::Condition::NonDefault },
                            "some" => quote! { ::deepmerge::Condition::Some },
                            "changed" => {
                                if let Some(ref key_extractor) = condition.changed_by {
                                    quote! { ::deepmerge::Condition::ChangedBy(#key_extractor) }
                                } else {
                                    quote! { ::deepmerge::Condition::Changed }
                                }
                            },
                            _ => quote! { #ident },
                        }
                    },
                    TypedPolicyValue::Path(expr) => quote! { #expr },
                };
                policy_setup.push(quote! {
                    let field_policy = field_policy.with_when_condition(#variant);
                });
            }
            
            quote! {
                {
                    #(#policy_setup)*
                    ::deepmerge::DeepMerge::merge_ref(&mut self.#field_name, &src.#field_name, &field_policy);
                }
            }
        } else {
            // Use struct policy directly (no field-level overrides)
            quote! {
                ::deepmerge::DeepMerge::merge_ref(&mut self.#field_name, &src.#field_name, &struct_policy);
            }
        }
    });
    */

    let output = quote! {
        impl #impl_generics_tokens ::deepmerge::DeepMerge<P> for #struct_name #ty_generics #enhanced_where_clause
        {
            fn merge_with_policy(&mut self, other: Self, policy: &P) {
                let Self { #(#field_names),* } = other;
                #struct_policy_setup
                #(#field_merges)*
            }
            
            // We don't generate merge_ref to allow non-Clone types to use the derive
            // The trait provides a default implementation that requires Clone
        }
    };
    
    TokenStream::from(output)
}

fn generate_enum_impl(
    enum_name: &syn::Ident,
    impl_generics_tokens: syn::ImplGenerics,
    ty_generics: syn::TypeGenerics,
    where_clause: Option<&syn::WhereClause>,
) -> TokenStream {
    // For enums, we just replace - enums are typically used for categorical data
    // where merging doesn't make sense, so we use replace semantics
    let output = quote! {
        impl #impl_generics_tokens ::deepmerge::DeepMerge<P> for #enum_name #ty_generics #where_clause
        where
            P: ::deepmerge::Policy,
        {
            fn merge_with_policy(&mut self, other: Self, _policy: &P) {
                *self = other;
            }
            
            // We don't generate merge_ref to allow non-Clone types to use the derive
            // The trait provides a default implementation that requires Clone
        }
    };
    
    TokenStream::from(output)
}

/// Check if a type is a sequence type (Vec, array, etc.)
fn is_sequence_type(ty: &syn::Type) -> bool {
    match ty {
        syn::Type::Path(type_path) => {
            if let Some(segment) = type_path.path.segments.last() {
                matches!(segment.ident.to_string().as_str(), "Vec" | "VecDeque" | "LinkedList")
            } else {
                false
            }
        }
        syn::Type::Array(_) => true,
        syn::Type::Slice(_) => true,
        _ => false,
    }
}

/// Check if a type is a map type (HashMap, BTreeMap, etc.)
fn is_map_type(ty: &syn::Type) -> bool {
    match ty {
        syn::Type::Path(type_path) => {
            if let Some(segment) = type_path.path.segments.last() {
                matches!(segment.ident.to_string().as_str(), "HashMap" | "BTreeMap" | "IndexMap")
            } else {
                false
            }
        }
        _ => false,
    }
}

/// Extract bounds for sequence element type
fn get_sequence_element_bounds(ty: &syn::Type, base_bounds: Vec<String>) -> Vec<String> {
    match ty {
        syn::Type::Path(type_path) => {
            if let Some(segment) = type_path.path.segments.last() {
                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
                    if let Some(syn::GenericArgument::Type(element_type)) = args.args.first() {
                        // Apply bounds to the element type
                        return base_bounds.into_iter().map(|bound| {
                            format!("{}: {}", quote!(#element_type), bound)
                        }).collect();
                    }
                }
            }
        }
        syn::Type::Array(array) => {
            let element_type = &array.elem;
            return base_bounds.into_iter().map(|bound| {
                format!("{}: {}", quote!(#element_type), bound)
            }).collect();
        }
        syn::Type::Slice(slice) => {
            let element_type = &slice.elem;
            return base_bounds.into_iter().map(|bound| {
                format!("{}: {}", quote!(#element_type), bound)
            }).collect();
        }
        _ => {}
    }
    
    // Fallback: apply bounds to the whole type
    base_bounds.into_iter().map(|bound| {
        format!("{}: {}", quote!(#ty), bound)
    }).collect()
}

/// Extract bounds for map key type
fn get_map_key_bounds(ty: &syn::Type, base_bounds: Vec<String>) -> Vec<String> {
    match ty {
        syn::Type::Path(type_path) => {
            if let Some(segment) = type_path.path.segments.last() {
                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
                    if let Some(syn::GenericArgument::Type(key_type)) = args.args.first() {
                        // Apply bounds to the key type
                        return base_bounds.into_iter().map(|bound| {
                            format!("{}: {}", quote!(#key_type), bound)
                        }).collect();
                    }
                }
            }
        }
        _ => {}
    }
    
    // Fallback: apply bounds to the whole type
    base_bounds.into_iter().map(|bound| {
        format!("{}: {}", quote!(#ty), bound)
    }).collect()
}