// 1. Spring이 UserService 빈을 생성할 때 실제 구조
 
// 원본 UserService 클래스
public class UserService {
    @Transactional
    public void updateUser(Long userId) {
        this.deleteUserCache(userId);  // 여기서 this는 프록시가 아닌 실제 객체
    }
    
    @CacheEvict(value = "users", key = "#userId")
    public void deleteUserCache(Long userId) {
        // 캐시 삭제 로직
    }
}
 
// 2. Spring이 생성하는 프록시 (개념적 표현)
public class UserService$$EnhancerBySpringCGLIB extends UserService {
    private UserService target;  // 실제 UserService 인스턴스
    private TransactionInterceptor txInterceptor;
    private CacheInterceptor cacheInterceptor;
    
    @Override
    public void updateUser(Long userId) {
        // 트랜잭션 시작
        TransactionStatus tx = txInterceptor.startTransaction();
        try {
            // 실제 메서드 호출
            target.updateUser(userId);
            // 트랜잭션 커밋
            txInterceptor.commit(tx);
        } catch (Exception e) {
            // 트랜잭션 롤백
            txInterceptor.rollback(tx);
            throw e;
        }
    }
    
    @Override
    public void deleteUserCache(Long userId) {
        // 캐시 제거 처리
        cacheInterceptor.evictCache("users", userId);
        // 실제 메서드 호출
        target.deleteUserCache(userId);
    }
}

// 3. 외부에서 호출할 때 (정상 동작)
@RestController
public class UserController {
    @Autowired
    private UserService userService;  // 실제로는 프록시가 주입됨
    
    @PostMapping("/users/{id}")
    public void updateUser(@PathVariable Long id) {
        // userService는 프록시이므로 AOP가 적용됨
        userService.updateUser(id);
        /*
        실제 호출 순서:
        1. UserController → UserService$$Proxy.updateUser()
        2. Proxy가 트랜잭션 시작
        3. Proxy → 실제 UserService.updateUser()
        4. 실제 UserService 내부에서 this.deleteUserCache() 호출
           → 이때 this는 프록시가 아닌 실제 객체!
        5. 프록시를 거치지 않고 직접 deleteUserCache() 호출
           → @CacheEvict 미적용!
        */
    }
}
 
// 4. 내부 호출 시 문제 발생 과정
public class UserService {
    @Transactional
    public void updateUser(Long userId) {
        log.info("updateUser 실행 - this의 클래스: {}", this.getClass().getName());
        // 출력: UserService (프록시가 아님!)
        
        // this는 프록시가 아닌 실제 UserService 인스턴스
        this.deleteUserCache(userId);  
        // 위 호출은 아래와 동일:
        // UserService.deleteUserCache(userId) - 직접 호출
        // 프록시의 deleteUserCache()가 아님!
    }
}

[외부 호출 - 정상 동작]
Client → Proxy → AOP처리 → Target Object

[내부 호출 - AOP 미적용]
Target Object 내부에서 this.method() → 같은 객체의 메서드 직접 호출
                                      → 프록시를 거치지 않음!

// Spring이 프록시를 생성하는 과정 시뮬레이션
@Configuration
public class ProxySimulation {
    
    @Bean
    public UserService userService() {
        UserService target = new UserService();
        
        // Spring이 실제로 하는 일 (개념적 표현)
        ProxyFactory factory = new ProxyFactory(target);
        
        // 트랜잭션 어드바이저 추가
        factory.addAdvisor(new TransactionAdvisor());
        
        // 캐시 어드바이저 추가  
        factory.addAdvisor(new CacheAdvisor());
        
        // 프록시 생성 및 반환
        return (UserService) factory.getProxy();
    }
}

@Service
@Slf4j
public class PaymentService {
    
    @Autowired
    private PaymentService self;
    
    @Transactional
    public void processPayment(Long orderId) {
        log.info("결제 처리 시작 - TX: {}", 
            TransactionSynchronizationManager.getCurrentTransactionName());
        
        // 방법 1: 내부 호출 (문제 발생)
        this.savePaymentHistory(orderId);  // 같은 트랜잭션에서 실행됨
        
        // 방법 2: 프록시를 통한 호출 (정상 동작)
        self.savePaymentHistory(orderId);  // 새 트랜잭션에서 실행됨
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void savePaymentHistory(Long orderId) {
        log.info("결제 이력 저장 - TX: {}", 
            TransactionSynchronizationManager.getCurrentTransactionName());
        // REQUIRES_NEW가 작동하려면 프록시를 통해 호출되어야 함
    }
}

@Service
@EnableAsync
@Slf4j
public class NotificationService {
    
    @Autowired
    private NotificationService self;
    
    public void handleOrder(Order order) {
        // 주문 처리
        processOrder(order);
        
        // 잘못된 호출 - 동기 실행됨
        this.sendEmailNotification(order.getId());  // ❌
        
        // 올바른 호출 - 비동기 실행됨
        self.sendEmailNotification(order.getId());  // ✅
        
        log.info("주문 처리 완료");
    }
    
    @Async
    public CompletableFuture<String> sendEmailNotification(Long orderId) {
        log.info("이메일 전송 시작 - Thread: {}", 
            Thread.currentThread().getName());
        
        // 시간이 오래 걸리는 작업
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return CompletableFuture.completedFuture("Email sent for order: " + orderId);
    }
}

@Component
@Slf4j
public class AopDebugger {
    
