alef 0.20.4

//! Swift trait bridge codegen for outbound plugins.
//!
//! For each configured `TraitBridgeConfig` entry (when `bind_via = "function_param"`),
//! generates:
//!
//! 1. A Swift `protocol Swift<TraitName>Bridge` declaring the trait methods with
//!    async/throws matching the Rust trait method signatures. Excluded/internal types
//!    are marshalled as JSON strings at the boundary.
//! 2. A Swift `struct Swift<TraitName>Adapter` wrapping an instance of the protocol
//!    and exposing methods that handle marshalling (conversion from/to JSON for excluded types,
//!    conversion from/to proper Swift types for visible types).
//! 3. A `register<TraitName>(_ bridge: Swift<TraitName>Bridge)` function that
//!    constructs the adapter and calls into Rust to register it.

use crate::backends::swift::naming::bridge_protocol_name;
use crate::core::config::TraitBridgeConfig;
use crate::core::ir::{TypeDef, TypeRef};
use heck::{ToLowerCamelCase, ToSnakeCase};
use std::collections::HashSet;

/// Generate Swift trait bridge protocol and adapter for outbound plugins.
///
/// `exclude_types` is the set of types that are not visible in the generated Swift binding.
/// These types are marshalled as JSON strings at the trait boundary.
///
/// Returns a list of (filename, content) tuples ready for emission.
pub fn gen_trait_bridge_files(
    bridges: &[(String, &TraitBridgeConfig, &TypeDef)],
    exclude_types: &HashSet<String>,
) -> Vec<(String, String)> {
    let mut files = Vec::new();

    for (trait_name, bridge_cfg, trait_def) in bridges {
        // Skip if swift is in exclude_languages
        if bridge_cfg.exclude_languages.iter().any(|lang| lang == "swift") {
            continue;
        }

        // Skip if not function_param binding (only outbound plugins use this codegen)
        if !matches!(bridge_cfg.bind_via, crate::core::config::BridgeBinding::FunctionParam) {
            continue;
        }

        let content = gen_single_trait_bridge_file(trait_name, bridge_cfg, trait_def, exclude_types);
        // Use the canonical protocol name as the filename base so the filename
        // stays in sync with the protocol declaration.
        let protocol = bridge_protocol_name(trait_name);
        let filename = format!("{protocol}.swift");
        files.push((filename, content));
    }

    files
}

