singleton_macro 0.1.0

//! Service 매크로 구현 모듈
//! 
//! 이 모듈은 `#[service]` 속성 매크로의 구현을 담당합니다.
//! 비즈니스 로직 계층의 서비스 컴포넌트를 싱글톤으로 관리하고,
//! 의존성 주입을 자동화합니다.
//! 
//! ## 주요 기능
//! 
//! - **싱글톤 패턴 자동 적용**: `OnceCell`과 `Arc`를 통한 thread-safe 구현
//! - **Arc<T> 타입 자동 주입**: `ServiceLocator`를 통한 의존성 해결
//! - **전역 레지스트리 등록**: `inventory`를 통한 자동 등록 (`_service` suffix 추가)
//! - **Service trait 자동 구현**: 표준 서비스 인터페이스 제공
//! - **Static context 호환**: 컴파일 타임 안전한 등록 시스템
//! 
//! ## Repository 매크로와의 차이점
//! 
//! | 특징 | Service | Repository |
//! |------|---------|------------|
//! | 인자 | `name`만 지원 | `name`, `collection` 지원 |
//! | 특별 필드 처리 | 없음 | `db`, `redis` 필드 특별 처리 |
//! | 생성 메서드 | 기본 메서드만 | MongoDB, Redis 헬퍼 메서드 |
//! | 주 용도 | 비즈니스 로직 | 데이터 액세스 |
//! 
//! ## 의존성 주입 규칙
//! 
//! Service는 단순한 의존성 주입 규칙을 따릅니다:
//! 
//! | 필드 타입 | 주입 방식 |
//! |-----------|-----------|
//! | `Arc<T>` | `ServiceLocator::get::<T>()` 자동 주입 |
//! | 기타 타입 | `Default::default()` 사용 |
//! 
//! Repository와 달리 필드 이름 기반 특별 처리는 없습니다.
//! 
//! ## 레지스트리 시스템
//! 
//! ### 자동 등록 규칙
//! - **기본**: `{구조체명소문자}_service` (예: `UserService` → `userservice_service`)
//! - **커스텀**: `{name}_service` (예: `name = "auth"` → `auth_service`)
//! 
//! ### 등록 구조체
//! ```rust,ignore
//! pub struct ServiceRegistration {
//!     pub name: &'static str,                              // 등록 이름
//!     pub constructor: fn() -> Box<dyn Any + Send + Sync>, // 생성 함수 포인터
//! }
//! ```
//! 
//! ## 매크로 사용법
//! 
//! ### 기본 사용법
//! ```rust,ignore
//! #[service]
//! struct UserService {
//!     user_repo: Arc<UserRepository>,    // ServiceLocator 자동 주입
//!     email_service: Arc<EmailService>,  // ServiceLocator 자동 주입
//!     retry_count: u32,                  // Default::default()
//!     config: ServiceConfig,             // Default::default()
//! }
//! 
//! // 생성되는 이름: "userservice_service"
//! ```
//! 
//! ### 커스텀 이름 지정
//! ```rust,ignore
//! #[service(name = "auth")]
//! struct AuthenticationService {
//!     user_repo: Arc<UserRepository>,
//!     token_service: Arc<TokenService>,
//! }
//! 
//! // 생성되는 이름: "auth_service"
//! ```
//! 
//! ### 사용 예제
//! ```rust,ignore
//! // 인스턴스 접근
//! let service = UserService::instance();
//! 
//! // 메타데이터
//! assert_eq!(service.name(), "userservice_service");
//! 
//! // 비즈니스 로직 호출
//! let user = service.get_user_by_id("123").await?;
//! service.send_welcome_email(&user).await?;
//! ```
//! 
//! ## 생성되는 메서드
//! 
//! ### 기본 메서드 (항상 생성)
//! - `instance()` - 싱글톤 인스턴스 접근
//! - `new()` - 의존성 주입을 통한 인스턴스 생성 (private)
//! 
//! ### Service trait 구현
//! ```rust,ignore
//! #[async_trait]
//! impl Service for UserService {
//!     fn name(&self) -> &str { "userservice_service" }
//!     async fn init(&self) -> Result<(), Box<dyn Error>> { 
//!         println!("Service {} initialized", self.name());
//!         Ok(()) 
//!     }
//! }
//! ```
//! 
//! ## 의존성 주입 동작 원리
//! 
//! ### Arc<T> 타입 감지 및 주입
//! ```rust,ignore
//! // 매크로가 분석하는 필드:
//! struct PaymentService {
//!     payment_repo: Arc<PaymentRepository>,  // Arc<T> 감지 → 자동 주입
//!     notification: Arc<NotificationService>, // Arc<T> 감지 → 자동 주입
//!     max_retries: u32,                      // 일반 타입 → Default::default()
//! }
//! 
//! // 생성되는 new() 메서드:
//! fn new() -> Self {
//!     Self {
//!         payment_repo: ServiceLocator::get::<PaymentRepository>().clone(),
//!         notification: ServiceLocator::get::<NotificationService>().clone(),
//!         max_retries: Default::default(),
//!     }
//! }
//! ```
//! 
//! ### ServiceLocator 연동
//! 1. **타입 추출**: `Arc<PaymentRepository>`에서 `PaymentRepository` 추출
//! 2. **ServiceLocator 호출**: `ServiceLocator::get::<PaymentRepository>()`
//! 3. **Arc 복제**: 반환된 `Arc<T>`를 `clone()`으로 복사
//! 4. **필드 할당**: 복제된 Arc를 필드에 할당
//! 
//! ## 일반적인 사용 패턴
//! 
//! ### 계층별 의존성 주입
//! ```rust,ignore
//! // 1. Repository 계층
//! #[repository]
//! struct UserRepository { /* ... */ }
//! 
//! // 2. Service 계층 (Repository 의존)
//! #[service]
//! struct UserService {
//!     user_repo: Arc<UserRepository>,  // 자동 주입
//! }
//! 
//! // 3. Application 계층 (Service 의존)
//! #[service]
//! struct UserApplicationService {
//!     user_service: Arc<UserService>,      // 자동 주입
//!     email_service: Arc<EmailService>,    // 자동 주입
//! }
//! ```
//! 
//! ### 서비스 간 상호 의존
//! ```rust,ignore
//! #[service]
//! struct OrderService {
//!     order_repo: Arc<OrderRepository>,
//!     user_service: Arc<UserService>,      // 다른 서비스 의존
//!     payment_service: Arc<PaymentService>, // 다른 서비스 의존
//! }
//! ```
//! 
//! ## 주의사항
//! 
//! ### 순환 의존성 방지
//! ```rust,ignore
//! // ❌ 금지: A → B → A 순환 의존성
//! #[service] struct ServiceA { b: Arc<ServiceB> }
//! #[service] struct ServiceB { a: Arc<ServiceA> }  // 런타임 패닉 발생!
//! 
//! // ✅ 권장: 계층적 의존성
//! #[service] struct ServiceA { repo: Arc<Repository> }
//! #[service] struct ServiceB { repo: Arc<Repository>, a: Arc<ServiceA> }
//! ```
//! 
//! ### ServiceLocator 의존성 등록
//! ```rust,ignore
//! // 핵심 서비스들은 미리 ServiceLocator에 등록 필요
//! fn main() {
//!     // 기반 서비스 등록
//!     ServiceLocator::set(Arc::new(Database::new()));
//!     ServiceLocator::set(Arc::new(RedisClient::new()));
//!     
//!     // 이제 Service 매크로가 생성한 서비스들 사용 가능
//!     let user_service = UserService::instance();
//! }
//! ```

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