    @PostConstruct
    public void debugProxyInfo() {
        // 1. 클래스 이름으로 확인
        log.info("Class name: {}", this.getClass().getName());
        // 프록시인 경우: $$EnhancerBySpringCGLIB$$ 포함
        
        // 2. AopUtils 활용
        log.info("Is AOP proxy: {}", AopUtils.isAopProxy(this));
        
        // 3. 메서드 실행 시 로그 추가
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        Arrays.stream(stackTrace)
            .limit(10)
            .forEach(element -> log.info("Stack: {}", element));
    }
    
    // 4. Aspect를 이용한 디버깅
    @Aspect
    @Component
    public static class DebugAspect {
        
        @Before("@annotation(org.springframework.transaction.annotation.Transactional)")
        public void debugTransaction(JoinPoint joinPoint) {
            log.info("=== Transaction Debug ===");
            log.info("Target: {}", joinPoint.getTarget().getClass().getName());
            log.info("Proxy: {}", joinPoint.getThis().getClass().getName());
            log.info("Method: {}", joinPoint.getSignature().getName());
            log.info("========================");
        }
    }
}

@RestController
@RequiredArgsConstructor
public class DebugController {
    
    private final ApplicationContext context;
    
    @GetMapping("/debug/proxy/{beanName}")
    public Map<String, Object> getProxyInfo(@PathVariable String beanName) {
        Object bean = context.getBean(beanName);
        
        Map<String, Object> info = new HashMap<>();
        info.put("beanClass", bean.getClass().getName());
        info.put("isAopProxy", AopUtils.isAopProxy(bean));
        info.put("isCglibProxy", AopUtils.isCglibProxy(bean));
        info.put("isJdkProxy", AopUtils.isJdkDynamicProxy(bean));
        info.put("targetClass", AopUtils.getTargetClass(bean).getName());
        
        if (AopUtils.isAopProxy(bean)) {
            // 프록시된 메서드 목록
            Method[] methods = AopUtils.getTargetClass(bean).getDeclaredMethods();
            List<String> proxiedMethods = Arrays.stream(methods)
                .filter(m -> m.isAnnotationPresent(Transactional.class) ||
                            m.isAnnotationPresent(Cacheable.class) ||
                            m.isAnnotationPresent(Async.class))
                .map(Method::getName)
                .collect(Collectors.toList());
            info.put("proxiedMethods", proxiedMethods);
        }
        
        return info;
    }
}

@Service
public class CommonMistakes {
    
    @Transactional  // ❌ 작동하지 않음!
    private void privateMethod() {
        // private 메서드는 프록시될 수 없음
    }
    
    @Transactional  // ❌ 작동하지 않음!
    final void finalMethod() {
        // final 메서드도 CGLIB 프록시 불가
    }
    
    @Transactional  // ✅ 정상 작동
    public void publicMethod() {
        // public 메서드만 프록시 가능
    }
}

@Service
@Slf4j
public class InitializationMistake {
    
    @Autowired
    private InitializationMistake self;
    
    @PostConstruct
    public void init() {
        // ❌ 빈 초기화 중에는 프록시가 아직 준비되지 않음
        this.loadCache();
        
        // ❌ self도 아직 완전히 초기화되지 않음
        // self.loadCache();
    }
    
    // 해결책: ApplicationListener 사용
    @Component
    public static class CacheInitializer implements ApplicationListener<ContextRefreshedEvent> {
        @Autowired
        private InitializationMistake service;
        
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
            service.loadCache();  // ✅ 컨텍스트 초기화 완료 후 호출
        }
    }
    
    @Cacheable("config")
    public String loadCache() {
        log.info("Loading cache...");
        return "config-data";
    }
}

@Service
@Slf4j
public class ConditionalService {
    
    @Value("${cache.enabled:true}")
    private boolean cacheEnabled;
    
    public void processData(String key) {
        if (cacheEnabled) {
            // ❌ 조건부로 호출해도 Self Invocation
            String data = this.getCachedData(key);
        } else {
            String data = this.getDirectData(key);
        }
    }
    
    // 해결책: 조건을 메서드 내부로 이동
    @Cacheable(value = "data", condition = "@conditionalService.cacheEnabled")
    public String getData(String key) {
        return fetchDataFromDb(key);
    }
}

@Service
public class StreamMistake {
    
    @Transactional(readOnly = true)
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
    
    public List<User> findUsers(List<Long> ids) {
        // ❌ 메서드 참조는 프록시를 거치지 않음
        return ids.stream()
            .map(this::findUser)  // Self Invocation!
            .collect(Collectors.toList());
            
        // ✅ 해결책: 별도 서비스로 분리하거나 직접 구현
        return ids.stream()
            .map(id -> userRepository.findById(id))
            .collect(Collectors.toList());
    }
}

@Service
public class ParentService {
    
    @Transactional
    public void parentMethod() {
        childMethod();  // ❌ Self Invocation
    }
    
    protected void childMethod() {
        // 트랜잭션 적용 안됨
    }
}
 
@Service
public class ChildService extends ParentService {
    
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    protected void childMethod() {
        // ❌ protected 메서드는 프록시되지 않음
        // ❌ 부모에서 호출 시 Self Invocation
    }
}