/// Generate Swift trait bridge code for a single trait.
///
/// `exclude_types` contains type names that are not visible in the Swift binding surface.
/// These types are marshalled as JSON strings at trait boundaries.
fn gen_single_trait_bridge_file(
    trait_name: &str,
    _bridge_cfg: &TraitBridgeConfig,
    trait_def: &TypeDef,
    exclude_types: &HashSet<String>,
) -> String {
    let mut out = String::new();

    // Header
    out.push_str("// Generated by alef. Do not edit by hand.\n");
    out.push_str("// swift-format-ignore-file\n");
    out.push_str("// This file contains generated FFI glue for trait bridge registration.\n\n");
    out.push_str("import Foundation\n");
    out.push_str("import RustBridge\n\n");

    // MARK: Protocol Declaration
    let protocol = bridge_protocol_name(trait_name);
    out.push_str(&format!(
        "/// Protocol for outbound `{trait_name}` implementations.\n\
         /// Conform your Swift class or struct to this protocol to implement\n\
         /// a Rust trait from the host side.\n\
         public protocol {protocol}: AnyObject {{\n"
    ));

    for method in &trait_def.methods {
        if method.has_default_impl {
            continue;
        }

        let method_camel = method.name.to_lower_camel_case();
        // Build params, marshalling excluded types as JSON (String)
        let params_sig = swift_method_params(&method.params, exclude_types);
        // Build return type, marshalling excluded types as JSON (String)
        let return_type = swift_return_type(&method.return_type, exclude_types);
        let throws = if method.error_type.is_some() { " throws" } else { "" };
        let async_kw = if method.is_async { " async" } else { "" };

        out.push_str(&format!(
            "    func {method_camel}({params_sig}){async_kw}{throws} -> {return_type}\n"
        ));
    }

    out.push_str("}\n\n");

    // MARK: Adapter Class
    out.push_str(&format!(
        "/// Internal adapter wrapping a `{protocol}` conformer.\n\
         /// Marshals Swift types and trait calls to/from the C boundary.\n\
         /// Excluded/internal types are serialised to/from JSON strings.\n\
         final class Swift{trait_name}Adapter {{\n\
         \x20   private let bridge: any {protocol}\n\n"
    ));

    // Constructor
    out.push_str(&format!(
        "    init(bridge: any {protocol}) {{\n\
         \x20\x20\x20\x20self.bridge = bridge\n\
         \x20   }}\n\n"
    ));

    // Method entry points — these marshal types across the boundary
    for method in &trait_def.methods {
        if method.has_default_impl {
            continue;
        }

        let method_camel = method.name.to_lower_camel_case();
        // Build parameter signature for the adapter method (input from Rust across the boundary)
        let params_sig = swift_method_params(&method.params, exclude_types);
        // Build return type for the adapter method (output back to Rust)
        // If the method has an error type, the adapter returns String (JSON envelope);
        // otherwise, it returns the original type
        let return_type = if method.error_type.is_some() {
            "String".to_string()
        } else {
            swift_return_type(&method.return_type, exclude_types)
        };

        // Build async/throws keywords for the adapter method signature
        let async_kw = if method.is_async { " async" } else { "" };
        let throws_kw = if method.error_type.is_some() { " throws" } else { "" };

        out.push_str(&format!(
            "    func {method_camel}Call({params_sig}){async_kw}{throws_kw} -> {return_type} {{\n"
        ));

        // Generate method body: construct call arguments and handle return value.
        let call_args = build_adapter_call_args(method);
        let call_args_str = call_args.join(", ");

        if method.error_type.is_some() {
            // Error-returning method: wrap result in try-catch and return JSON envelope
            // Swift requires 'try await' order (not 'await try')
            let try_await = if method.is_async { "try await " } else { "try " };
            out.push_str(&format!(
                "        do {{\n\
                 \x20\x20\x20\x20\x20\x20\x20\x20let result = {try_await}self.bridge.{method_camel}({call_args_str})\n"
            ));
            // Special case: if return type is Void, don't try to marshal it
            if matches!(method.return_type, TypeRef::Unit) {
                out.push_str(
                    "            return marshal_ok_result(Empty())\n\
                     \x20\x20\x20\x20} catch {\n\
                     \x20\x20\x20\x20\x20\x20\x20\x20return marshal_error_result(error)\n\
                     \x20\x20\x20\x20}\n",
                );
            } else {
                // For error-returning methods, JSON-encode the result
                let encoded_result = match &method.return_type {
                    TypeRef::String => "result".to_string(),
                    TypeRef::Unit => "Empty()".to_string(),
                    TypeRef::Primitive(_) | TypeRef::Bytes | TypeRef::Char => "result".to_string(),
                    _ => "try JSONEncoder().encode(result)".to_string(),
                };
                out.push_str(&format!(
                    "            return marshal_ok_result({encoded_result})\n\
                     \x20\x20\x20\x20}} catch {{\n\
                     \x20\x20\x20\x20\x20\x20\x20\x20return marshal_error_result(error)\n\
                     \x20\x20\x20\x20}}\n"
                ));
            }
        } else if method.is_async {
            // Async method without error: return the result directly, no encoding
            out.push_str(&format!(
                "        let result = await self.bridge.{method_camel}({call_args_str})\n"
            ));
            out.push_str("        return result\n");
        } else {
            // Sync method without error: return the result directly, no encoding
            out.push_str(&format!(
                "        let result = self.bridge.{method_camel}({call_args_str})\n"
            ));
            out.push_str("        return result\n");
        }

        out.push_str("    }\n\n");
    }

    out.push_str("}\n\n");

    // MARK: Helper functions for marshalling
    out.push_str("// MARK: - Marshalling helpers\n\n");
    out.push_str(
        "private struct Empty: Codable {}\n\n\
         private func marshal_ok_result<T: Encodable>(_ value: T) -> String {\n\
         \x20\x20\x20\x20let encoder = JSONEncoder()\n\
         \x20\x20\x20\x20if let data = try? encoder.encode(value),\n\
         \x20\x20\x20\x20   let jsonString = String(data: data, encoding: .utf8) {\n\
         \x20\x20\x20\x20\x20\x20\x20\x20return \"{\\\"ok\\\": \\(jsonString)}\"\n\
         \x20\x20\x20\x20}\n\
         \x20\x20\x20\x20return \"{\\\"ok\\\": null}\"\n\
         }\n\n\
         private func marshal_error_result(_ error: any Error) -> String {\n\
         \x20\x20\x20\x20let errorString = String(describing: error)\n\
         \x20\x20\x20\x20let encoder = JSONEncoder()\n\
         \x20\x20\x20\x20if let data = try? encoder.encode(errorString),\n\
         \x20\x20\x20\x20   let jsonString = String(data: data, encoding: .utf8) {\n\
         \x20\x20\x20\x20\x20\x20\x20\x20return \"{\\\"err\\\": \\(jsonString)}\"\n\
         \x20\x20\x20\x20}\n\
         \x20\x20\x20\x20return \"{\\\"err\\\": \\\"unknown error\\\"}\"\n\
         }\n\n",
    );

    // NOTE: Registration functions are NOT emitted here. They live in <Binding>.swift
    // (generated by `emit_trait_bridge_forwarders`) and accept the Box-based type
    // (`Swift{Trait}Box`) from `Sources/RustBridge/Plugins.swift` that the RustBridge
    // `register_*` entry point actually expects. Emitting a duplicate here that passes
    // `Swift{Trait}Adapter` would cause a type mismatch at the `try RustBridge.{camel}(adapter)`
    // call site because Adapter and Box are distinct, incompatible types.

    out
}

