to-ts-macros 0.1.9

extern crate proc_macro;

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Item, Fields, Attribute, parse_quote};

/// 从 doc 注释中提取键值对
/// 格式: /// label = "低优先级", icon = "🔵"
fn parse_doc_meta(attrs: &[Attribute]) -> Vec<(String, String)> {
    let mut result = Vec::new();
    for attr in attrs {
        if attr.path().is_ident("doc") {
            if let syn::Meta::NameValue(meta) = &attr.meta {
                if let syn::Expr::Lit(expr_lit) = &meta.value {
                    if let syn::Lit::Str(lit_str) = &expr_lit.lit {
                        let doc = lit_str.value();
                        let doc = doc.trim();
                        // 解析 key = "value" 对
                        for part in doc.split(',') {
                            let part = part.trim();
                            if let Some(eq_pos) = part.find('=') {
                                let key = part[..eq_pos].trim().to_string();
                                let value = part[eq_pos + 1..].trim();
                                let value = value.trim_matches('"').to_string();
                                result.push((key, value));
                            }
                        }
                    }
                }
            }
        }
    }
    result
}

/// 将 CamelCase 转换为 snake_case
fn to_snake_case(s: &str) -> String {
    let mut result = String::new();
    for (i, c) in s.char_indices() {
        if c.is_uppercase() {
            if i > 0 {
                result.push('_');
            }
            result.push(c.to_ascii_lowercase());
        } else {
            result.push(c);
        }
    }
    result
}
fn to_ts_value(expr: &syn::Expr) -> String {
    match expr {
        syn::Expr::Lit(expr_lit) => {
             match &expr_lit.lit {
                 syn::Lit::Str(s) => format!("\"{}\"", s.value()),
                 syn::Lit::Char(c) => format!("\"{}\"", c.value()),
                 syn::Lit::Int(i) => i.base10_digits().to_string(),
                 syn::Lit::Float(f) => f.base10_digits().to_string(),
                 syn::Lit::Bool(b) => b.value.to_string(),
                 _ => quote::quote!(#expr).to_string(),
             }
        },
        syn::Expr::Array(expr_array) => {
            let elems: Vec<String> = expr_array.elems.iter().map(to_ts_value).collect();
            format!("[{}]", elems.join(", "))
        },
        syn::Expr::Struct(expr_struct) => {
            let fields: Vec<String> = expr_struct.fields.iter().map(|field| {
                 let key = match &field.member {
                     syn::Member::Named(ident) => ident.to_string(),
                     syn::Member::Unnamed(idx) => idx.index.to_string(),
                 };
                 let val = to_ts_value(&field.expr);
                 format!("{}: {}", key, val)
            }).collect();
            format!("{{ {} }}", fields.join(", "))
        },
        syn::Expr::Call(expr_call) => {
            // Check for specific constructors
            if let syn::Expr::Path(path) = &*expr_call.func {
                if let Some(last_segment) = path.path.segments.last() {
                     if last_segment.ident == "new" {
                         let path_str = quote::quote!(#path).to_string();
                         // Remove spaces for easier matching
                         let path_str = path_str.replace(" ", "");
                         if path_str.contains("Vec::new") || path_str.contains("VecDeque::new") {
                             return "[]".to_string();
                         }
                         if path_str.contains("String::new") {
                             return "\"\"".to_string();
                         }
                     }
                }
            }
             quote::quote!(#expr).to_string()
        },
        _ => quote::quote!(#expr).to_string()
    }
}

#[proc_macro_attribute]
pub fn ts(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as Item);
    
    let attr_str = attr.to_string();
    let enum_format = if attr_str.contains("\"union\"") {
        "union"
    } else if attr_str.contains("\"string\"") {
        "string"
    } else if attr_str.contains("\"number\"") {
        "number"
    } else {
        "union"
    };
    
    let generate_meta = attr_str.contains("meta");

    let is_class = attr_str.contains("class");

    match input {
        Item::Struct(ref s) => {
            let name = &s.ident;
            let name_str = name.to_string();
            let mut fields_ts = Vec::new();
            let mut fields_defaults = Vec::new();

            match &s.fields {
                Fields::Named(fields) => {
                    for field in &fields.named {
                        let field_name = field.ident.as_ref().unwrap();
                        let field_type = &field.ty;

                        // Check for default override in doc comments
                        let meta_pairs = parse_doc_meta(&field.attrs);
                        let mut default_override = None;
                        for (k, v) in meta_pairs {
                            if k == "default" {
                                default_override = Some(v);
                                break;
                            }
                        }

                        let default_val_expr = if let Some(def_val) = default_override {
                             quote! { #def_val.to_string() }
                        } else {
                             quote! { <#field_type as ::to_ts::TsType>::ts_default() }
                        };

                        fields_ts.push(quote! {
                            format!("{}: {};", stringify!(#field_name), <#field_type as ::to_ts::TsType>::ts_name())
                        });

                         fields_defaults.push(quote! {
                            format!("{}: {}", stringify!(#field_name), #default_val_expr)
                        });
                    }
                }
                _ => panic!("Only named fields are supported for #[ts] on structs"),
            }
            let expanded = quote! {
                #s

                #[cfg(not(target_arch = "wasm32"))]
                const _: () = {
                    impl ::to_ts::TsType for #name {
                        fn ts_name() -> String {
                            stringify!(#name).to_string()
                        }

                        fn ts_default() -> String {
                            if #is_class {
                                format!("new {}()", stringify!(#name))
                            } else {
                                // For interfaces, return an object literal with defaults
                                let defaults = vec![#(#fields_defaults),*];
                                let kv = defaults.iter().map(|d| {
                                     // d is "key: value"
                                     d.as_str()
                                }).collect::<Vec<_>>();
                                format!("{{ {} }}", kv.join(", "))
                            }
                        }

                        fn ts_definition() -> Option<String> {
                            let fields = vec![#(#fields_ts),*];
                            if #is_class {
                                let defaults = vec![#(#fields_defaults),*];
                                
                                let class_fields = fields.iter().zip(defaults.iter()).map(|(f, d)| {
                                    // f is "name: type;"
                                    // d is "name: default"
                                    // We want "name: type = default;"
                                    let type_part = f.trim_end_matches(';');
                                    let default_part = d.splitn(2, ':').nth(1).unwrap_or("null").trim();
                                    format!("{} = {};", type_part, default_part)
                                }).collect::<Vec<_>>();

                                let constructor_assigns = defaults.iter().map(|d| {
                                    let parts: Vec<&str> = d.splitn(2, ':').collect();
                                    let key = parts[0].trim();
                                    format!("if (init.{} !== undefined) this.{} = init.{};", key, key, key)
                                }).collect::<Vec<_>>();

                                Some(format!(
                                    "export class {} {{\n  {}\n\n  constructor(init?: Partial<{}>) {{\n    if (!init) return;\n    {}\n  }}\n}}",
                                    stringify!(#name),
                                    class_fields.join("\n  "),
                                    stringify!(#name),
                                    constructor_assigns.join("\n    ")
                                ))
                            } else {
                                Some(format!("export interface {} {{\n  {}\n}}", stringify!(#name), fields.join("\n  ")))
                            }
                        }
                    }

                    ::to_ts::inventory::submit! {
                        ::to_ts::TsDefinition {
                            name: #name_str,
                            definition: || <#name as ::to_ts::TsType>::ts_definition(),
                        }
                    }
                };
            };
            TokenStream::from(expanded)
        }
        Item::Enum(mut e) => {
            let name = &e.ident;
            let name_str = name.to_string();
            
            // 如果是数字枚举，且没有 repr 属性，自动添加 #[repr(u8)]
            if enum_format == "number" {
                let has_repr = e.attrs.iter().any(|attr| attr.path().is_ident("repr"));
                if !has_repr {
                    e.attrs.push(parse_quote!(#[repr(u8)]));
                }
            }
            
            // 收集变体的元数据
            let mut meta_entries = Vec::new();
            if generate_meta {
                for variant in &e.variants {
                    let variant_name = &variant.ident;
                    let variant_name_str = variant_name.to_string();
                    let mut meta_pairs = parse_doc_meta(&variant.attrs);
                    
                    // 自动生成 label 如果没有提供
                    if !meta_pairs.iter().any(|(k, _)| k == "label") {
                        meta_pairs.push(("label".to_string(), to_snake_case(&variant_name_str)));
                    }




                     
                    // 重构 meta 生成逻辑以支持动态值 (如 code)
                    let mut meta_fields = Vec::new();
                    
                    // 1. 添加 doc 注释中的静态元数据
                    for (k, v) in meta_pairs {
                        meta_fields.push(format!("{}: \"{}\"", k, v)); // 注意：这里还是 compile time string creation
                    }
                    
                    // 2. 如果是数字枚举，添加 code 字段
                    let code_field = if enum_format == "number" {
                         let value = if let Some((_, expr)) = &variant.discriminant {
                            quote! { #expr }
                        } else {
                            quote! { Self::#variant_name as isize }
                        };
                        Some(quote! { format!("code: {}", #value) })
                    } else {
                        None
                    };

                    // 组合所有字段
                    // 我们需要构造类似 `key: "value", code: 1` 的字符串
                    // 静态字段部分已经是字符串了，code 是动态的
                    
                    let static_fields = meta_fields.join(", ");
                    
                    let meta_obj_expr = if let Some(code_expr) = code_field {
                         if static_fields.is_empty() {
                             quote! { #code_expr }
                         } else {
                             quote! { format!("{}, {}", #static_fields, #code_expr) }
                         }
                    } else {
                        if static_fields.is_empty() {
                             // 如果没有元数据且不是数字枚举，跳过（或者生成空对象，视需求而定）
                             // 这里为了保持一致性，如果没有元数据，就不生成这一项？
                             // 但之前的逻辑是 !meta_pairs.is_empty() 才 push
                             // 现在如果是 Number 枚举，即使没有 meta pairs，也要生成 code
                             quote! { String::new() } // placeholder, handled below check
                        } else {
                             quote! { #static_fields.to_string() }
                        }
                    };
                    
                    // 只有当有内容时才添加
                    if !meta_fields.is_empty() || enum_format == "number" {
                         meta_entries.push(quote! {
                            format!("  [{}.{}]: {{ {} }},", stringify!(#name), #variant_name_str, #meta_obj_expr)
                        });
                    }
                }
            }
            
            let (ts_name_impl, ts_def_impl, ts_default_impl) = match enum_format {
                "string" => {
                    let mut variants_ts = Vec::new();
                    let mut first_variant = None;
                    
                    for variant in &e.variants {
                        let variant_name = &variant.ident;
                        if first_variant.is_none() {
                            first_variant = Some(variant_name.to_string());
                        }
                        variants_ts.push(quote! {
                            format!("{} = \"{}\",", stringify!(#variant_name), stringify!(#variant_name))
                        });
                    }
                    
                    let default_val = if let Some(v) = first_variant {
                        quote! { format!("{}.{}", stringify!(#name), #v) }
                    } else {
                        quote! { "null".to_string() }
                    };

                    (
                        quote! { stringify!(#name).to_string() },
                        if generate_meta && !meta_entries.is_empty() {
                            quote! {
                                let variants = vec![#(#variants_ts),*];
                                let meta = vec![#(#meta_entries),*];
                                Some(format!("export enum {} {{\n  {}\n}}\n\nexport const {}Meta = {{\n{}\n}} as const;", 
                                    stringify!(#name), 
                                    variants.join("\n  "),
                                    stringify!(#name),
                                    meta.join("\n")))
                            }
                        } else {
                            quote! {
                                let variants = vec![#(#variants_ts),*];
                                Some(format!("export enum {} {{\n  {}\n}}", stringify!(#name), variants.join("\n  ")))
                            }
                        },
                        default_val
                    )
                }
                "number" => {
                    let mut variants_ts = Vec::new();
                    let mut first_variant = None;

                    for variant in &e.variants {
                        let variant_name = &variant.ident;
                        if first_variant.is_none() {
                            first_variant = Some(variant_name.to_string());
                        }
                        let value = if let Some((_, expr)) = &variant.discriminant {
                            quote! { #expr }
                        } else {
                            quote! { Self::#variant_name as isize }
                        };
                        variants_ts.push(quote! {
                            format!("{} = {},", stringify!(#variant_name), #value)
                        });
                    }

                    let default_val = if let Some(v) = first_variant {
                        quote! { format!("{}.{}", stringify!(#name), #v) }
                    } else {
                        quote! { "null".to_string() }
                    };

                    (
                        quote! { stringify!(#name).to_string() },
                        if generate_meta && !meta_entries.is_empty() {
                            quote! {
                                let variants = vec![#(#variants_ts),*];
                                let meta = vec![#(#meta_entries),*];
                                Some(format!("export enum {} {{\n  {}\n}}\n\nexport const {}Meta = {{\n{}\n}} as const;", 
                                    stringify!(#name), 
                                    variants.join("\n  "),
                                    stringify!(#name),
                                    meta.join("\n")))
                            }
                        } else {
                            quote! {
                                let variants = vec![#(#variants_ts),*];
                                Some(format!("export enum {} {{\n  {}\n}}", stringify!(#name), variants.join("\n  ")))
                            }
                        },
                        default_val
                    )
                }
                _ => {
                    let mut variants_ts = Vec::new();
                    let mut first_variant = None;

                    for variant in &e.variants {
                        let variant_name = &variant.ident;
                        if first_variant.is_none() {
                            first_variant = Some(variant_name.to_string());
                        }
                        variants_ts.push(quote! {
                            format!("\"{}\"", stringify!(#variant_name))
                        });
                    }
                    
                    let default_val = if let Some(v) = first_variant {
                        quote! { format!("\"{}\"", #v) }
                    } else {
                        quote! { "null".to_string() }
                    };

                    (
                        quote! { stringify!(#name).to_string() },
                        quote! {
                            let variants = vec![#(#variants_ts),*];
                            Some(format!("export type {} = {};", stringify!(#name), variants.join(" | ")))
                        },
                        default_val
                    )
                }
            };
            
            let expanded = quote! {
                #e

                #[cfg(not(target_arch = "wasm32"))]
                const _: () = {
                    impl ::to_ts::TsType for #name {
                        fn ts_name() -> String {
                            #ts_name_impl
                        }
                        
                        fn ts_default() -> String {
                            #ts_default_impl
                        }

                        fn ts_definition() -> Option<String> {
                            #ts_def_impl
                        }
                    }

                    ::to_ts::inventory::submit! {
                        ::to_ts::TsDefinition {
                            name: #name_str,
                            definition: || <#name as ::to_ts::TsType>::ts_definition(),
                        }
                    }
                };
            };
            TokenStream::from(expanded)
        }
        Item::Const(ref c) => {
            let name = &c.ident;
            let name_str = name.to_string();
            let ty = &c.ty;
            let expr = &c.expr;
            let dummy_name = quote::format_ident!("__TS_EXPORT_{}", name);
            let ts_val_str = to_ts_value(expr);

            let expanded = quote! {
                #c

                #[cfg(not(target_arch = "wasm32"))]
                const _: () = {
                    #[allow(non_camel_case_types)]
                    pub struct #dummy_name;

                    impl ::to_ts::TsType for #dummy_name {
                        fn ts_name() -> String {
                            stringify!(#name).to_string()
                        }

                        fn ts_definition() -> Option<String> {
                            Some(format!("export const {}: {} = {};", stringify!(#name), <#ty as ::to_ts::TsType>::ts_name(), #ts_val_str))
                        }
                    }

                    ::to_ts::inventory::submit! {
                        ::to_ts::TsDefinition {
                            name: #name_str,
                            definition: || <#dummy_name as ::to_ts::TsType>::ts_definition(),
                        }
                    }
                };
            };
            TokenStream::from(expanded)
        }
        _ => panic!("The #[ts] attribute can only be used on structs, enums, and constants"),
    }
}