public interface Notifiable {
	// 추상 메서드: 구현체가 반드시 구현해야 함
	String getRecipientId();

	void notify(String message);

	// 기본 구현: override하지 않으면 이 구현이 사용됨 (Java 8+)
	default void notifyWithPrefix(String prefix, String message) {
		notify("[" + prefix + "] " + message);
	}
}

public interface Auditable {
	long getCreatedAt();

	String auditLog();
}

public interface Cacheable {
	String getCacheKey();

	boolean isCacheExpired(long nowMs);
}

// Notifiable, Auditable, Cacheable 세 역할을 하나의 클래스에서 동시에 수행
public class UserSession implements Notifiable, Auditable, Cacheable {
	private final String recipientId;
	private final long createdAt;
	private final long ttlMs;  // 세션 유효 기간(밀리초)

	public UserSession(String recipientId, long createdAt, long ttlMs) {
		this.recipientId = recipientId;
		this.createdAt = createdAt;
		this.ttlMs = ttlMs;
	}

	@Override
	public String getRecipientId() {
		return recipientId;
	}

	@Override
	public void notify(String message) {
		System.out.println("push to " + recipientId + ": " + message);
	}

	@Override
	public long getCreatedAt() {
		return createdAt;
	}

	@Override
	public String auditLog() {
		return "session created at " + createdAt + " for " + recipientId;
	}

	@Override
	public String getCacheKey() {
		return "session:" + recipientId;
	}

	// 현재 시각과 생성 시각의 차이가 TTL을 초과하면 만료로 판단
	@Override
	public boolean isCacheExpired(long nowMs) {
		return (nowMs - createdAt) > ttlMs;
	}
}

public interface Describable {
	String getName();
	String getCode();

	// 인터페이스는 상태 저장 없이 계산 로직만 제공
	default String displayName() {
		return "[" + getCode() + "] " + getName();
	}
}

public class ProductCategory implements Describable {
	private final String name;
	private final String code;

	public ProductCategory(String name, String code) {
		this.name = name;
		this.code = code;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getCode() {
		return code;
	}
}

// sealed interface로 결과 타입을 고정: 성공/실패 외의 경우를 추가하려면 permits 수정 필요
public sealed interface ChargeResult permits ChargeResult.Success, ChargeResult.Failure {
	record Success(String transactionId) implements ChargeResult {
	}

	record Failure(String reason) implements ChargeResult {
	}
}

public interface PaymentGateway {
	ChargeResult charge(String orderId, long amount);
}

// 실제 환경에서 사용하는 구현체: 외부 결제 API와 통신
public class TossPaymentGateway implements PaymentGateway {
	@Override
	public ChargeResult charge(String orderId, long amount) {
		// 실제 외부 API 호출 (생략)
		return new ChargeResult.Success("txn-" + orderId);
	}
}

// 테스트에서 사용하는 가짜 구현체: 외부 API 호출 없이 항상 성공을 반환
public class FakePaymentGateway implements PaymentGateway {
	@Override
	public ChargeResult charge(String orderId, long amount) {
		return new ChargeResult.Success("fake-txn-" + orderId);
	}
}

public abstract class BaseRepository<T> {
	protected final String tableName;  // 하위 클래스가 공유하는 테이블 이름

	protected BaseRepository(String tableName) {
		this.tableName = tableName;
	}

	// 공통 구현: 하위 클래스가 override하지 않으면 이 구현이 사용됨
	public List<T> findAll() {
		System.out.println("SELECT * FROM " + tableName);
		return Collections.emptyList();
	}

	// 추상 메서드: 조회 방식이 구현체마다 다르므로 하위 클래스에 위임
	public abstract Optional<T> findById(long id);

	// 템플릿 메서드: 검증 → 저장 순서를 고정하고, 세부 구현은 하위 클래스에 위임
	public T save(T entity) {
		validate(entity);
		return persist(entity);
	}

	protected abstract void validate(T entity);

	protected abstract T persist(T entity);
}

public abstract class DiscountPolicy {
	protected final long minAmount;

	protected DiscountPolicy(long minAmount) {
		this.minAmount = minAmount;
	}

