singleton_macro 0.1.0

//! Repository 매크로 구현 모듈
//! 
//! 이 모듈은 `#[repository]` 속성 매크로의 구현을 담당합니다.
//! 데이터 액세스 계층의 리포지토리 컴포넌트를 싱글톤으로 관리하고,
//! MongoDB 컬렉션과의 통합 및 Redis 캐싱을 자동화합니다.
//! 
//! ## 주요 기능
//! 
//! - **싱글톤 패턴 자동 적용**: `OnceCell`과 `Arc`를 통한 thread-safe 구현
//! - **MongoDB 컬렉션 헬퍼**: `db` 필드 감지 시 `collection()` 메서드 자동 생성
//! - **Redis 캐싱 헬퍼**: `redis`/`cache` 필드 감지 시 캐싱 메서드 자동 생성
//! - **의존성 자동 주입**: 필드 이름과 타입 기반 스마트 주입
//! - **전역 레지스트리 등록**: `inventory`를 통한 자동 등록 (`_repository` suffix 추가)
//! - **Static context 호환**: 컴파일 타임 안전한 등록 시스템
//! 
//! ## 의존성 주입 규칙
//! 
//! 필드 이름과 타입에 따라 자동으로 의존성을 주입합니다:
//! 
//! | 필드 이름 | 주입되는 타입 | 추가 기능 |
//! |-----------|---------------|-----------|
//! | `db`, `database` | `crate::db::Database` | MongoDB `collection()` 메서드 |
//! | `redis`, `cache` | `crate::caching::redis::RedisClient` | Redis 캐싱 메서드들 |
//! | 기타 `Arc<T>` 타입 | `ServiceLocator::get::<T>()` | - |
//! | 기타 타입 | `Default::default()` | - |
//! 
//! ## 자동 생성 메서드
//! 
//! ### 기본 메서드 (항상 생성)
//! - `instance()` - 싱글톤 인스턴스 접근
//! - `new()` - 의존성 주입을 통한 인스턴스 생성 (private)
//! - `collection_name()` - MongoDB 컬렉션 이름 반환
//! 
//! ### MongoDB 관련 (db/database 필드가 있을 때)
//! - `collection<T>()` - 타입 안전한 MongoDB 컬렉션 접근
//! 
//! ### Redis 관련 (redis/cache 필드가 있을 때)
//! - `cache_key(id)` - 표준화된 엔티티 캐시 키 생성
//! - `collection_cache_key(suffix)` - 컬렉션 레벨 캐시 키 생성
//! - `invalidate_cache(id)` - 특정 엔티티 캐시 무효화
//! - `invalidate_collection_cache(suffix)` - 컬렉션 캐시 무효화
//! - `invalidate_pattern_cache(pattern)` - 패턴 매칭 캐시 무효화
//! 
//! ## 레지스트리 시스템
//! 
//! ### 자동 등록 규칙
//! - **기본**: `{구조체명소문자}_repository` (예: `UserRepository` → `userrepository_repository`)
//! - **커스텀**: `{name}_repository` (예: `name = "user"` → `user_repository`)
//! 
//! ### 등록 구조체
//! ```rust,ignore
//! pub struct RepositoryRegistration {
//!     pub name: &'static str,                              // 등록 이름
//!     pub constructor: fn() -> Box<dyn Any + Send + Sync>, // 생성 함수 포인터
//! }
//! ```
//! 
//! ## 매크로 사용법
//! 
//! ### 기본 사용법
//! ```rust,ignore
//! #[repository]
//! struct UserRepository {
//!     db: Arc<Database>,        // MongoDB 기능 활성화
//!     redis: Arc<RedisClient>,  // Redis 캐싱 기능 활성화
//! }
//! 
//! // 생성되는 이름: "userrepository_repository"
//! // 컬렉션 이름: "userrepository" (자동 생성)
//! ```
//! 
//! ### 커스텀 설정
//! ```rust,ignore
//! #[repository(name = "user", collection = "users")]
//! struct UserRepository {
//!     db: Arc<Database>,
//!     redis: Arc<RedisClient>,
//! }
//! 
//! // 생성되는 이름: "user_repository"
//! // 컬렉션 이름: "users"
//! ```
//! 
//! ### 사용 예제
//! ```rust,ignore
//! // 인스턴스 접근
//! let repo = UserRepository::instance();
//! 
//! // MongoDB 작업 (db 필드가 있으므로 가능)
//! let users: Collection<User> = repo.collection();
//! let user = users.find_one(doc! { "email": "test@example.com" }, None).await?;
//! 
//! // Redis 캐싱 (redis 필드가 있으므로 가능)
//! let cache_key = repo.cache_key("user123");     // "user_repository:user123"
//! repo.invalidate_cache("user123").await?;
//! repo.invalidate_pattern_cache("user_repository:*").await?;
//! 
//! // 메타데이터
//! assert_eq!(repo.name(), "user_repository");
//! assert_eq!(repo.collection_name(), "users");
//! ```
//! 
//! ## 생성되는 trait 구현
//! 
//! ```rust,ignore
//! #[async_trait]
//! impl Repository for UserRepository {
//!     fn name(&self) -> &str { "user_repository" }
//!     fn collection_name(&self) -> &str { "users" }
//!     async fn init(&self) -> Result<(), Box<dyn Error>> { 
//!         println!("Repository {} initialized", self.name());
//!         Ok(()) 
//!     }
//! }
//! ```

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, parse::Parse, parse::ParseStream, DeriveInput, Token, LitStr};

