macroforge_ts 0.1.78

//! # Ord Macro Implementation
//!
//! The `Ord` macro generates a `compareTo()` method for **total ordering** comparison.
//! This is analogous to Rust's `Ord` trait, enabling objects to be sorted and
//! compared with a guaranteed ordering relationship.
//!
//! ## Generated Output
//!
//! | Type | Generated Code | Description |
//! |------|----------------|-------------|
//! | Class | `classNameCompare(a, b)` + `static compareTo(a, b)` | Standalone function + static wrapper method |
//! | Enum | `enumNameCompare(a: EnumName, b: EnumName): number` | Standalone function comparing enum values |
//! | Interface | `interfaceNameCompare(a: InterfaceName, b: InterfaceName): number` | Standalone function comparing fields |
//! | Type Alias | `typeNameCompare(a: TypeName, b: TypeName): number` | Standalone function with type-appropriate comparison |
//!
//!
//! ## Return Values
//!
//! Unlike `PartialOrd`, `Ord` provides **total ordering** - every pair of values
//! can be compared:
//!
//! - **-1**: `a` is less than `b`
//! - **0**: `a` is equal to `b`
//! - **1**: `a` is greater than `b`
//!
//! The function **never returns null** - all values must be comparable.
//!
//! ## Comparison Strategy
//!
//! Fields are compared **lexicographically** in declaration order:
//!
//! 1. Compare first field
//! 2. If not equal, return that result
//! 3. Otherwise, compare next field
//! 4. Continue until a difference is found or all fields are equal
//!
//! ## Type-Specific Comparisons
//!
//! | Type | Comparison Method |
//! |------|-------------------|
//! | `number`/`bigint` | Direct `<` and `>` comparison |
//! | `string` | `localeCompare()` (clamped to -1, 0, 1) |
//! | `boolean` | false < true |
//! | Arrays | Lexicographic element-by-element |
//! | `Date` | `getTime()` timestamp comparison |
//! | Objects | Calls `compareTo()` if available, else 0 |
//!
//! ## Field-Level Options
//!
//! The `@ord` decorator supports:
//!
//! - `skip` - Exclude the field from ordering comparison
//!
//! ## Example
//!
//! ```typescript
//! /** @derive(Ord) */
//! class Version {
//!     major: number;
//!     minor: number;
//!     patch: number;
//! }
//! ```
//!
//! Generated output:
//!
//! ```typescript
//! class Version {
//!     major: number;
//!     minor: number;
//!     patch: number;
//!
//!     static compareTo(a: Version, b: Version): number {
//!         return versionCompare(a, b);
//!     }
//! }
//!
//! export function versionCompare(a: Version, b: Version): number {
//!     if (a === b) return 0;
//!     const cmp0 = a.major < b.major ? -1 : a.major > b.major ? 1 : 0;
//!     if (cmp0 !== 0) return cmp0;
//!     const cmp1 = a.minor < b.minor ? -1 : a.minor > b.minor ? 1 : 0;
//!     if (cmp1 !== 0) return cmp1;
//!     const cmp2 = a.patch < b.patch ? -1 : a.patch > b.patch ? 1 : 0;
//!     if (cmp2 !== 0) return cmp2;
//!     return 0;
//! }
//! ```
//!
//! ## Ord vs PartialOrd
//!
//! - Use **Ord** when all values are comparable (total ordering)
//! - Use **PartialOrd** when some values may be incomparable (returns `Option<number>`)

use convert_case::{Case, Casing};

use crate::builtin::derive_common::{
    CompareFieldOptions, is_numeric_type, is_primitive_type, standalone_fn_name, type_has_derive,
};
use crate::macros::{ts_macro_derive, ts_template};
use crate::swc_ecma_ast::{Expr, Ident};
use crate::ts_syn::abi::ir::type_registry::{ResolvedTypeRef, TypeRegistry};
use crate::ts_syn::{
    Data, DeriveInput, MacroforgeError, TsStream, parse_ts_expr, parse_ts_macro_input, ts_ident,
};

/// Contains field information needed for ordering comparison generation.
///
/// Each field that participates in ordering is represented by this struct,
/// which captures both the field name (for access) and its TypeScript type
/// (to select the appropriate comparison strategy).
struct OrdField {
    /// The field name as it appears in the source TypeScript class.
    /// Used to generate property access expressions like `this.name`.
    name: String,