/// Emit Swift method parameter signature from MethodDef params.
///
/// Excluded types (not in the visible binding surface) are marshalled as JSON strings.
fn swift_method_params(params: &[crate::core::ir::ParamDef], exclude_types: &HashSet<String>) -> String {
    if params.is_empty() {
        return String::new();
    }

    params
        .iter()
        .map(|p| {
            let name = p.name.to_snake_case();
            let ty = swift_type_name(&p.ty, exclude_types);
            format!("{}: {}", name, ty)
        })
        .collect::<Vec<_>>()
        .join(", ")
}

/// Get the Swift type name for a TypeRef.
///
/// Excluded/internal types (not in the visible binding surface) are marshalled as JSON strings.
fn swift_type_name(ty: &TypeRef, exclude_types: &HashSet<String>) -> String {
    match ty {
        TypeRef::Primitive(p) => match p {
            crate::core::ir::PrimitiveType::Bool => "Bool".to_string(),
            crate::core::ir::PrimitiveType::I8 => "Int8".to_string(),
            crate::core::ir::PrimitiveType::I16 => "Int16".to_string(),
            crate::core::ir::PrimitiveType::I32 => "Int32".to_string(),
            crate::core::ir::PrimitiveType::I64 => "Int64".to_string(),
            crate::core::ir::PrimitiveType::U8 => "UInt8".to_string(),
            crate::core::ir::PrimitiveType::U16 => "UInt16".to_string(),
            crate::core::ir::PrimitiveType::U32 => "UInt32".to_string(),
            crate::core::ir::PrimitiveType::U64 => "UInt64".to_string(),
            crate::core::ir::PrimitiveType::Usize => "Int".to_string(), // Maps to platform-dependent size
            crate::core::ir::PrimitiveType::Isize => "Int".to_string(), // Maps to platform-dependent size
            crate::core::ir::PrimitiveType::F32 => "Float".to_string(),
            crate::core::ir::PrimitiveType::F64 => "Double".to_string(),
        },
        TypeRef::String => "String".to_string(),
        TypeRef::Bytes => "Data".to_string(),
        TypeRef::Path => "URL".to_string(),
        TypeRef::Char => "Character".to_string(),
        TypeRef::Named(name) => {
            // If the named type is excluded (internal/not visible), marshal as JSON string
            if exclude_types.contains(name) {
                "String".to_string() // JSON-marshalled as String
            } else {
                name.clone()
            }
        }
        TypeRef::Vec(inner) => format!("[{}]", swift_type_name(inner, exclude_types)),
        TypeRef::Map(k, v) => format!(
            "[{}: {}]",
            swift_type_name(k, exclude_types),
            swift_type_name(v, exclude_types)
        ),
        TypeRef::Optional(inner) => format!("{}?", swift_type_name(inner, exclude_types)),
        TypeRef::Unit => "Void".to_string(),
        TypeRef::Json => "String".to_string(), // JSON is marshalled as String
        TypeRef::Duration => "TimeInterval".to_string(), // Duration -> TimeInterval in Swift
    }
}