/// Repository 매크로의 인자를 파싱하는 구조체
/// 
/// 다음과 같은 형식의 인자를 파싱합니다:
/// - `#[repository]` - 인자 없음 (기본값 사용)
/// - `#[repository(name = "user")]` - name만 지정 (`user_repository`로 등록)
/// - `#[repository(collection = "users")]` - collection만 지정  
/// - `#[repository(name = "user", collection = "users")]` - 둘 다 지정
/// 
/// # 필드
/// 
/// * `name` - 레지스트리에 등록될 리포지토리 이름 (선택사항, `_repository` suffix 자동 추가)
/// * `collection` - MongoDB 컬렉션 이름 (선택사항)
/// 
/// # 기본값 규칙
/// 
/// - **name**: `{구조체명소문자}_repository` (예: `UserRepository` → `userrepository_repository`)
/// - **collection**: 구조체명에서 `Repository` 제거 후 소문자 + `s` (예: `UserRepository` → `users`)
struct RepositoryArgs {
    name: Option<String>,
    collection: Option<String>,
}

impl Parse for RepositoryArgs {
    /// 매크로 인자를 파싱합니다.
    /// 
    /// # 파싱 형식
    /// 
    /// ```text
    /// name = "repository_name", collection = "collection_name"
    /// ```
    /// 
    /// # 에러
    /// 
    /// - 알 수 없는 인자 이름이 제공된 경우
    /// - 문법이 올바르지 않은 경우 (예: `=` 누락)
    /// 
    /// # 예제
    /// 
    /// ```rust,ignore
    /// // 빈 인자
    /// #[repository]
    /// 
    /// // name만 지정
    /// #[repository(name = "user")]
    /// 
    /// // 둘 다 지정
    /// #[repository(name = "user", collection = "users")]
    /// ```
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut name = None;
        let mut collection = None;

        if input.is_empty() {
            return Ok(RepositoryArgs { name, collection });
        }

        // 쉼표로 구분된 인자들 파싱
        loop {
            let ident: syn::Ident = input.parse()?;
            input.parse::<Token![=]>()?;
            let value: LitStr = input.parse()?;

            match ident.to_string().as_str() {
                "name" => name = Some(value.value()),
                "collection" => collection = Some(value.value()),
                _ => return Err(syn::Error::new(ident.span(), "Unknown argument. Expected 'name' or 'collection'")),
            }

            // 더 이상 인자가 없으면 종료
            if input.is_empty() {
                break;
            }

            // 쉼표 파싱
            input.parse::<Token![,]>()?;
        }

        Ok(RepositoryArgs { name, collection })
    }
}