    /// The TypeScript type annotation for this field.
    /// Used to determine which comparison strategy to apply
    /// (e.g., numeric comparison, string localeCompare, recursive compareTo).
    ts_type: String,
}

/// Generates JavaScript code that compares fields for ordering.
///
/// This function produces an expression that evaluates to -1, 0, or 1 indicating
/// the ordering relationship between two values. The generated code handles
/// different TypeScript types with appropriate comparison strategies.
///
/// Unlike `PartialOrd`, this function guarantees a total ordering - it **never
/// returns null**. For incomparable values, it falls back to 0 (equal).
///
/// # Arguments
///
/// * `field` - The field to generate comparison code for
/// * `self_var` - Variable name for the first object (e.g., "self", "a")
/// * `other_var` - Variable name for the second object (e.g., "other", "b")
///
/// # Returns
///
/// A string containing a JavaScript expression that evaluates to -1, 0, or 1.
/// Field access uses the provided variable names: `self_var.field` vs `other_var.field`.
///
/// # Type-Specific Strategies
///
/// - **number/bigint**: Direct `<` and `>` comparison
/// - **string**: Uses `localeCompare()`, result clamped to -1, 0, 1
/// - **boolean**: false is less than true
/// - **null/undefined**: Treated as equal (returns 0)
/// - **Arrays**: Lexicographic comparison with fallback to 0 for incomparable elements
/// - **Date**: Timestamp comparison via `getTime()`
/// - **Objects**: Calls `compareTo()` if available (with `?? 0` fallback), else 0
fn generate_field_compare_for_interface(
    field: &OrdField,
    self_var: &str,
    other_var: &str,
    resolved: Option<&ResolvedTypeRef>,
    registry: Option<&TypeRegistry>,
) -> String {
    let field_name = &field.name;
    let ts_type = &field.ts_type;

    // Type-aware path: direct compare call when type has @derive(Ord)
    if let (Some(resolved), Some(registry)) = (resolved, registry)
        && !resolved.is_collection
        && resolved.registry_key.is_some()
        && type_has_derive(registry, &resolved.base_type_name, "Ord")
    {
        let fn_name = standalone_fn_name(&resolved.base_type_name, "Compare");
        return format!("{fn_name}({self_var}.{field_name}, {other_var}.{field_name})");
    }

    if is_numeric_type(ts_type) {
        format!(
            "({self_var}.{field_name} < {other_var}.{field_name} ? -1 : \
             {self_var}.{field_name} > {other_var}.{field_name} ? 1 : 0)"
        )
    } else if ts_type == "string" {
        format!(
            "((cmp => cmp < 0 ? -1 : cmp > 0 ? 1 : 0)({self_var}.{field_name}.localeCompare({other_var}.{field_name})))"
        )
    } else if ts_type == "boolean" {
        format!(
            "({self_var}.{field_name} === {other_var}.{field_name} ? 0 : \
             {self_var}.{field_name} ? 1 : -1)"
        )
    } else if is_primitive_type(ts_type) {
        "0".to_string()
    } else if ts_type.ends_with("[]") || ts_type.starts_with("Array<") {
        format!(
            "(() => {{ \
                const a = {self_var}.{field_name} ?? []; \
                const b = {other_var}.{field_name} ?? []; \
                const minLen = Math.min(a.length, b.length); \
                for (let i = 0; i < minLen; i++) {{ \
                    const cmp = typeof (a[i] as any)?.compareTo === 'function' \
                        ? (a[i] as any).compareTo(b[i]) ?? 0 \
                        : (a[i] < b[i] ? -1 : a[i] > b[i] ? 1 : 0); \
                    if (cmp !== 0) return cmp; \
                }} \
                return a.length < b.length ? -1 : a.length > b.length ? 1 : 0; \
            }})()"
        )
    } else if ts_type == "Date" {
        format!(
            "(() => {{ \
                const ta = {self_var}.{field_name}?.getTime() ?? 0; \
                const tb = {other_var}.{field_name}?.getTime() ?? 0; \
                return ta < tb ? -1 : ta > tb ? 1 : 0; \
            }})()"
        )
    } else {
        format!(
            "(typeof ({self_var}.{field_name} as any)?.compareTo === 'function' \
                ? ({self_var}.{field_name} as any).compareTo({other_var}.{field_name}) ?? 0 \
                : 0)"
        )
    }
}