	// 공통 흐름: 최소 금액 검증은 상위 클래스에서 고정
	public final long apply(long amount) {
		if (amount < minAmount) {
			return amount;
		}
		return calculate(amount);
	}

	protected abstract long calculate(long amount);
}

public class FixedDiscountPolicy extends DiscountPolicy {
	private final long discountAmount;

	public FixedDiscountPolicy(long minAmount, long discountAmount) {
		super(minAmount);
		this.discountAmount = discountAmount;
	}

	@Override
	protected long calculate(long amount) {
		return Math.max(0, amount - discountAmount);
	}
}

public interface EventHandler<T> {
	boolean canHandle(Object event);

	void handle(T event);
}

// 추상 클래스가 공통 처리(로깅 등)를 담당
public abstract class BaseEventHandler<T> implements EventHandler<T> {
	private final String handlerName;

	protected BaseEventHandler(String handlerName) {
		this.handlerName = handlerName;
	}

	// final: 하위 클래스가 처리 흐름(로깅 → doHandle) 자체를 변경하지 못하도록 봉쇄
	@Override
	public final void handle(T event) {
		System.out.println(handlerName + " 처리 시작");
		doHandle(event);
		System.out.println(handlerName + " 처리 완료");
	}

	// 하위 클래스가 실제 처리 로직만 구현: 로깅 등 공통 흐름은 관여하지 않음
	protected abstract void doHandle(T event);
}

// record: 컴팩트한 불변 데이터 객체, equals/hashCode/toString 자동 생성 (Java 16+, 14/15는 preview)
public record OrderCreatedEvent(String orderId, long amount) {
}

public class OrderCreatedHandler extends BaseEventHandler<OrderCreatedEvent> {
	public OrderCreatedHandler() {
		super("주문생성핸들러");
	}

	// instanceof 패턴 매칭(Java 16+): 타입 확인과 동시에 변수 바인딩
	@Override
	public boolean canHandle(Object event) {
		return event instanceof OrderCreatedEvent;
	}

	@Override
	protected void doHandle(OrderCreatedEvent event) {
		System.out.printf("주문 처리: orderId=%s amount=%d%n", event.orderId(), event.amount());
	}
}

// permits로 허용할 하위 타입을 명시 (sealed class: 하위 타입은 extends로 연결)
public sealed class ApiResponse permits ApiResponse.Ok, ApiResponse.Error {
	public static final class Ok extends ApiResponse {
		public final String body;
		public Ok(String body) { this.body = body; }
	}
	public static final class Error extends ApiResponse {
		public final int statusCode;
		public final String message;
		public Error(int statusCode, String message) {
			this.statusCode = statusCode;
			this.message = message;
		}
	}
}

// Java 21+: switch 패턴 매칭, sealed class이므로 default 불필요
String describe(ApiResponse response) {
	return switch (response) {
		case ApiResponse.Ok ok -> "성공: " + ok.body;
		case ApiResponse.Error error -> "오류 " + error.statusCode + ": " + error.message;
		// default 불필요: sealed이므로 모든 경우가 열거됨
	};
}

// sealed interface: record는 interface만 구현 가능 (record는 extends 불가)
public sealed interface PaymentEvent
	permits PaymentEvent.Approved, PaymentEvent.Failed, PaymentEvent.Pending {

	record Approved(String transactionId, long amount) implements PaymentEvent {
	}

	record Failed(String reason, boolean retryable) implements PaymentEvent {
	}

	// 데이터 없이 상태만 표현: 빈 바디로 선언
	record Pending() implements PaymentEvent {
	}
}

// Java 21+: 각 case가 타입 패턴으로 매칭되며, sealed이므로 default 없이 exhaustive
String describeEvent(PaymentEvent event) {
	return switch (event) {
		case PaymentEvent.Approved a -> "승인 완료: txn=" + a.transactionId();
		case PaymentEvent.Failed f -> "실패 (재시도=" + f.retryable() + "): " + f.reason();
		case PaymentEvent.Pending p -> "대기 중";
	};
}

public interface PaymentResult {
	boolean isSuccess();

	String describe();
}

public class ApprovedResult implements PaymentResult {
	private final String transactionId;

	public ApprovedResult(String transactionId) {
		this.transactionId = transactionId;
	}

