/**
 * 도메인 이벤트 마커 인터페이스
 */
public interface DomainEvent {
}

public class Events {
    private static ThreadLocal<ApplicationEventPublisher> publisherLocal = new ThreadLocal<>();

    public static void publish(DomainEvent event) {
        if (event == null) {
            return;
        }
        if (publisherLocal.get() != null) {
            publisherLocal.get().publishEvent(event);
        }
    }

    static void setPublisher(ApplicationEventPublisher publisher) {
        publisherLocal.set(publisher);
    }


    static void reset() {
        publisherLocal.remove();
    }
}

@Aspect
@Component
@Slf4j
public class EventPublisherAspect implements ApplicationEventPublisherAware {

    private ApplicationEventPublisher publisher;
    private ThreadLocal<Boolean> appliedLocal = new ThreadLocal<>();

    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object handleEvent(ProceedingJoinPoint joinPoint) throws Throwable {
        Boolean appliedValue = appliedLocal.get();
        boolean nested;
        if (appliedValue != null && appliedValue) {
            nested = true;
        } else {
            nested = false;
            appliedLocal.set(Boolean.TRUE);
        }
        if (!nested) Events.setPublisher(publisher);
        try {
            return joinPoint.proceed();
        } finally {
            if (!nested) {
                Events.reset();
                appliedLocal.remove();
            }
        }
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.publisher = eventPublisher;
    }
}

/**
 * 협력사 차단 이벤트
 * <p>
 *     1. 관리하는 업체를 상위 협력사로 이관
 * </p>
 * @see PartnerEventHandler#handle(PartnerBlockedEvent)
 */
@Value
public class PartnerBlockedEvent implements DomainEvent {
    @NonNull
    private Partner blockedPartner;
    @NonNull
    private User publishUser;
}

@Entity
public class Partner implements User {
    // ...
    /**
     * 현 협력사를 차단
     * @param user 차단하는 사용자
     */
    public void block(User user) {
        // 자기자신을 차단할 수 없음
        if (partnerNo.equals(user.getPartnerNo())) {
            throw new ImpossibleBlockException("Can't block myself : " + userId);
        }
        this.block = true;
        this.cau.update(user);    // 마지막 수정자, 수정일시 변경
        // 차단 도메인 이벤트 발행 !!!
        Events.publish(new PartnerBlockedEvent(this, user));
    }
}

/**
 * 협력사 도메인 이벤트 구독 컴포넌트
 */
@Component
@Slf4j
public class PartnerEventSubscriber {
    private final CompanyCommander companyCommander;

    @Autowired
    public PartnerEventSubscriber(CompanyCommander companyCommander) {
        this.companyCommander = companyCommander;
    }

    /**
     * 협력사 차단 이벤트 구독 처리 - 동일 트랜잭션 내 처리(BEFORE_COMMIT)
     * <p>
     *     협력사가 관리하는 하위 업체들을 상위 업체들로 이관
     * </p>
     * @param event 협력사 차단 이벤트
     */
    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
    // @Async 비동기처리 가능
    public void subscribe(PartnerBlockedEvent event) {
        // 차단된 협력사
        Partner blockedPartner = event.getBlockedPartner();
        companyCommander.moveCompanies(blockedPartner);
        // ...
        // 구독 내 이벤트 발행이므로 정상적으로 발행되지 않음 !!!
        anotherPatner.block(event.getPublishUser());
    }
}