#[ts_macro_derive(
    Ord,
    description = "Generates a compareTo() method for total ordering (returns -1, 0, or 1, never null)",
    attributes(ord)
)]
pub fn derive_ord_macro(mut input: TsStream) -> Result<TsStream, MacroforgeError> {
    let input = parse_ts_macro_input!(input as DeriveInput);
    let resolved_fields = input.context.resolved_fields.as_ref();
    let type_registry = input.context.type_registry.as_ref();

    match &input.data {
        Data::Class(class) => {
            let class_name = input.name();
            let class_ident = ts_ident!(class_name);

            // Collect fields for comparison
            let ord_fields: Vec<OrdField> = class
                .fields()
                .iter()
                .filter_map(|field| {
                    let opts = CompareFieldOptions::from_decorators(&field.decorators, "ord");
                    if opts.skip {
                        return None;
                    }
                    Some(OrdField {
                        name: field.name.clone(),
                        ts_type: field.ts_type.clone(),
                    })
                })
                .collect();

            // Generate function name (always prefix style)
            let fn_name_ident = ts_ident!("{}Compare", class_name.to_case(Case::Camel));
            let fn_name_expr: Expr = fn_name_ident.clone().into();

            // Generate standalone function with two parameters
            let standalone = if !ord_fields.is_empty() {
                let compare_steps: Vec<(Ident, Expr)> = ord_fields
                    .iter()
                    .enumerate()
                    .map(|(i, f)| {
                        let cmp_ident = ts_ident!(format!("cmp{}", i));
                        let resolved = resolved_fields.and_then(|rf| rf.get(&f.name));
                        let expr_src = generate_field_compare_for_interface(
                            f,
                            "a",
                            "b",
                            resolved,
                            type_registry,
                        );
                        let expr = parse_ts_expr(&expr_src).map_err(|err| {
                            MacroforgeError::new(
                                input.decorator_span(),
                                format!(
                                    "@derive(Ord): invalid comparison expression for '{}': {err:?}",
                                    f.name
                                ),
                            )
                        })?;
                        Ok((cmp_ident, *expr))
                    })
                    .collect::<Result<_, MacroforgeError>>()?;

                // Explicitly use compare_steps to satisfy clippy (it's consumed by ts_template! macro)
                let _ = &compare_steps;

                ts_template! {
                    export function @{fn_name_ident}(a: @{class_ident}, b: @{class_ident}): number {
                        if (a === b) return 0;
                        {#for (cmp_ident, cmp_expr) in &compare_steps}
                            const @{cmp_ident.clone()} = @{cmp_expr.clone()};
                            if (@{cmp_ident.clone()} !== 0) return @{cmp_ident.clone()};
                        {/for}
                        return 0;
                    }
                }
            } else {
                ts_template! {
                    export function @{fn_name_ident}(a: @{class_ident}, b: @{class_ident}): number {
                        if (a === b) return 0;
                        return 0;
                    }
                }
            };

            // Generate static wrapper method that delegates to standalone function
            let class_body = ts_template!(Within {
                static compareTo(a: @{class_ident}, b: @{class_ident}): number {
                    return @{fn_name_expr}(a, b);
                }
            });

            // Combine standalone function with class body
            // The standalone output (no marker) must come FIRST so it defaults to "below" (after class)
            Ok(standalone.merge(class_body))
        }
        Data::Enum(_) => {
            let enum_name = input.name();
            let fn_name_ident = ts_ident!("{}Compare", enum_name.to_case(Case::Camel));

            Ok(ts_template! {
                export function @{fn_name_ident}(a: @{ts_ident!(enum_name)}, b: @{ts_ident!(enum_name)}): number {
                    // For enums, compare by value (numeric enums) or string
                    if (typeof a === "number" && typeof b === "number") {
                        return a < b ? -1 : a > b ? 1 : 0;
                    }
                    if (typeof a === "string" && typeof b === "string") {
                        const cmp = a.localeCompare(b);
                        return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
                    }
                    return 0;
                }
            })
        }
        Data::Interface(interface) => {
            let interface_name = input.name();
            let interface_ident = ts_ident!(interface_name);

            let ord_fields: Vec<OrdField> = interface
                .fields()
                .iter()
                .filter_map(|field| {
                    let opts = CompareFieldOptions::from_decorators(&field.decorators, "ord");
                    if opts.skip {
                        return None;
                    }
                    Some(OrdField {
                        name: field.name.clone(),
                        ts_type: field.ts_type.clone(),
                    })
                })
                .collect();

            let fn_name_ident = ts_ident!("{}Compare", interface_name.to_case(Case::Camel));

            if !ord_fields.is_empty() {
                let compare_steps: Vec<(Ident, Expr)> = ord_fields
                    .iter()
                    .enumerate()
                    .map(|(i, f)| {
                        let cmp_ident = ts_ident!(format!("cmp{}", i));
                        let resolved = resolved_fields.and_then(|rf| rf.get(&f.name));
                        let expr_src = generate_field_compare_for_interface(
                            f,
                            "a",
                            "b",
                            resolved,
                            type_registry,
                        );
                        let expr = parse_ts_expr(&expr_src).map_err(|err| {
                            MacroforgeError::new(
                                input.decorator_span(),
                                format!(
                                    "@derive(Ord): invalid comparison expression for '{}': {err:?}",
                                    f.name
                                ),
                            )
                        })?;
                        Ok((cmp_ident, *expr))
                    })
                    .collect::<Result<_, MacroforgeError>>()?;

                // Explicitly use compare_steps to satisfy clippy (it's consumed by ts_template! macro)
                let _ = &compare_steps;

                Ok(ts_template! {
                    export function @{fn_name_ident}(a: @{interface_ident}, b: @{interface_ident}): number {
                        if (a === b) return 0;
                        {#for (cmp_ident, cmp_expr) in &compare_steps}
                            const @{cmp_ident.clone()} = @{cmp_expr.clone()};
                            if (@{cmp_ident.clone()} !== 0) return @{cmp_ident.clone()};
                        {/for}
                        return 0;
                    }
                })
            } else {
                Ok(ts_template! {
                    export function @{fn_name_ident}(a: @{interface_ident}, b: @{interface_ident}): number {
                        if (a === b) return 0;
                        return 0;
                    }
                })
            }
        }
        Data::TypeAlias(type_alias) => {
            let type_name = input.name();
            let type_ident = ts_ident!(type_name);

            if type_alias.is_object() {
                let ord_fields: Vec<OrdField> = type_alias
                    .as_object()
                    .unwrap()
                    .iter()
                    .filter_map(|field| {
                        let opts = CompareFieldOptions::from_decorators(&field.decorators, "ord");
                        if opts.skip {
                            return None;
                        }
                        Some(OrdField {
                            name: field.name.clone(),
                            ts_type: field.ts_type.clone(),
                        })
                    })
                    .collect();

                let fn_name_ident = ts_ident!("{}Compare", type_name.to_case(Case::Camel));

                if !ord_fields.is_empty() {
                    let compare_steps: Vec<(Ident, Expr)> = ord_fields
                        .iter()
                        .enumerate()
                        .map(|(i, f)| {
                            let cmp_ident = ts_ident!(format!("cmp{}", i));
                            let resolved = resolved_fields.and_then(|rf| rf.get(&f.name));
                        let expr_src = generate_field_compare_for_interface(
                            f, "a", "b", resolved, type_registry,
                        );
                            let expr = parse_ts_expr(&expr_src).map_err(|err| {
                                MacroforgeError::new(
                                    input.decorator_span(),
                                    format!(
                                        "@derive(Ord): invalid comparison expression for '{}': {err:?}",
                                        f.name
                                    ),
                                )
                            })?;
                            Ok((cmp_ident, *expr))
                        })
                        .collect::<Result<_, MacroforgeError>>()?;

                    // Explicitly use compare_steps to satisfy clippy (it's consumed by ts_template! macro)
                    let _ = &compare_steps;

                    Ok(ts_template! {
                        export function @{fn_name_ident}(a: @{type_ident}, b: @{type_ident}): number {
                            if (a === b) return 0;
                            {#for (cmp_ident, cmp_expr) in &compare_steps}
                                const @{cmp_ident.clone()} = @{cmp_expr.clone()};
                                if (@{cmp_ident.clone()} !== 0) return @{cmp_ident.clone()};
                            {/for}
                            return 0;
                        }
                    })
                } else {
                    Ok(ts_template! {
                        export function @{fn_name_ident}(a: @{type_ident}, b: @{type_ident}): number {
                            if (a === b) return 0;
                            return 0;
                        }
                    })
                }
            } else {
                // Union, tuple, or simple alias: basic comparison
                let fn_name_ident = ts_ident!("{}Compare", type_name.to_case(Case::Camel));

                Ok(ts_template! {
                    export function @{fn_name_ident}(a: @{type_ident}, b: @{type_ident}): number {
                        if (a === b) return 0;
                        // For unions/tuples, try primitive comparison
                        if (typeof a === "number" && typeof b === "number") {
                            return a < b ? -1 : a > b ? 1 : 0;
                        }
                        if (typeof a === "string" && typeof b === "string") {
                            const cmp = a.localeCompare(b);
                            return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
                        }
                        return 0;
                    }
                })
            }
        }
    }
}

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

    #[test]
    fn test_ord_macro_output() {
        let class_name = "User";
        let class_ident = ts_ident!(class_name);
        let ord_fields: Vec<OrdField> = vec![OrdField {
            name: "id".to_string(),
            ts_type: "number".to_string(),
        }];

        let compare_steps: Vec<(Ident, Expr)> = ord_fields
            .iter()
            .enumerate()
            .map(|(i, f)| {
                let cmp_ident = ts_ident!(format!("cmp{}", i));
                let expr_src = generate_field_compare_for_interface(f, "a", "b", None, None);
                let expr = parse_ts_expr(&expr_src).expect("compare expr should parse");
                (cmp_ident, *expr)
            })
            .collect();

        // Explicitly use compare_steps to satisfy clippy (it's consumed by body! macro)
        let _ = &compare_steps;

        let output = ts_template!(Within {
            compareTo(other: @{class_ident}): number {
                if (a === b) return 0;
                {#for (cmp_ident, cmp_expr) in &compare_steps}
                    const @{cmp_ident.clone()} = @{cmp_expr.clone()};
                    if (@{cmp_ident.clone()} !== 0) return @{cmp_ident.clone()};
                {/for}
                return 0;
            }
        });

        let source = output.source();
        let body_content = source
            .strip_prefix("/* @macroforge:body */")
            .unwrap_or(source);
        let wrapped = format!("class __Temp {{ {} }}", body_content);

        assert!(
            macroforge_ts_syn::parse_ts_stmt(&wrapped).is_ok(),
            "Generated Ord macro output should parse as class members"
        );
        assert!(
            source.contains("compareTo"),
            "Should contain compareTo method"
        );
        // Verify return type doesn't contain null
        assert!(
            !source.contains("number | null"),
            "Should not contain nullable return type"
        );
    }

    #[test]
    fn test_field_compare_number() {
        let field = OrdField {
            name: "id".to_string(),
            ts_type: "number".to_string(),
        };
        let result = generate_field_compare_for_interface(&field, "a", "b", None, None);
        assert!(result.contains("a.id < b.id"));
        assert!(result.contains("a.id > b.id"));
        assert!(!result.contains("null")); // Total ordering - no null
    }

    #[test]
    fn test_field_compare_string() {
        let field = OrdField {
            name: "name".to_string(),
            ts_type: "string".to_string(),
        };
        let result = generate_field_compare_for_interface(&field, "a", "b", None, None);
        assert!(result.contains("localeCompare"));
        // Should clamp localeCompare result to -1, 0, 1
        assert!(result.contains("-1"));
        assert!(result.contains("1"));
    }

    #[test]
    fn test_field_compare_object_no_null() {
        let field = OrdField {
            name: "user".to_string(),
            ts_type: "User".to_string(),
        };
        let result = generate_field_compare_for_interface(&field, "a", "b", None, None);
        assert!(result.contains("compareTo"));
        // Should fallback to 0 instead of null
        assert!(result.contains("?? 0"));
    }
}