	@Override
	public boolean isSuccess() {
		return true;
	}

	@Override
	public String describe() {
		return "승인: " + transactionId;
	}
}

public class FailedResult implements PaymentResult {
	private final String reason;

	public FailedResult(String reason) {
		this.reason = reason;
	}

	@Override
	public boolean isSuccess() {
		return false;
	}

	@Override
	public String describe() {
		return "실패: " + reason;
	}
}

// interface는 하위 타입이 열려있어 switch exhaustiveness 불가: 조건 분기로 처리
// 새로운 구현체가 추가되어도 이 코드에서 컴파일 오류가 발생하지 않음
String process(PaymentResult result) {
	if (result.isSuccess())
		return "완료";
	return "오류";  // 새 구현체의 처리 누락을 컴파일러가 잡아주지 못함
}

public abstract class PaymentResultBase {
	public final String requestId;
	public final long transactionFee;  // 공통 상태

	protected PaymentResultBase(String requestId, long transactionFee) {
		this.requestId = requestId;
		this.transactionFee = transactionFee;
	}

	public abstract boolean isSuccess();

	public abstract String describe();

	public String summary() {
		return "requestId=" + requestId + " fee=" + transactionFee + " success=" + isSuccess();
	}
}

public class ApprovedResultBase extends PaymentResultBase {
	public final String transactionId;

	public ApprovedResultBase(String requestId, long transactionFee, String transactionId) {
		super(requestId, transactionFee);
		this.transactionId = transactionId;
	}

	@Override
	public boolean isSuccess() {
		return true;
	}

	@Override
	public String describe() {
		return "승인: " + transactionId;
	}
}

public class FailedResultBase extends PaymentResultBase {
	public final String reason;

	public FailedResultBase(String requestId, long transactionFee, String reason) {
		super(requestId, transactionFee);
		this.reason = reason;
	}

	@Override
	public boolean isSuccess() {
		return false;
	}

	@Override
	public String describe() {
		return "실패: " + reason;
	}
}

// sealed interface + record 조합: 하위 타입 제한과 간결한 데이터 선언을 동시에 달성
public sealed interface PaymentOutcome
	permits PaymentOutcome.Approved, PaymentOutcome.Failed, PaymentOutcome.Pending {

	record Approved(String requestId, String transactionId, long transactionFee)
		implements PaymentOutcome {
	}

	record Failed(String requestId, String reason, boolean retryable)
		implements PaymentOutcome {
	}

	record Pending(String requestId)
		implements PaymentOutcome {
	}
}

// sealed이므로 default 없이 exhaustive: Pending 케이스가 빠지면 컴파일 오류 발생
String handleOutcome(PaymentOutcome outcome) {
	return switch (outcome) {
		case PaymentOutcome.Approved a -> "승인: " + a.transactionId() + " (수수료: " + a.transactionFee() + ")";
		case PaymentOutcome.Failed f -> "실패 (재시도=" + f.retryable() + "): " + f.reason();
		case PaymentOutcome.Pending p -> "처리 중: " + p.requestId();
	};
}

// interface: OrderProcessor라는 역할만 선언, 구현 세부사항 없음
public interface OrderProcessor {
	ProcessResult process(String orderId);
}

// sealed interface: 처리 결과를 Done/Rejected 두 가지로 고정 (Java 17+)
public sealed interface ProcessResult
	permits ProcessResult.Done, ProcessResult.Rejected {
	record Done(long confirmedAt) implements ProcessResult {
	}   // confirmedAt: 처리 완료 시각(epoch ms)

	record Rejected(String reason) implements ProcessResult {
	}
}

// abstract class: 공통 흐름을 담당, 하위 클래스는 doProcess만 구현
public abstract class BaseOrderProcessor implements OrderProcessor {
	@Override
	public final ProcessResult process(String orderId) {
		System.out.println("orderId=" + orderId + " 처리 시작");
		return doProcess(orderId);
	}

	protected abstract ProcessResult doProcess(String orderId);
}

public class StandardOrderProcessor extends BaseOrderProcessor {
	@Override
	protected ProcessResult doProcess(String orderId) {
		return new ProcessResult.Done(System.currentTimeMillis());
	}
}