olai-codegen 0.0.1

//! Type conversion utilities for code generation
//!
//! This module provides utilities for converting between protobuf types and Rust types
//! during code generation.

use convert_case::{Case, Casing};
use proc_macro2::TokenStream;
use quote::quote;

use crate::utils::extract_simple_type_name;

/// Context for rendering types in different situations
#[derive(Debug, Clone, Copy)]
pub enum RenderContext {
    /// A constructor (new method) in Rust
    Constructor,
    /// when extracting from a request inside implementations of FromRequest or FromRequestParts
    /// (path params: renders enum as i32 for direct axum::extract::Path deserialization)
    Extractor,
    /// when building the QueryParams serde struct for query string deserialization
    /// (renders enum as its actual Rust type so serde can deserialize from string variant names)
    QueryExtractor,
    /// Regular parameter type
    Parameter,
    /// Return type
    ReturnType,
    /// Field type in a struct
    FieldType,
    /// Builder method parameter
    BuilderMethod,
    /// Python parameter type (Rust FFI signatures for PyO3 bindings)
    PythonParameter,
    /// NAPI parameter type (Rust NAPI function signatures for Node.js bindings)
    NapiParameter,
}

/// Trait for rendering a [`UnifiedType`] into a language-specific string.
///
/// Each language backend provides a concrete impl. The four existing free functions
/// (`unified_to_rust`, `unified_to_python_type`, `unified_to_napi`, `unified_to_typescript`)
/// are kept as thin wrappers so call-sites don't change.
pub trait TypeRenderer {
    fn render(&self, ty: &UnifiedType) -> String;
}

/// Rust type renderer — handles optional `impl Into<>` / `Option<>` wrapping.
pub struct RustRenderer(pub RenderContext);

impl TypeRenderer for RustRenderer {
    fn render(&self, ty: &UnifiedType) -> String {
        unified_to_rust(ty, self.0)
    }
}

/// Python type annotation renderer.
pub struct PythonRenderer;

impl TypeRenderer for PythonRenderer {
    fn render(&self, ty: &UnifiedType) -> String {
        unified_to_python_type(ty)
    }
}

/// Rust NAPI parameter type renderer.
pub struct NapiRenderer;

impl TypeRenderer for NapiRenderer {
    fn render(&self, ty: &UnifiedType) -> String {
        unified_to_napi(ty)
    }
}

/// TypeScript type annotation renderer.
pub struct TypeScriptRenderer;

impl TypeRenderer for TypeScriptRenderer {
    fn render(&self, ty: &UnifiedType) -> String {
        unified_to_typescript(ty)
    }
}

/// Convert a unified type to a Rust type string
pub fn unified_to_rust(unified_type: &UnifiedType, context: RenderContext) -> String {
    let base_type_str = match &unified_type.base_type {
        BaseType::String => {
            if matches!(context, RenderContext::Constructor) && !unified_type.is_optional {
                "impl Into<String>".to_string()
            } else {
                "String".to_string()
            }
        }
        BaseType::Int32 => "i32".to_string(),
        BaseType::Int64 => "i64".to_string(),
        BaseType::Bool => "bool".to_string(),
        BaseType::Float64 => "f64".to_string(),
        BaseType::Float32 => "f32".to_string(),
        BaseType::Bytes => "Vec<u8>".to_string(),
        BaseType::Unit => "()".to_string(),
        BaseType::Message(name) => extract_simple_type_name(name),
        BaseType::Enum(name) => {
            if matches!(
                context,
                RenderContext::Extractor | RenderContext::NapiParameter
            ) {
                "i32".to_string()
            } else {
                convert_protobuf_enum_to_rust_type(&format!("TYPE_ENUM:{}", name))
            }
        }
        BaseType::OneOf(name) => extract_simple_type_name(name),
        BaseType::Map(key_type, value_type) => {
            if matches!(context, RenderContext::Constructor) && !unified_type.is_optional {
                "impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>".to_string()
            } else {
                let key_str = unified_to_rust(key_type, context);
                let value_str = unified_to_rust(value_type, context);
                format!("HashMap<{}, {}>", key_str, value_str)
            }
        }
    };

    let mut result = base_type_str;

    // In builder methods we require the inner type only.
    if unified_type.is_repeated && !matches!(context, RenderContext::BuilderMethod) {
        result = format!("Vec<{}>", result);
    }

    if should_wrap_in_option(context, unified_type) {
        result = format!("Option<{}>", result);
    }

    result
}