/// Service 매크로의 인자를 파싱하는 구조체
/// 
/// Repository와 달리 Service는 단순히 이름만 지정할 수 있습니다.
/// 
/// # 지원 형식
/// 
/// - `#[service]` - 인자 없음 (기본값 사용)
/// - `#[service(name = "auth")]` - 커스텀 이름 지정
/// 
/// # 필드
/// 
/// * `name` - 레지스트리에 등록될 서비스 이름 (선택사항, `_service` suffix 자동 추가)
/// 
/// # 기본값 규칙
/// 
/// - **name**: `{구조체명소문자}_service` (예: `UserService` → `userservice_service`)
/// 
/// # 예제
/// 
/// ```rust,ignore
/// // 기본 이름 사용
/// #[service]                    // → "paymentservice_service"
/// struct PaymentService { }
/// 
/// // 커스텀 이름 지정  
/// #[service(name = "payment")]  // → "payment_service"
/// struct PaymentProcessor { }
/// ```
struct ServiceArgs {
    name: Option<String>,
}

impl Parse for ServiceArgs {
    /// 매크로 인자를 파싱합니다.
    /// 
    /// Service 매크로는 단일 인자만 지원하므로 파싱이 단순합니다.
    /// 
    /// # 파싱 형식
    /// 
    /// ```text
    /// name = "service_name"
    /// ```
    /// 
    /// # 에러
    /// 
    /// - `name` 이외의 인자가 제공된 경우
    /// - 문법이 올바르지 않은 경우 (예: `=` 누락)
    /// 
    /// # 예제
    /// 
    /// ```rust,ignore
    /// // 빈 인자 (기본값 사용)
    /// #[service]
    /// 
    /// // name 지정
    /// #[service(name = "authentication")]
    /// ```
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if input.is_empty() {
            return Ok(ServiceArgs { name: None });
        }