/// Emit Swift return type from TypeRef.
fn swift_return_type(ty: &TypeRef, exclude_types: &HashSet<String>) -> String {
    swift_type_name(ty, exclude_types)
}

/// Build the call arguments for the adapter method with Swift argument labels.
///
/// Swift requires explicit labels for all method arguments.
fn build_adapter_call_args(method: &crate::core::ir::MethodDef) -> Vec<String> {
    method
        .params
        .iter()
        .map(|p| {
            let name = p.name.to_snake_case();
            format!("{}: {}", name, name)
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::config::BridgeBinding;

    fn make_trait_def(name: &str) -> TypeDef {
        TypeDef {
            name: name.to_string(),
            rust_path: format!("testcrate::{}", name),
            original_rust_path: String::new(),
            fields: vec![],
            methods: vec![],
            is_opaque: false,
            is_clone: true,
            is_copy: false,
            is_trait: true,
            has_default: false,
            has_stripped_cfg_fields: false,
            is_return_type: false,
            serde_rename_all: None,
            has_serde: false,
            super_traits: vec![],
            doc: String::new(),
            cfg: None,
            binding_excluded: false,
            binding_exclusion_reason: None,
        }
    }

    fn make_bridge_cfg(trait_name: &str) -> TraitBridgeConfig {
        TraitBridgeConfig {
            trait_name: trait_name.to_string(),
            param_name: None,
            type_alias: None,
            exclude_languages: vec![],
            super_trait: None,
            registry_getter: None,
            register_fn: Some(format!("register{}", trait_name)),
            unregister_fn: None,
            clear_fn: None,
            register_extra_args: None,
            bind_via: BridgeBinding::FunctionParam,
            options_type: None,
            options_field: None,
            context_type: None,
            result_type: None,
            ffi_skip_methods: Vec::new(),
        }
    }

    #[test]
    fn test_trait_bridge_protocol_generated() {
        let trait_def = make_trait_def("OcrBackend");
        let bridge_cfg = make_bridge_cfg("OcrBackend");
        let bridges = vec![("OcrBackend".to_string(), &bridge_cfg, &trait_def)];
        let exclude_types = HashSet::new();
        let files = gen_trait_bridge_files(&bridges, &exclude_types);

        assert_eq!(files.len(), 1);
        assert_eq!(files[0].0, "SwiftOcrBackendBridge.swift");
        assert!(files[0].1.contains("protocol SwiftOcrBackendBridge"));
    }

    #[test]
    fn test_trait_bridge_excludes_swift_language() {
        let trait_def = make_trait_def("OcrBackend");
        let mut bridge_cfg = make_bridge_cfg("OcrBackend");
        bridge_cfg.exclude_languages = vec!["swift".to_string()];
        let bridges = vec![("OcrBackend".to_string(), &bridge_cfg, &trait_def)];
        let exclude_types = HashSet::new();
        let files = gen_trait_bridge_files(&bridges, &exclude_types);

        assert!(files.is_empty());
    }

    #[test]
    fn test_trait_bridge_skips_non_function_param() {
        let trait_def = make_trait_def("OcrBackend");
        let mut bridge_cfg = make_bridge_cfg("OcrBackend");
        bridge_cfg.bind_via = BridgeBinding::OptionsField;
        let bridges = vec![("OcrBackend".to_string(), &bridge_cfg, &trait_def)];
        let exclude_types = HashSet::new();
        let files = gen_trait_bridge_files(&bridges, &exclude_types);

        assert!(files.is_empty());
    }

    #[test]
    fn test_swift_type_mapping() {
        use crate::core::ir::PrimitiveType;
        let exclude_types = HashSet::new();
        assert_eq!(swift_type_name(&TypeRef::String, &exclude_types), "String");
        assert_eq!(swift_type_name(&TypeRef::Bytes, &exclude_types), "Data");
        assert_eq!(swift_type_name(&TypeRef::Unit, &exclude_types), "Void");
        assert_eq!(
            swift_type_name(&TypeRef::Primitive(PrimitiveType::I32), &exclude_types),
            "Int32"
        );
        assert_eq!(swift_type_name(&TypeRef::Duration, &exclude_types), "TimeInterval");
    }

    #[test]
    fn test_swift_marshals_excluded_types_as_json() {
        let mut exclude_types = HashSet::new();
        exclude_types.insert("InternalDocument".to_string());
        assert_eq!(
            swift_type_name(&TypeRef::Named("InternalDocument".to_string()), &exclude_types),
            "String",
            "Excluded types should be marshalled as JSON strings"
        );
        assert_eq!(
            swift_type_name(&TypeRef::Named("ExtractionResult".to_string()), &exclude_types),
            "ExtractionResult",
            "Non-excluded types should keep their original names"
        );
    }

    /// Verify that gen_single_trait_bridge_file does NOT emit a `public func register*`
    /// function. Registration is handled by `emit_trait_bridge_forwarders` in `<Binding>.swift`
    /// which uses the Box-based type (`SwiftDocumentExtractorBox`) that the RustBridge
    /// `register_*` entry point actually expects. A duplicate here would pass the
    /// incompatible `Adapter` type, causing a compile error.
    #[test]
    fn test_no_register_fn_in_trait_bridge_file() {
        let trait_def = make_trait_def("DocumentExtractor");
        let bridge_cfg = make_bridge_cfg("DocumentExtractor");
        let bridges = vec![("DocumentExtractor".to_string(), &bridge_cfg, &trait_def)];
        let exclude_types = HashSet::new();
        let files = gen_trait_bridge_files(&bridges, &exclude_types);

        assert_eq!(files.len(), 1);
        let content = &files[0].1;

        // The protocol and adapter must still be emitted.
        assert!(
            content.contains("protocol SwiftDocumentExtractorBridge"),
            "protocol must be emitted, got:\n{content}"
        );
        assert!(
            content.contains("final class SwiftDocumentExtractorAdapter"),
            "adapter class must be emitted, got:\n{content}"
        );

        // A register function must NOT be emitted — it is emitted by emit_trait_bridge_forwarders
        // in <Binding>.swift and uses SwiftDocumentExtractorBox (not Adapter).
        assert!(
            !content.contains("public func registerDocumentExtractor("),
            "register function must NOT be emitted in the bridge file (would use wrong Adapter type), got:\n{content}"
        );
    }

    /// Verify that when an excluded type (e.g. InternalDocument) appears in a trait method
    /// signature, the generated protocol and adapter use `String` (JSON marshalling) rather
    /// than the non-existent Swift type `InternalDocument`.
    #[test]
    fn test_excluded_type_in_method_becomes_string() {
        use crate::core::ir::{MethodDef, ParamDef, ReceiverKind};

        let mut trait_def = make_trait_def("DocumentExtractor");
        // Add a method with InternalDocument as return type.
        trait_def.methods.push(MethodDef {
            name: "extract_bytes".to_string(),
            params: vec![ParamDef {
                name: "content".to_string(),
                ty: TypeRef::Bytes,
                optional: false,
                default: None,
                sanitized: false,
                typed_default: None,
                is_ref: false,
                is_mut: false,
                newtype_wrapper: None,
                original_type: None,
                map_is_ahash: false,
                map_key_is_cow: false,
            }],
            return_type: TypeRef::Named("InternalDocument".to_string()),
            is_async: false,
            is_static: false,
            error_type: Some("Error".to_string()),
            doc: String::new(),
            receiver: Some(ReceiverKind::Ref),
            sanitized: false,
            trait_source: None,
            returns_ref: false,
            returns_cow: false,
            return_newtype_wrapper: None,
            has_default_impl: false,
            binding_excluded: false,
            binding_exclusion_reason: None,
        });

        let bridge_cfg = make_bridge_cfg("DocumentExtractor");
        let bridges = vec![("DocumentExtractor".to_string(), &bridge_cfg, &trait_def)];

        // Pass InternalDocument in exclude_types (mimicking what mod.rs does when
        // it augments from IR binding_excluded types).
        let mut exclude_types = HashSet::new();
        exclude_types.insert("InternalDocument".to_string());

        let files = gen_trait_bridge_files(&bridges, &exclude_types);
        assert_eq!(files.len(), 1);
        let content = &files[0].1;

        // Return type must be String, not InternalDocument.
        assert!(
            content.contains("-> String"),
            "excluded return type InternalDocument must map to String in protocol, got:\n{content}"
        );
        assert!(
            !content.contains("InternalDocument"),
            "excluded type InternalDocument must not appear in the generated Swift code, got:\n{content}"
        );
    }
}