/// Repository 매크로의 메인 구현 함수
/// 
/// 이 함수는 `#[repository]` 속성이 적용된 구조체를 분석하고,
/// 필요한 모든 보일러플레이트 코드를 생성합니다.
/// 
/// # 생성되는 코드 구조
/// 
/// 1. **원본 구조체**: 사용자가 정의한 구조체를 그대로 유지
/// 2. **Static 상수**: 리포지토리 이름을 const로 정의
/// 3. **싱글톤 저장소**: `OnceCell<Arc<T>>` static 변수
/// 4. **impl 블록**: 
///    - `instance()` - 싱글톤 인스턴스 접근
///    - `new()` - 의존성 주입 생성자 (private)
///    - `collection_name()` - 컬렉션 이름 반환
///    - MongoDB/Redis 헬퍼 메서드들 (조건부)
/// 5. **Registry 등록**: `inventory::submit!`을 통한 자동 등록
/// 6. **Trait 구현**: `Repository` trait 자동 구현
/// 
/// # 조건부 메서드 생성
/// 
/// ## MongoDB 헬퍼 (db/database 필드가 있을 때)
/// ```rust,ignore
/// pub fn collection<T: Send + Sync + 'static>(&self) -> mongodb::Collection<T> {
///     self.db.get_database().collection::<T>(self.collection_name())
/// }
/// ```
/// 
/// ## Redis 헬퍼 (redis/cache 필드가 있을 때)
/// ```rust,ignore
/// pub fn cache_key(&self, id: &str) -> String { /* ... */ }
/// pub fn collection_cache_key(&self, suffix: Option<&str>) -> String { /* ... */ }
/// pub async fn invalidate_cache(&self, id: &str) -> Result<(), Box<dyn Error>> { /* ... */ }
/// // ... 기타 캐싱 메서드들
/// ```
/// 
/// # 인자
/// 
/// * `args` - 매크로 속성 인자 (name, collection)
/// * `input` - 대상 구조체의 TokenStream
/// 
/// # 반환값
/// 
/// 확장된 TokenStream (원본 구조체 + 생성된 코드)
/// 
/// # 에러
/// 
/// - 구조체가 아닌 타입에 적용된 경우 panic
/// - 인자 파싱 실패 시 컴파일 에러
/// 
/// # 예제 변환
/// 
/// **입력:**
/// ```rust,ignore
/// #[repository(name = "user", collection = "users")]
/// struct UserRepository {
///     db: Arc<Database>,
///     redis: Arc<RedisClient>,
/// }
/// ```
/// 
/// **출력 (일부):**
/// ```rust,ignore
/// struct UserRepository { /* 원본 */ }
/// 
/// const __USERREPOSITORY_REPOSITORY_NAME: &'static str = "user_repository";
/// static __USERREPOSITORY_INSTANCE: OnceCell<Arc<UserRepository>> = OnceCell::new();
/// 
/// impl UserRepository {
///     pub fn instance() -> Arc<Self> { /* ... */ }
///     fn new() -> Self { /* ... */ }
///     pub fn collection<T>(&self) -> Collection<T> { /* ... */ }
///     pub fn cache_key(&self, id: &str) -> String { /* ... */ }
///     // ... 기타 메서드들
/// }
/// 
/// inventory::submit! { RepositoryRegistration { /* ... */ } }
/// impl Repository for UserRepository { /* ... */ }
/// ```
pub fn implement_repository(args: TokenStream, input: TokenStream) -> TokenStream {
    // 입력 파싱
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = &input.ident;

    // 매크로 인자 파싱
    let args = if args.is_empty() {
        RepositoryArgs { name: None, collection: None }
    } else {
        parse_macro_input!(args as RepositoryArgs)
    };

    // 리포지토리 이름 생성 - 자동으로 _repository suffix 추가
    let repo_name = if let Some(name) = args.name {
        // 사용자가 명시적으로 지정한 경우에도 _repository suffix 추가
        format!("{}_repository", name)
    } else {
        // 구조체 이름에서 자동 생성 (UserRepository -> userrepository_repository)
        format!("{}_repository", struct_name.to_string().to_lowercase())
    };

    // 컬렉션 이름 생성 
    let collection_name = args.collection.unwrap_or_else(|| {
        // UserRepository -> users
        let name = struct_name.to_string();
        if name.ends_with("Repository") {
            let base = &name[..name.len() - "Repository".len()];
            format!("{}s", base.to_lowercase())
        } else {
            format!("{}s", name.to_lowercase())
        }
    });

    // 필드 분석
    let fields = match &input.data {
        syn::Data::Struct(data) => &data.fields,
        _ => panic!("repository macro only works with structs"),
    };

    // 기능 감지
    let has_db_field = has_database_field(fields);
    let has_redis_field = has_redis_field(fields);
    let redis_field_name = find_redis_field_name(fields);

    // 필드 초기화 코드 생성
    let field_initializers = generate_repository_field_initializers(fields);

    // 네이밍
    let instance_name = quote::format_ident!("__{}_INSTANCE", struct_name.to_string().to_uppercase());
    let repo_name_const = quote::format_ident!("__{}_REPOSITORY_NAME", struct_name.to_string().to_uppercase());

    // MongoDB collection helper 메서드 생성 (db 필드가 있을 때만)
    let collection_method = if has_db_field {
        quote! {
            /// MongoDB 컬렉션 접근
            /// 
            /// 지정된 타입 T의 MongoDB 컬렉션을 반환합니다.
            /// `db` 또는 `database` 필드가 있을 때만 생성됩니다.
            /// 
            /// # 타입 파라미터
            /// 
            /// * `T` - 컬렉션에 저장될 문서의 타입 (Send + Sync + 'static 구현 필요)
            /// 
            /// # 반환값
            /// 
            /// `mongodb::Collection<T>` 인스턴스
            /// 
            /// # 예제
            /// 
            /// ```rust,ignore
            /// let repo = UserRepository::instance();
            /// let users: Collection<User> = repo.collection();
            /// let user = users.find_one(doc! { "email": email }, None).await?;
            /// ```
            pub fn collection<T: Send + Sync + 'static>(&self) -> mongodb::Collection<T> {
                self.db.get_database().collection::<T>(self.collection_name())
            }
        }
    } else {
        quote! {}
    };

    // Redis 캐싱 helper 메서드 생성 (redis/cache 필드가 있을 때만)
    let redis_methods = if has_redis_field {
        if let Some(redis_field_name) = redis_field_name {
            quote! {
                /// Redis 캐시 키 생성
                /// 
                /// 리포지토리 이름과 ID를 기반으로 표준화된 캐시 키를 생성합니다.
                /// 형식: `{repository_name}:{id}`
                /// 
                /// # 인자
                /// 
                /// * `id` - 엔티티의 고유 식별자
                /// 
                /// # 반환값
                /// 
                /// 표준화된 캐시 키 문자열
                /// 
                /// # 예제
                /// 
                /// ```rust,ignore
                /// let repo = UserRepository::instance();
                /// let key = repo.cache_key("user123"); // "user_repository:user123"
                /// ```
                pub fn cache_key(&self, id: &str) -> String {
                    format!("{}:{}", self.name(), id)
                }

                /// 컬렉션 전체 캐시 키 생성
                /// 
                /// 컬렉션 레벨의 캐시 키를 생성합니다.
                /// 형식: `{repository_name}:collection:{suffix}` 또는 `{repository_name}:collection`
                /// 
                /// # 인자
                /// 
                /// * `suffix` - 키의 접미사 (선택사항)
                /// 
                /// # 반환값
                /// 
                /// 컬렉션 캐시 키 문자열
                /// 
                /// # 예제
                /// 
                /// ```rust,ignore
                /// let repo = UserRepository::instance();
                /// 
                /// // 특정 접미사를 가진 캐시 키
                /// let key = repo.collection_cache_key(Some("active")); 
                /// // -> "user_repository:collection:active"
                ///
                /// // 기본 컬렉션 캐시 키
                /// let key = repo.collection_cache_key(None); 
                /// // -> "user_repository:collection"
                /// ```
                pub fn collection_cache_key(&self, suffix: Option<&str>) -> String {
                    match suffix {
                        Some(s) => format!("{}:collection:{}", self.name(), s),
                        None => format!("{}:collection", self.name()),
                    }
                }

                /// 엔티티 캐시 무효화
                /// 
                /// 특정 ID에 해당하는 캐시를 삭제합니다.
                /// 
                /// # 인자
                /// 
                /// * `id` - 무효화할 엔티티의 ID
                /// 
                /// # 반환값
                /// 
                /// `Result<(), Box<dyn Error>>` - 성공 시 Ok(()), 실패 시 에러
                /// 
                /// # 예제
                /// 
                /// ```rust,ignore
                /// let repo = UserRepository::instance();
                /// repo.invalidate_cache("user123").await?;
                /// ```
                pub async fn invalidate_cache(&self, id: &str) -> Result<(), Box<dyn ::std::error::Error>> {
                    let key = self.cache_key(id);
                    self.#redis_field_name.del(&key).await?;
                    Ok(())
                }

                /// 컬렉션 캐시 무효화
                /// 
                /// 컬렉션 레벨의 캐시를 삭제합니다.
                /// 
                /// # 인자
                /// 
                /// * `suffix` - 삭제할 캐시 키의 접미사 (선택사항)
                /// 
                /// # 반환값
                /// 
                /// `Result<(), Box<dyn Error>>` - 성공 시 Ok(()), 실패 시 에러
                /// 
                /// # 예제
                /// 
                /// ```rust,ignore
                /// let repo = UserRepository::instance();
                /// 
                /// // 특정 컬렉션 캐시 삭제
                /// repo.invalidate_collection_cache(Some("active")).await?;
                /// 
                /// // 전체 컬렉션 캐시 삭제
                /// repo.invalidate_collection_cache(None).await?;
                /// ```
                pub async fn invalidate_collection_cache(&self, suffix: Option<&str>) -> Result<(), Box<dyn ::std::error::Error>> {
                    let key = self.collection_cache_key(suffix);
                    self.#redis_field_name.del(&key).await?;
                    Ok(())
                }

                /// 패턴 기반 캐시 무효화
                /// 
                /// 특정 패턴과 일치하는 모든 캐시를 삭제합니다.
                /// Redis KEYS 명령을 사용하므로 대량의 키가 있는 프로덕션 환경에서는 주의가 필요합니다.
                /// 
                /// # 인자
                /// 
                /// * `pattern` - Redis 패턴 (예: "user_repository:*", "*:active")
                /// 
                /// # 반환값
                /// 
                /// `Result<(), Box<dyn Error>>` - 성공 시 Ok(()), 실패 시 에러
                /// 
                /// # 예제
                /// 
                /// ```rust,ignore
                /// let repo = UserRepository::instance();
                /// 
                /// // 모든 사용자 캐시 삭제
                /// repo.invalidate_pattern_cache(&format!("{}:*", repo.name())).await?;
                /// 
                /// // 특정 패턴의 캐시 삭제
                /// repo.invalidate_pattern_cache("user_repository:session:*").await?;
                /// ```
                /// 
                /// # 주의사항
                /// 
                /// - KEYS 명령은 Redis를 블로킹할 수 있으므로 프로덕션에서는 신중히 사용
                /// - 대량의 키가 있는 경우 SCAN 명령 사용 고려
                /// - 패턴이 너무 광범위하면 성능 문제 발생 가능
                pub async fn invalidate_pattern_cache(&self, pattern: &str) -> Result<(), Box<dyn ::std::error::Error>> {
                    let keys: Vec<String> = self.#redis_field_name.keys(pattern).await?;
                    if !keys.is_empty() {
                        self.#redis_field_name.del_multiple(&keys).await?;
                    }
                    Ok(())
                }
            }
        } else {
            // 이론적으로 도달하지 않아야 함
            quote! {}
        }
    } else {
        quote! {}
    };

    // 최종 코드 생성
    let expanded = quote! {
        #input

        // 리포지토리 이름을 const로 정의 (컴파일 타임 상수)
        const #repo_name_const: &'static str = #repo_name;

        // 싱글톤 인스턴스 저장 (thread-safe)
        static #instance_name: ::once_cell::sync::OnceCell<::std::sync::Arc<#struct_name>> =
            ::once_cell::sync::OnceCell::new();

        impl #struct_name {
            /// 싱글톤 인스턴스 가져오기
            /// 
            /// 첫 호출 시 인스턴스를 생성하고, 이후 호출에서는 캐시된 인스턴스를 반환합니다.
            /// Thread-safe하며 여러 스레드에서 동시에 호출해도 안전합니다.
            /// 
            /// # 반환값
            /// 
            /// `Arc<Self>` - 싱글톤 인스턴스
            /// 
            /// # 예제
            /// 
            /// ```rust,ignore
            /// let repo = UserRepository::instance();
            /// let another_repo = UserRepository::instance();
            /// // repo와 another_repo는 같은 인스턴스를 가리킴
            /// ```
            pub fn instance() -> ::std::sync::Arc<Self>
            where 
                Self: Send + Sync + 'static,
            {
                #instance_name
                    .get_or_init(|| {
                        ::std::sync::Arc::new(Self::new())
                    })
                    .clone()
            }

            /// 의존성 주입을 통한 인스턴스 생성 (내부 사용)
            /// 
            /// 이 메서드는 `instance()`에서만 호출되며 직접 사용하지 않습니다.
            /// 필드 이름과 타입을 분석하여 적절한 의존성을 자동 주입합니다.
            fn new() -> Self {
                #[allow(unused_imports)]
                use std::default::Default;
                
                Self {
                    #field_initializers
                }
            }

            /// MongoDB 컬렉션 이름 반환
            /// 
            /// # 반환값
            /// 
            /// `&'static str` - 컬렉션 이름
            /// 
            /// # 예제
            /// 
            /// ```rust,ignore
            /// let repo = UserRepository::instance();
            /// assert_eq!(repo.collection_name(), "users");
            /// ```
            pub fn collection_name(&self) -> &'static str {
                #collection_name
            }

            #collection_method
            #redis_methods
        }

        // 전역 레지스트리에 자동 등록
        // inventory 크레이트를 통해 컴파일 타임에 등록됨
        ::inventory::submit! {
            crate::core::registry::RepositoryRegistration {
                name: #repo_name,
                constructor: || {
                    let instance = #struct_name::instance();
                    Box::new(instance) as Box<dyn ::std::any::Any + Send + Sync>
                },
            }
        }

        // Repository trait 자동 구현
        #[::async_trait::async_trait]
        impl crate::core::registry::Repository for #struct_name {
            /// 리포지토리 이름 반환
            fn name(&self) -> &str {
                #repo_name_const
            }

            /// MongoDB 컬렉션 이름 반환
            fn collection_name(&self) -> &str {
                #collection_name
            }

            /// 리포지토리 초기화
            /// 
            /// 필요시 MongoDB 인덱스 생성, Redis 연결 확인 등의 초기화 로직을 수행합니다.
            /// 기본 구현에서는 로그만 출력합니다.
            async fn init(&self) -> Result<(), Box<dyn ::std::error::Error>> {
                println!("Repository {} initialized", self.name());
                Ok(())
            }
        }
    };

    TokenStream::from(expanded)
}