        // name = "..." 파싱
        let ident: syn::Ident = input.parse()?;
        if ident != "name" {
            return Err(syn::Error::new(ident.span(), "Expected 'name'. Service macro only supports 'name' argument."));
        }

        input.parse::<Token![=]>()?;
        let lit: LitStr = input.parse()?;

        Ok(ServiceArgs {
            name: Some(lit.value()),
        })
    }
}

/// Service 매크로의 메인 구현 함수
/// 
/// 이 함수는 `#[service]` 속성이 적용된 구조체를 분석하고,
/// 싱글톤 패턴과 의존성 주입을 위한 코드를 생성합니다.
/// 
/// # 생성되는 코드 구조
/// 
/// 1. **원본 구조체**: 사용자가 정의한 구조체를 그대로 유지
/// 2. **Static 상수**: 서비스 이름을 const로 정의
/// 3. **싱글톤 저장소**: `OnceCell<Arc<T>>` static 변수
/// 4. **impl 블록**:
///    - `instance()` - 싱글톤 인스턴스 접근
///    - `new()` - 의존성 주입 생성자 (private)
/// 5. **Registry 등록**: `inventory::submit!`을 통한 자동 등록
/// 6. **Trait 구현**: `Service` trait 자동 구현
/// 
/// # 의존성 주입 규칙
/// 
/// Repository와 달리 Service는 간단한 규칙만 적용합니다:
/// 
/// ## Arc<T> 타입 자동 주입
/// ```rust,ignore
/// // 입력:
/// struct PaymentService {
///     payment_repo: Arc<PaymentRepository>,  // ServiceLocator 자동 주입
///     email_service: Arc<EmailService>,      // ServiceLocator 자동 주입
/// }
/// 
/// // 생성되는 new() 메서드:
/// fn new() -> Self {
///     Self {
///         payment_repo: ServiceLocator::get::<PaymentRepository>().clone(),
///         email_service: ServiceLocator::get::<EmailService>().clone(),
///     }
/// }
/// ```
/// 
/// ## 일반 타입 기본값 사용
/// ```rust,ignore
/// // 입력:
/// struct ConfigService {
///     retry_count: u32,           // Default::default()
///     timeout: Duration,          // Default::default()
///     settings: AppSettings,      // Default::default()
/// }
/// 
/// // 생성되는 new() 메서드:
/// fn new() -> Self {
///     Self {
///         retry_count: Default::default(),
///         timeout: Default::default(), 
///         settings: Default::default(),
///     }
/// }
/// ```
/// 
/// # 인자
/// 
/// * `args` - 매크로 속성 인자 (name)
/// * `input` - 대상 구조체의 TokenStream
/// 
/// # 반환값
/// 
/// 확장된 TokenStream (원본 구조체 + 생성된 코드)
/// 
/// # 에러
/// 
/// - 구조체가 아닌 타입에 적용된 경우 panic
/// - 인자 파싱 실패 시 컴파일 에러
/// 
/// # 예제 변환
/// 
/// **입력:**
/// ```rust,ignore
/// #[service(name = "auth")]
/// struct AuthService {
///     user_repo: Arc<UserRepository>,
///     token_service: Arc<TokenService>,
///     max_attempts: u32,
/// }
/// ```
/// 
/// **출력 (일부):**
/// ```rust,ignore
/// struct AuthService { /* 원본 */ }
/// 
/// const __AUTHSERVICE_SERVICE_NAME: &'static str = "auth_service";
/// static __AUTHSERVICE_INSTANCE: OnceCell<Arc<AuthService>> = OnceCell::new();
/// 
/// impl AuthService {
///     pub fn instance() -> Arc<Self> { /* ... */ }
///     fn new() -> Self {
///         Self {
///             user_repo: ServiceLocator::get::<UserRepository>().clone(),
///             token_service: ServiceLocator::get::<TokenService>().clone(),
///             max_attempts: Default::default(),
///         }
///     }
/// }
/// 
/// inventory::submit! { ServiceRegistration { /* ... */ } }
/// impl Service for AuthService { /* ... */ }
/// ```
pub fn implement_service(args: TokenStream, input: TokenStream) -> TokenStream {
    // 입력 파싱
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = &input.ident;

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

    // 서비스 이름 생성 - 자동으로 _service suffix 추가
    let service_name = if let Some(name) = args.name {
        // 사용자가 명시적으로 지정한 경우에도 _service suffix 추가
        format!("{}_service", name)
    } else {
        // 구조체 이름에서 자동 생성 (UserService -> userservice_service)
        format!("{}_service", struct_name.to_string().to_lowercase())
    };

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

    // 의존성 주입 코드 생성
    let field_initializers = generate_field_initializers(fields);

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

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

        // 서비스 이름을 const로 정의 (컴파일 타임 상수)
        const #service_name_const: &'static str = #service_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 service = UserService::instance();
            /// let another_service = UserService::instance();
            /// // service와 another_service는 같은 인스턴스를 가리킴
            /// 
            /// // 다른 스레드에서도 안전하게 사용 가능
            /// let handle = tokio::spawn(async move {
            ///     let service = UserService::instance();
            ///     service.process_user("123").await
            /// });
            /// ```
            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()`에서만 호출되며 직접 사용하지 않습니다.
            /// 필드 타입을 분석하여 적절한 의존성을 자동 주입합니다.
            /// 
            /// # 주입 규칙
            /// 
            /// - `Arc<T>` 타입: `ServiceLocator::get::<T>().clone()`
            /// - 기타 타입: `Default::default()`
            fn new() -> Self {
                #[allow(unused_imports)]
                use std::default::Default;
                
                Self {
                    #field_initializers
                }
            }
        }

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

        // Service trait 자동 구현
        #[::async_trait::async_trait]
        impl crate::core::registry::Service for #struct_name {
            /// 서비스 이름 반환
            /// 
            /// # 반환값
            /// 
            /// `&str` - 레지스트리에 등록된 서비스 이름 (`_service` suffix 포함)
            fn name(&self) -> &str {
                #service_name_const
            }

            /// 서비스 초기화
            /// 
            /// 서비스 시작 시 필요한 초기화 로직을 수행합니다.
            /// 기본 구현에서는 로그만 출력합니다.
            /// 
            /// # 반환값
            /// 
            /// `Result<(), Box<dyn Error>>` - 성공 시 Ok(()), 실패 시 에러
            /// 
            /// # 커스텀 초기화
            /// 
            /// 필요시 이 메서드를 오버라이드하여 커스텀 초기화 로직을 구현할 수 있습니다:
            /// 
            /// ```rust,ignore
            /// #[async_trait]
            /// impl Service for UserService {
            ///     async fn init(&self) -> Result<(), Box<dyn Error>> {
            ///         // 커스텀 초기화 로직
            ///         self.user_repo.create_indexes().await?;
            ///         println!("UserService initialized with custom logic");
            ///         Ok(())
            ///     }
            /// }
            /// ```
            async fn init(&self) -> Result<(), Box<dyn ::std::error::Error>> {
                println!("Service {} initialized", self.name());
                Ok(())
            }
        }
    };

    TokenStream::from(expanded)
}