/// Return `true` when the Rust representation of `ty` in `ctx` should be wrapped in `Option<T>`.
///
/// Two independent conditions trigger wrapping:
///
/// 1. **Optional field outside a builder method** — builder methods use `impl Into<Option<T>>`
///    for their parameter type and leave the inner `Option<T>` implicit, so wrapping is skipped
///    in that context.
///
/// 2. **FFI boundaries (Python / NAPI) with maps or repeated fields** — at FFI boundaries we
///    distinguish "field absent" from "field is an empty collection" by wrapping maps and
///    repeated fields in `Option<T>`, even when the field is not marked optional in proto.
fn should_wrap_in_option(ctx: RenderContext, ty: &UnifiedType) -> bool {
    let is_optional_non_builder = ty.is_optional && !matches!(ctx, RenderContext::BuilderMethod);
    let is_ffi_collection = matches!(
        ctx,
        RenderContext::PythonParameter | RenderContext::NapiParameter
    ) && (matches!(ty.base_type, BaseType::Map(_, _)) || ty.is_repeated);
    is_optional_non_builder || is_ffi_collection
}

/// Generate field assignment code
pub fn field_assignment(
    unified_type: &UnifiedType,
    field_ident: &proc_macro2::Ident,
    ctx: &RenderContext,
) -> TokenStream {
    if matches!(ctx, RenderContext::BuilderMethod) {
        return flexible_optional_field_assignment(unified_type, field_ident);
    }
    match &unified_type.base_type {
        BaseType::String if !unified_type.is_optional => quote! { #field_ident.into() },
        BaseType::Enum(_) => {
            if unified_type.is_repeated {
                quote! { #field_ident.into_iter().map(|v| v as i32).collect() }
            } else {
                quote! { #field_ident as i32 }
            }
        }
        BaseType::Map(_, _) => quote! {
            #field_ident.into_iter().map(|(k, v)| (k.into(), v.into())).collect()
        },
        _ => quote! { #field_ident },
    }
}

/// Convert a unified type to a Python type annotation string
pub fn unified_to_python_type(unified_type: &UnifiedType) -> String {
    let base_type_str = match &unified_type.base_type {
        BaseType::String => "str".to_string(),
        BaseType::Int32 | BaseType::Int64 => "int".to_string(),
        BaseType::Bool => "bool".to_string(),
        BaseType::Float64 | BaseType::Float32 => "float".to_string(),
        BaseType::Bytes => "bytes".to_string(),
        BaseType::Unit => "None".to_string(),
        BaseType::Message(name) => extract_simple_type_name(name),
        BaseType::Enum(name) => extract_simple_type_name(name),
        BaseType::OneOf(name) => extract_simple_type_name(name),
        BaseType::Map(key_type, value_type) => {
            let key_str = unified_to_python_type(key_type);
            let value_str = unified_to_python_type(value_type);
            format!("Dict[{}, {}]", key_str, value_str)
        }
    };

    let mut result = base_type_str;

    if unified_type.is_repeated {
        result = format!("List[{}]", result);
    }

    if unified_type.is_optional {
        result = format!("Optional[{}]", result);
    }

    result
}

/// Convert a unified type to a Rust NAPI parameter type string.
///
/// NAPI requires concrete types (no `impl Into<>`). Optional fields
/// become `Option<T>`, maps become `Option<HashMap<K, V>>`.
pub fn unified_to_napi(unified_type: &UnifiedType) -> String {
    let base_type_str = match &unified_type.base_type {
        BaseType::String => "String".to_string(),
        BaseType::Int32 => "i32".to_string(),
        BaseType::Int64 => "i64".to_string(),
        BaseType::Bool => "bool".to_string(),
        BaseType::Float64 => "f64".to_string(),
        BaseType::Float32 => "f32".to_string(),
        BaseType::Bytes => "Vec<u8>".to_string(),
        BaseType::Unit => "()".to_string(),
        BaseType::Message(name) => extract_simple_type_name(name),
        BaseType::Enum(name) => convert_protobuf_enum_to_rust_type(&format!("TYPE_ENUM:{}", name)),
        BaseType::OneOf(name) => extract_simple_type_name(name),
        BaseType::Map(key_type, value_type) => {
            let key_str = unified_to_napi(key_type);
            let value_str = unified_to_napi(value_type);
            format!("HashMap<{}, {}>", key_str, value_str)
        }
    };

    let mut result = base_type_str;

    if unified_type.is_repeated {
        result = format!("Vec<{}>", result);
    }

    if unified_type.is_optional
        || matches!(unified_type.base_type, BaseType::Map(_, _))
        || unified_type.is_repeated
    {
        result = format!("Option<{}>", result);
    }

    result
}

/// Convert a unified type to a TypeScript type annotation string.
///
/// Enums are mapped to `number` since they cross the NAPI boundary as `i32`.
pub fn unified_to_typescript(unified_type: &UnifiedType) -> String {
    let base_type_str = match &unified_type.base_type {
        BaseType::String => "string".to_string(),
        BaseType::Int32 | BaseType::Int64 => "number".to_string(),
        BaseType::Bool => "boolean".to_string(),
        BaseType::Float64 | BaseType::Float32 => "number".to_string(),
        BaseType::Bytes => "Uint8Array".to_string(),
        BaseType::Unit => "void".to_string(),
        BaseType::Message(name) => extract_simple_type_name(name),
        BaseType::Enum(_) => "number".to_string(),
        BaseType::OneOf(name) => extract_simple_type_name(name),
        BaseType::Map(key_type, value_type) => {
            let key_str = unified_to_typescript(key_type);
            let value_str = unified_to_typescript(value_type);
            format!("Record<{}, {}>", key_str, value_str)
        }
    };

    let mut result = base_type_str;

    if unified_type.is_repeated {
        result = format!("{}[]", result);
    }

    if unified_type.is_optional {
        result = format!("{} | undefined", result);
    }

    result
}

fn flexible_optional_field_assignment(
    unified_type: &UnifiedType,
    field_ident: &proc_macro2::Ident,
) -> TokenStream {
    if unified_type.is_optional {
        match &unified_type.base_type {
            BaseType::Enum(_) => quote! { #field_ident.into().map(|e| e as i32) },
            _ => quote! { #field_ident.into() },
        }
    } else {
        match &unified_type.base_type {
            BaseType::String => quote! { #field_ident.into() },
            BaseType::Int32
            | BaseType::Int64
            | BaseType::Bool
            | BaseType::Float64
            | BaseType::Float32 => {
                quote! { #field_ident.into() }
            }
            BaseType::Enum(_) => {
                quote! { #field_ident as i32 }
            }
            // Message, OneOf, and Map types are always handled by their own
            // dedicated branches in `builder_with_impl` and never reach this path.
            _ => quote! { #field_ident },
        }
    }
}

/// Convert protobuf enum type to Rust type
///
/// # FIXME: Fragile heuristic for nested vs package-level enums
///
/// This function guesses whether an enum is nested inside a message (e.g.
/// `example.Catalog.Status`) or defined at package level (e.g.
/// `example.catalog.v1.CatalogType`) by inspecting the casing of the last
/// path segment before the enum name.  The special-case for `"V1"` and the
/// all-lowercase check are workarounds for common proto package naming
/// conventions, not a principled solution.
///
/// The correct fix (Phase 3): accept a `package_prefix: &str` parameter so
/// callers can strip the known package prefix and always identify the boundary
/// between package segments and message/enum names deterministically.
fn convert_protobuf_enum_to_rust_type(proto_type: &str) -> String {
    if let Some(enum_name) = proto_type.strip_prefix("TYPE_ENUM:") {
        // Remove leading dot if present
        let enum_name = enum_name.trim_start_matches('.');

        // Check if this is a nested enum (has a parent message)
        // Nested enums have PascalCase message names before the enum name
        if let Some(last_dot) = enum_name.rfind('.') {
            let parent_part = &enum_name[..last_dot];
            let enum_simple_name = &enum_name[last_dot + 1..];

            // Check if the parent part ends with a PascalCase message name (nested enum)
            // vs. a package name like "v1" (package-level enum)
            let parent_parts: Vec<&str> = parent_part.split('.').collect();
            if let Some(last_part) = parent_parts.last() {
                // If the last part starts with uppercase, it's likely a message name (nested enum)
                // If it's "v1" or similar version, it's a package-level enum
                if last_part.chars().next().is_some_and(|c| c.is_uppercase())
                    && *last_part != "V1"
                    && !last_part
                        .chars()
                        .all(|c| c.is_lowercase() || c.is_numeric())
                {
                    // This is a nested enum - convert parent message to snake_case module
                    let snake_case_module = last_part.to_case(Case::Snake);

                    // Convert enum name from UPPER_SNAKE_CASE to PascalCase if needed
                    let enum_rust_name = if enum_simple_name.contains('_')
                        && enum_simple_name
                            .chars()
                            .all(|c| c.is_uppercase() || c == '_')
                    {
                        enum_simple_name.to_case(Case::Pascal)
                    } else {
                        enum_simple_name.to_string()
                    };

                    format!("{}::{}", snake_case_module, enum_rust_name)
                } else {
                    // This is a package-level enum - just use the simple name
                    convert_enum_name_to_rust(enum_simple_name)
                }
            } else {
                // Fallback to simple enum name
                convert_enum_name_to_rust(enum_simple_name)
            }
        } else {
            // Simple enum name without dots
            convert_enum_name_to_rust(enum_name)
        }
    } else {
        "i32".to_string() // Fallback for unknown enum types
    }
}

/// Convert enum name from proto format to Rust format
fn convert_enum_name_to_rust(enum_name: &str) -> String {
    // Convert from proto naming to Rust naming if needed
    if enum_name.contains('_') && enum_name.chars().all(|c| c.is_uppercase() || c == '_') {
        enum_name.to_case(Case::Pascal)
    } else {
        enum_name.to_string()
    }
}

/// Unified type representation that can be converted to different target languages
#[derive(Debug, Clone)]
pub struct UnifiedType {
    /// The base type
    pub base_type: BaseType,
    /// Whether this type is optional (Option<T> in Rust)
    pub is_optional: bool,
    /// Whether this type is repeated (Vec<T> in Rust)
    pub is_repeated: bool,
}

/// Base type categories that can be converted to specific language types
#[derive(Debug, Clone)]
pub enum BaseType {
    /// String type
    String,
    /// 32-bit integer
    Int32,
    /// 64-bit integer
    Int64,
    /// Boolean
    Bool,
    /// 64-bit float
    Float64,
    /// 32-bit float
    Float32,
    /// Byte array
    Bytes,
    /// Protobuf message type
    Message(String),
    /// Protobuf enum type
    Enum(String),
    /// Protobuf oneof type
    OneOf(String),
    /// Map type with key and value types
    Map(Box<UnifiedType>, Box<UnifiedType>),
    /// Unit/void type
    Unit,
}

impl UnifiedType {
    /// Extract a syn::Ident for the inner type name (last segment of a qualified name).
    pub fn type_ident(&self) -> syn::Ident {
        let name = match &self.base_type {
            BaseType::Message(n) | BaseType::Enum(n) | BaseType::OneOf(n) => {
                n.split('.').next_back().unwrap_or(n)
            }
            BaseType::String => "String",
            BaseType::Int32 => "i32",
            BaseType::Int64 => "i64",
            BaseType::Bool => "bool",
            BaseType::Float64 => "f64",
            BaseType::Float32 => "f32",
            BaseType::Bytes => "Bytes",
            BaseType::Unit => "()",
            BaseType::Map(_, _) => "HashMap",
        };
        quote::format_ident!("{}", name)
    }

    /// Create a simple string type
    pub fn string() -> Self {
        Self {
            base_type: BaseType::String,
            is_optional: false,
            is_repeated: false,
        }
    }

    /// Create an optional version of this type
    pub fn optional(mut self) -> Self {
        self.is_optional = true;
        self
    }

    /// Create a repeated version of this type
    pub fn repeated(mut self) -> Self {
        self.is_repeated = true;
        self
    }

    /// Create a map type
    pub fn map(key: UnifiedType, value: UnifiedType) -> Self {
        Self {
            base_type: BaseType::Map(Box::new(key), Box::new(value)),
            is_optional: false,
            is_repeated: false,
        }
    }
}