/// Database 필드 감지
/// 
/// 구조체의 필드 중 이름이 "db" 또는 "database"인 필드가 있는지 검사합니다.
/// 이 필드가 있으면 MongoDB collection 헬퍼 메서드를 생성합니다.
/// 
/// # 인자
/// 
/// * `fields` - 구조체의 필드 정보
/// 
/// # 반환값
/// 
/// * `true` - db 또는 database 필드가 있음
/// * `false` - 해당 필드가 없음
/// 
/// # 검사 규칙
/// 
/// - 필드 이름이 정확히 "db" 또는 "database"와 일치해야 함
/// - 대소문자 구분함
/// - 타입은 상관없음 (Arc<Database>, Database 등 모두 허용)
fn has_database_field(fields: &syn::Fields) -> bool {
    match fields {
        syn::Fields::Named(fields) => {
            fields.named.iter().any(|field| {
                field.ident.as_ref()
                    .map(|ident| ident == "db" || ident == "database")
                    .unwrap_or(false)
            })
        }
        _ => false,
    }
}

/// Redis 필드 감지
/// 
/// 구조체의 필드 중 이름이 "redis" 또는 "cache"인 필드가 있는지 검사합니다.
/// 이 필드가 있으면 Redis 캐싱 관련 헬퍼 메서드를 생성합니다.
/// 
/// # 인자
/// 
/// * `fields` - 구조체의 필드 정보
/// 
/// # 반환값
/// 
/// * `true` - redis 또는 cache 필드가 있음
/// * `false` - 해당 필드가 없음
/// 
/// # 생성되는 메서드
/// 
/// Redis 필드가 있을 경우 다음 메서드들이 자동 생성됩니다:
/// - `cache_key()` - 표준화된 캐시 키 생성
/// - `collection_cache_key()` - 컬렉션 레벨 캐시 키 생성  
/// - `invalidate_cache()` - 특정 엔티티 캐시 무효화
/// - `invalidate_collection_cache()` - 컬렉션 캐시 무효화
/// - `invalidate_pattern_cache()` - 패턴 기반 캐시 무효화
fn has_redis_field(fields: &syn::Fields) -> bool {
    match fields {
        syn::Fields::Named(fields) => {
            fields.named.iter().any(|field| {
                field.ident.as_ref()
                    .map(|ident| ident == "redis" || ident == "cache")
                    .unwrap_or(false)
            })
        }
        _ => false,
    }
}