/// 필드 초기화 코드 생성
/// 
/// 구조체의 각 필드를 분석하여 적절한 초기화 코드를 생성합니다.
/// Service 매크로는 Repository와 달리 특별한 필드 이름을 처리하지 않고,
/// 오직 `Arc<T>` 타입만 자동으로 주입합니다.
/// 
/// # 의존성 주입 규칙
/// 
/// 1. **Arc<T> 타입**: `ServiceLocator::get::<T>().clone()` - ServiceLocator에서 타입 T 검색
/// 2. **기타 타입**: `Default::default()` - 기본값 사용
/// 
/// # 인자
/// 
/// * `fields` - 구조체의 필드 정보
/// 
/// # 반환값
/// 
/// 필드 초기화 코드를 포함하는 TokenStream
/// 
/// # 생성 예시
/// 
/// ```rust,ignore
/// // 입력 구조체:
/// struct PaymentService {
///     payment_repo: Arc<PaymentRepository>, // → ServiceLocator::get::<PaymentRepository>().clone()
///     email_service: Arc<EmailService>,     // → ServiceLocator::get::<EmailService>().clone()
///     config: ServiceConfig,                // → Default::default()
///     retry_count: u32,                     // → Default::default()
/// }
/// 
/// // 생성되는 코드:
/// Self {
///     payment_repo: crate::core::registry::ServiceLocator::get::<PaymentRepository>().clone(),
///     email_service: crate::core::registry::ServiceLocator::get::<EmailService>().clone(),
///     config: Default::default(),
///     retry_count: Default::default(),
/// }
/// ```
/// 
/// # Arc<T> 타입 감지 과정
/// 
/// 1. **타입 분석**: 필드의 `syn::Type`을 분석
/// 2. **Arc 감지**: `extract_arc_inner_type()`으로 Arc<T>에서 T 추출
/// 3. **ServiceLocator 호출**: `ServiceLocator::get::<T>()`로 의존성 해결
/// 4. **Arc 복제**: 반환된 Arc를 `.clone()`으로 복사
/// 
/// # 에러 처리
/// 
/// - Arc 타입이 아닌 경우: `Default::default()` 사용
/// - ServiceLocator에서 타입을 찾을 수 없는 경우: 런타임에 panic (ServiceLocator 책임)
fn generate_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;

                // Arc<T> 타입인지 확인하고 자동 주입
                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()
                    }
                }
            });

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