/// Repository 필드 초기화 코드 생성
/// 
/// 구조체의 각 필드를 분석하여 적절한 초기화 코드를 생성합니다.
/// 필드 이름과 타입에 따라 자동으로 의존성을 주입합니다.
/// 
/// # 의존성 주입 우선순위
/// 
/// 1. **특별한 필드 이름 기반**:
///    - `db`, `database` → `ServiceLocator::get::<Database>()`
///    - `redis`, `cache` → `ServiceLocator::get::<RedisClient>()`
/// 
/// 2. **타입 기반**:
///    - `Arc<T>` → `ServiceLocator::get::<T>()` (ServiceLocator에서 T 타입 검색)
/// 
/// 3. **기본값**:
///    - 나머지 → `Default::default()`
/// 
/// # 인자
/// 
/// * `fields` - 구조체의 필드 정보
/// 
/// # 반환값
/// 
/// 필드 초기화 코드를 포함하는 TokenStream
/// 
/// # 생성 예시
/// 
/// ```rust,ignore
/// // 입력 구조체:
/// struct UserRepository {
///     db: Arc<Database>,           // → ServiceLocator::get::<Database>()
///     cache: Arc<RedisClient>,     // → ServiceLocator::get::<RedisClient>()
///     user_service: Arc<UserService>, // → ServiceLocator::get::<UserService>()
///     config: Config,              // → Default::default()
/// }
/// 
/// // 생성되는 코드:
/// Self {
///     db: crate::core::registry::ServiceLocator::get::<crate::db::Database>().clone(),
///     cache: crate::core::registry::ServiceLocator::get::<crate::caching::redis::RedisClient>().clone(),
///     user_service: crate::core::registry::ServiceLocator::get::<UserService>().clone(),
///     config: Default::default(),
/// }
/// ```
fn generate_repository_field_initializers(fields: &syn::Fields) -> proc_macro2::TokenStream {
    match fields {
        syn::Fields::Named(fields) => {
            let initializers = fields.named.iter().map(|field| {
                let field_name = &field.ident;
                let field_type = &field.ty;

                // 필드 이름으로 특별 처리
                if let Some(name) = field_name {
                    match name.to_string().as_str() {
                        "db" | "database" => {
                            quote! {
                                #field_name: crate::core::registry::ServiceLocator::get::<crate::db::Database>()
                                    .clone()
                            }
                        }
                        "redis" | "cache" => {
                            quote! {
                                #field_name: crate::core::registry::ServiceLocator::get::<crate::caching::redis::RedisClient>()
                                    .clone()
                            }
                        }
                        _ => {
                            // Arc<T> 타입인 경우 ServiceLocator에서 자동 주입
                            if let Some(inner_type) = extract_arc_inner_type(field_type) {
                                quote! {
                                    #field_name: crate::core::registry::ServiceLocator::get::<#inner_type>()
                                        .clone()
                                }
                            } else {
                                quote! {
                                    #field_name: Default::default()
                                }
                            }
                        }
                    }
                } else {
                    quote! {
                        Default::default()
                    }
                }
            });

            quote! { #(#initializers),* }
        }
        _ => quote! {},
    }
}

/// Redis 필드의 실제 이름 찾기
/// 
/// 구조체의 필드 중 이름이 "redis" 또는 "cache"인 필드의 identifier를 반환합니다.
/// Redis 캐싱 메서드 생성 시 실제 필드 이름을 참조하기 위해 사용됩니다.
/// 
/// # 인자
/// 
/// * `fields` - 구조체의 필드 정보
/// 
/// # 반환값
/// 
/// * `Some(&Ident)` - redis 또는 cache 필드의 identifier
/// * `None` - 해당 필드가 없음
/// 
/// # 우선순위
/// 
/// 1. "redis" 필드를 먼저 찾음
/// 2. "redis"가 없으면 "cache" 필드를 찾음
/// 3. 둘 다 있으면 첫 번째로 발견된 것을 반환
/// 
/// # 사용 예시
/// 
/// ```rust,ignore
/// // 구조체:
/// struct Repository {
///     redis: Arc<RedisClient>,  // 이 필드 이름이 반환됨
/// }
/// 
/// // 생성되는 코드에서 사용:
/// self.redis.del(&key).await?;  // redis 필드를 직접 참조
/// ```
fn find_redis_field_name(fields: &syn::Fields) -> Option<&syn::Ident> {
    match fields {
        syn::Fields::Named(fields) => {
            fields.named.iter()
                .find_map(|field| {
                    field.ident.as_ref().filter(|ident| {
                        let name = ident.to_string();
                        name == "redis" || name == "cache"
                    })
                })
        }
        _ => None,
    }
}

/// Arc<T>에서 내부 타입 T 추출
/// 
/// `Arc<T>` 타입에서 제네릭 인자 T를 추출합니다.
/// 의존성 주입 시 ServiceLocator에서 올바른 타입을 가져오기 위해 사용됩니다.
/// 
/// # 인자
/// 
/// * `ty` - 검사할 타입 (syn::Type)
/// 
/// # 반환값
/// 
/// * `Some(&Type)` - Arc의 내부 타입 T
/// * `None` - Arc 타입이 아니거나 내부 타입을 추출할 수 없는 경우
/// 
/// # 지원하는 형태
/// 
/// - `Arc<UserService>` → `Some(UserService)`
/// - `Arc<Database>` → `Some(Database)` 
/// - `std::sync::Arc<RedisClient>` → `Some(RedisClient)`
/// - `String` → `None`
/// - `Vec<User>` → `None`
/// - `Option<Arc<T>>` → `None` (중첩된 Arc는 지원하지 않음)
/// 
/// # 구현 세부사항
/// 
/// syn의 타입 시스템을 사용하여 다음 구조를 파싱합니다:
/// 
/// ```text
/// Type::Path
///   └─ PathSegment { ident: "Arc", arguments: AngleBracketed }
///       └─ GenericArgument::Type(내부_타입)
/// ```
/// 
/// # 예제
/// 
/// ```rust,ignore
/// // 매크로 내부에서 사용:
/// if let Some(inner_type) = extract_arc_inner_type(&field.ty) {
///     // inner_type이 UserService라면
///     quote! {
///         field_name: ServiceLocator::get::<#inner_type>()  // get::<UserService>()
///     }
/// }
/// ```
fn extract_arc_inner_type(ty: &syn::Type) -> Option<&syn::Type> {
    if let syn::Type::Path(type_path) = ty {
        let segments = &type_path.path.segments;

        if let Some(segment) = segments.last() {
            if segment.ident == "Arc" {
                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
                    if let Some(syn::GenericArgument::Type(inner_type)) = args.args.first() {
                        return Some(inner_type);
                    }
                }
            }
        }
    }
    None
}