/// Arc<T>에서 내부 타입 T 추출
/// 
/// `Arc<T>` 타입에서 제네릭 인자 T를 추출합니다.
/// 의존성 주입 시 ServiceLocator에서 올바른 타입을 가져오기 위해 사용됩니다.
/// 
/// # 인자
/// 
/// * `ty` - 검사할 타입 (syn::Type)
/// 
/// # 반환값
/// 
/// * `Some(&Type)` - Arc의 내부 타입 T
/// * `None` - Arc 타입이 아니거나 내부 타입을 추출할 수 없는 경우
/// 
/// # 지원하는 형태
/// 
/// - `Arc<AuthService>` → `Some(AuthService)`
/// - `Arc<TokenService>` → `Some(TokenService)`
/// - `std::sync::Arc<UserRepository>` → `Some(UserRepository)`
/// - `String` → `None`
/// - `Option<User>` → `None`
/// - `Vec<Arc<T>>` → `None` (중첩된 구조는 지원하지 않음)
/// 
/// # 구현 세부사항
/// 
/// syn의 타입 시스템을 사용하여 다음 구조를 파싱합니다:
/// 
/// ```text
/// Type::Path
///   └─ PathSegment { ident: "Arc", arguments: AngleBracketed }
///       └─ GenericArgument::Type(내부_타입)
/// ```
/// 
/// # 코드 공유
/// 
/// 이 함수는 repository.rs의 동일한 함수와 코드를 공유합니다.
/// 향후 공통 유틸리티 모듈로 추출을 고려할 수 있습니다.
/// 
/// # 예제
/// 
/// ```rust,ignore
/// // 매크로 내부에서 사용:
/// if let Some(inner_type) = extract_arc_inner_type(&field.ty) {
///     // inner_type이 UserService라면
///     quote! {
///         field_name: ServiceLocator::get::<#inner_type>().clone()  // get::<UserService>()
///     }
/// } else {
///     quote! {
///         field_name: Default::default()
///     }
/// }
/// ```
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
}