public class Stack<E> extends Vector<E> {
    public E push(E item) {
        addElement(item);
        return item;
    }
    
    public E pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return remove(size() - 1);
    }
}

Stack<String> stack = new Stack<>();
stack.push("1st");
stack.push("2nd");
stack.push("3rd");

// ❌ Vector의 메서드로 Stack 규칙 위반!
stack.add(0, "4th");

// Stack의 LIFO 규칙이 깨짐
assertEquals("3rd", stack.pop());  // 실패!
// 실제로는 "4th"가 나옴

public class Stack<E> {
    private Vector<E> elements = new Vector<>();  // 합성!
    
    public E push(E item) {
        elements.addElement(item);
        return item;
    }
    
    public E pop() {
        if (elements.isEmpty()) {
            throw new EmptyStackException();
        }
        return elements.remove(elements.size() - 1);
    }
}

public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;
    
    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }
    
    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }
    
    public int getAddCount() {
        return addCount;
    }
}

InstrumentedHashSet<String> set = new InstrumentedHashSet<>();
set.addAll(Arrays.asList("Java", "Ruby", "Scala"));

System.out.println(set.getAddCount());
// 예상: 3
// 실제: 6  ❌

public class InstrumentedHashSet<E> {
    private int addCount = 0;
    private Set<E> set;  // 합성!
    
    public InstrumentedHashSet(Set<E> set) {
        this.set = set;
    }
    
    public boolean add(E e) {
        addCount++;
        return set.add(e);
    }
    
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return set.addAll(c);
    }
    
    public int getAddCount() {
        return addCount;
    }
}

public class InstrumentedHashSet<E> implements Set<E> {
    private int addCount = 0;
    private Set<E> set;
    
    public InstrumentedHashSet(Set<E> set) {
        this.set = set;
    }
    
    @Override
    public boolean add(E e) {
        addCount++;
        return set.add(e);
    }
    
    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return set.addAll(c);
    }
    
    public int getAddCount() {
        return addCount;
    }
    
    // ✅ 포워딩 메서드들
    @Override public boolean remove(Object o) {
        return set.remove(o);
    }
    
    @Override public void clear() {
        set.clear();
    }
    
    @Override public boolean equals(Object o) {
        return set.equals(o);
    }
    
    @Override public int hashCode() {
        return set.hashCode();
    }
    
    @Override public int size() {
        return set.size();
    }
    
    @Override public boolean isEmpty() {
        return set.isEmpty();
    }
    
    @Override public boolean contains(Object o) {
        return set.contains(o);
    }
    
    @Override public Iterator<E> iterator() {
        return set.iterator();
    }
    
    @Override public Object[] toArray() {
        return set.toArray();
    }
    
    @Override public <T> T[] toArray(T[] a) {
        return set.toArray(a);
    }
    
    @Override public boolean containsAll(Collection<?> c) {
        return set.containsAll(c);
    }
    
    @Override public boolean retainAll(Collection<?> c) {
        return set.retainAll(c);
    }
    
    @Override public boolean removeAll(Collection<?> c) {
        return set.removeAll(c);
    }
}

public class Playlist {
    private List<Song> tracks = new ArrayList<>();
    private Map<String, String> singers = new HashMap<>();
    
    public void append(Song song) {
        tracks.add(song);
        singers.put(song.getSinger(), song.getTitle());
    }
    
    public List<Song> getTracks() {
        return tracks;
    }
    
    public Map<String, String> getSingers() {
        return singers;
    }
}

public class PersonalPlaylist extends Playlist {
    public void remove(Song song) {
        getTracks().remove(song);
        getSingers().remove(song.getSinger());
    }
}

public class PersonalPlaylist {
    private Playlist playlist = new Playlist();  // 합성!
    
    public void append(Song song) {
        playlist.append(song);
    }
    
    public void remove(Song song) {
        playlist.getTracks().remove(song);
        playlist.getSingers().remove(song.getSinger());
    }
}

public abstract class Phone {
    private List<Call> calls = new ArrayList<>();
    
    public Money calculateFee() {
        Money result = Money.ZERO;
        
        for(Call call : calls) {
            result = result.plus(calculateCallFee(call));
        }
        
        return result;
    }
    
    protected abstract Money calculateCallFee(Call call);
}

public class RegularPhone extends Phone {
    private Money amount;
    private Duration seconds;
    
    public RegularPhone(Money amount, Duration seconds) {
        this.amount = amount;
        this.seconds = seconds;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        return amount.times(call.getDuration().getSeconds() / seconds.getSeconds());
    }
}

public class NightlyDiscountPhone extends Phone {
    private static final int LATE_NIGHT_HOUR = 22;
    
    private Money nightlyAmount;
    private Money regularAmount;
    private Duration seconds;
    
    public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, 
                                Duration seconds) {
        this.nightlyAmount = nightlyAmount;
        this.regularAmount = regularAmount;
        this.seconds = seconds;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
            return nightlyAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
        } else {
            return regularAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
        }
    }
}

public class TaxableRegularPhone extends RegularPhone {
    private double taxRate;
    
    public TaxableRegularPhone(Money amount, Duration seconds, double taxRate) {
        super(amount, seconds);
        this.taxRate = taxRate;
    }
    
    @Override
    public Money calculateFee() {
        // ❌ super 호출로 부모에 강하게 결합
        Money fee = super.calculateFee();
        return fee.plus(fee.times(taxRate));
    }
}

public abstract class Phone {
    private List<Call> calls = new ArrayList<>();
    
    public Money calculateFee() {
        Money result = Money.ZERO;
        
        for(Call call : calls) {
            result = result.plus(calculateCallFee(call));
        }
        
        // ✅ 훅 메서드 호출
        return afterCalculated(result);
    }
    
    protected abstract Money calculateCallFee(Call call);
    
    // ✅ 훅 메서드: 기본 구현 제공
    protected Money afterCalculated(Money fee) {
        return fee;
    }
}

public class RegularPhone extends Phone {
    private Money amount;
    private Duration seconds;
    
    public RegularPhone(Money amount, Duration seconds) {
        this.amount = amount;
        this.seconds = seconds;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        return amount.times(call.getDuration().getSeconds() / seconds.getSeconds());
    }
    
    // afterCalculated는 오버라이드 불필요 (기본 구현 사용)
}

public class NightlyDiscountPhone extends Phone {
    // ... 필드 생략
    
    @Override
    protected Money calculateCallFee(Call call) {
        if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
            return nightlyAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
        } else {
            return regularAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
        }
    }
    
    // afterCalculated는 오버라이드 불필요 (기본 구현 사용)
}

public class TaxableRegularPhone extends RegularPhone {
    private double taxRate;
    
    public TaxableRegularPhone(Money amount, Duration seconds, double taxRate) {
        super(amount, seconds);
        this.taxRate = taxRate;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.plus(fee.times(taxRate));
    }
}

public class TaxableNightlyDiscountPhone extends NightlyDiscountPhone {
    private double taxRate;
    
    public TaxableNightlyDiscountPhone(Money nightlyAmount, Money regularAmount, 
                                       Duration seconds, double taxRate) {
        super(nightlyAmount, regularAmount, seconds);
        this.taxRate = taxRate;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.plus(fee.times(taxRate));
    }
}

public class RateDiscountableRegularPhone extends RegularPhone {
    private Money discountAmount;
    
    public RateDiscountableRegularPhone(Money amount, Duration seconds, 
                                        Money discountAmount) {
        super(amount, seconds);
        this.discountAmount = discountAmount;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.minus(discountAmount);
    }
}

public class RateDiscountableNightlyDiscountPhone extends NightlyDiscountPhone {
    private Money discountAmount;
    
    public RateDiscountableNightlyDiscountPhone(Money nightlyAmount, 
                                                Money regularAmount, 
                                                Duration seconds, 
                                                Money discountAmount) {
        super(nightlyAmount, regularAmount, seconds);
        this.discountAmount = discountAmount;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.minus(discountAmount);
    }
}

public class TaxableAndRateDiscountableRegularPhone extends TaxableRegularPhone {
    private Money discountAmount;
    
    public TaxableAndRateDiscountableRegularPhone(Money amount, Duration seconds, 
                                                   double taxRate, 
                                                   Money discountAmount) {
        super(amount, seconds, taxRate);
        this.discountAmount = discountAmount;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        // 세금 먼저 (부모의 afterCalculated)
        return super.afterCalculated(fee).minus(discountAmount);
    }
}

public class RateDiscountableAndTaxableRegularPhone 
        extends RateDiscountableRegularPhone {
    private double taxRate;
    
    public RateDiscountableAndTaxableRegularPhone(Money amount, Duration seconds, 
                                                   Money discountAmount, 
                                                   double taxRate) {
        super(amount, seconds, discountAmount);
        this.taxRate = taxRate;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        // 할인 먼저 (부모의 afterCalculated)
        return super.afterCalculated(fee).plus(fee.times(taxRate));
    }
}

public class TaxableAndRateDiscountableNightlyDiscountPhone 
        extends TaxableNightlyDiscountPhone {
    // ... 동일한 패턴
}

public class RateDiscountableAndTaxableNightlyDiscountPhone 
        extends RateDiscountableNightlyDiscountPhone {
    // ... 동일한 패턴
}

public interface RatePolicy {
    Money calculateFee(Phone phone);
}

public abstract class BasicRatePolicy implements RatePolicy {
    @Override
    public Money calculateFee(Phone phone) {
        Money result = Money.ZERO;
        
        for(Call call : phone.getCalls()) {
            result = result.plus(calculateCallFee(call));
        }
        
        return result;
    }
    
    protected abstract Money calculateCallFee(Call call);
}

public class RegularPolicy extends BasicRatePolicy {
    private Money amount;
    private Duration seconds;
    
    public RegularPolicy(Money amount, Duration seconds) {
        this.amount = amount;
        this.seconds = seconds;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        return amount.times(call.getDuration().getSeconds() / seconds.getSeconds());
    }
}

public class NightlyDiscountPolicy extends BasicRatePolicy {
    private static final int LATE_NIGHT_HOUR = 22;
    
    private Money nightlyAmount;
    private Money regularAmount;
    private Duration seconds;
    
    public NightlyDiscountPolicy(Money nightlyAmount, Money regularAmount, 
                                 Duration seconds) {
        this.nightlyAmount = nightlyAmount;
        this.regularAmount = regularAmount;
        this.seconds = seconds;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
            return nightlyAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
        }
        
        return regularAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
    }
}

public class Phone {
    private RatePolicy ratePolicy;  // ✅ 합성!
    private List<Call> calls = new ArrayList<>();
    
    public Phone(RatePolicy ratePolicy) {
        this.ratePolicy = ratePolicy;
    }
    
    public List<Call> getCalls() {
        return Collections.unmodifiableList(calls);
    }
    
    public Money calculateFee() {
        return ratePolicy.calculateFee(this);
    }
}

Phone phone = new Phone(
    new RegularPolicy(Money.wons(10), Duration.ofSeconds(10))
);

Phone phone = new Phone(
    new NightlyDiscountPolicy(
        Money.wons(5),    // 심야 요금
        Money.wons(10),   // 일반 요금
        Duration.ofSeconds(10)
    )
);

public abstract class AdditionalRatePolicy implements RatePolicy {
    private RatePolicy next;  // ✅ 다음 정책
    
    public AdditionalRatePolicy(RatePolicy next) {
        this.next = next;
    }
    
    @Override
    public Money calculateFee(Phone phone) {
        // 1. 다음 정책의 요금 계산
        Money fee = next.calculateFee(phone);
        
        // 2. 부가 정책 적용
        return afterCalculated(fee);
    }
    
    protected abstract Money afterCalculated(Money fee);
}

public class TaxablePolicy extends AdditionalRatePolicy {
    private double taxRate;
    
    public TaxablePolicy(double taxRate, RatePolicy next) {
        super(next);
        this.taxRate = taxRate;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.plus(fee.times(taxRate));
    }
}

public class RateDiscountablePolicy extends AdditionalRatePolicy {
    private Money discountAmount;
    
    public RateDiscountablePolicy(Money discountAmount, RatePolicy next) {
        super(next);
        this.discountAmount = discountAmount;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.minus(discountAmount);
    }
}

Phone phone = new Phone(
    new TaxablePolicy(0.05,  // 5% 세금
        new RegularPolicy(
            Money.wons(100), 
            Duration.ofSeconds(10)
        )
    )
);

Phone phone = new Phone(
    new TaxablePolicy(0.05,  // 5% 세금 (마지막)
        new RateDiscountablePolicy(Money.wons(1000),  // 1000원 할인 (중간)
            new RegularPolicy(
                Money.wons(100), 
                Duration.ofSeconds(10)
            )  // 기본 요금 (처음)
        )
    )
);

Phone phone = new Phone(
    new RateDiscountablePolicy(Money.wons(1000),  // 1000원 할인 (마지막)
        new TaxablePolicy(0.05,  // 5% 세금 (중간)
            new RegularPolicy(
                Money.wons(100), 
                Duration.ofSeconds(10)
            )  // 기본 요금 (처음)
        )
    )
);

Phone phone = new Phone(
    new RateDiscountablePolicy(Money.wons(1000),
        new TaxablePolicy(0.05,
            new NightlyDiscountPolicy(
                Money.wons(5),    // 심야 요금
                Money.wons(10),   // 일반 요금
                Duration.ofSeconds(10)
            )
        )
    )
);

public class FixedFeePolicy extends BasicRatePolicy {
    private Money monthlyFee;
    
    public FixedFeePolicy(Money monthlyFee) {
        this.monthlyFee = monthlyFee;
    }
    
    @Override
    protected Money calculateCallFee(Call call) {
        return Money.ZERO;  // 통화 요금 없음
    }
    
    @Override
    public Money calculateFee(Phone phone) {
        return monthlyFee;  // 월정액만
    }
}

// 고정 요금제만
Phone phone = new Phone(
    new FixedFeePolicy(Money.wons(50000))
);

// 고정 요금제 + 세금
Phone phone = new Phone(
    new TaxablePolicy(0.05,
        new FixedFeePolicy(Money.wons(50000))
    )
);

// 고정 요금제 + 할인 + 세금
Phone phone = new Phone(
    new TaxablePolicy(0.05,
        new RateDiscountablePolicy(Money.wons(5000),
            new FixedFeePolicy(Money.wons(50000))
        )
    )
);

public class ContractDiscountPolicy extends AdditionalRatePolicy {
    private Money discountAmount;
    
    public ContractDiscountPolicy(Money discountAmount, RatePolicy next) {
        super(next);
        this.discountAmount = discountAmount;
    }
    
    @Override
    protected Money afterCalculated(Money fee) {
        return fee.minus(discountAmount);
    }
}

// 일반 요금제 + 약정 할인
Phone phone = new Phone(
    new ContractDiscountPolicy(Money.wons(3000),
        new RegularPolicy(Money.wons(100), Duration.ofSeconds(10))
    )
);

// 일반 요금제 + 약정 할인 + 기본 할인 + 세금
Phone phone = new Phone(
    new TaxablePolicy(0.05,
        new RateDiscountablePolicy(Money.wons(1000),
            new ContractDiscountPolicy(Money.wons(3000),
                new RegularPolicy(Money.wons(100), Duration.ofSeconds(10))
            )
        )
    )
);

// 기본 로거
public abstract class Logger {
    public void log(String message) {
        String formatted = formatMessage(message);
        writeLog(formatted);
    }
    
    protected abstract String formatMessage(String message);
    protected abstract void writeLog(String message);
}

// 파일 로거
public class FileLogger extends Logger {
    private String filePath;
    
    @Override
    protected String formatMessage(String message) {
        return message;
    }
    
    @Override
    protected void writeLog(String message) {
        // 파일에 쓰기
    }
}

// 콘솔 로거
public class ConsoleLogger extends Logger {
    @Override
    protected String formatMessage(String message) {
        return message;
    }
    
    @Override
    protected void writeLog(String message) {
        System.out.println(message);
    }
}

// 로그 처리 전략 인터페이스
public interface LogStrategy {
    void log(String message);
}

// 기본 파일 로거
public class FileLogStrategy implements LogStrategy {
    private String filePath;
    
    @Override
    public void log(String message) {
        // 파일에 쓰기
    }
}

// 기본 콘솔 로거
public class ConsoleLogStrategy implements LogStrategy {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

// 부가 기능 데코레이터
public abstract class LogDecorator implements LogStrategy {
    protected LogStrategy wrapped;
    
    public LogDecorator(LogStrategy wrapped) {
        this.wrapped = wrapped;
    }
    
    @Override
    public void log(String message) {
        String processed = process(message);
        wrapped.log(processed);
    }
    
    protected abstract String process(String message);
}

// 타임스탬프 데코레이터
public class TimestampDecorator extends LogDecorator {
    public TimestampDecorator(LogStrategy wrapped) {
        super(wrapped);
    }
    
    @Override
    protected String process(String message) {
        return LocalDateTime.now() + " " + message;
    }
}

// 로그 레벨 데코레이터
public class LevelDecorator extends LogDecorator {
    private Level level;
    
    public LevelDecorator(Level level, LogStrategy wrapped) {
        super(wrapped);
        this.level = level;
    }
    
    @Override
    protected String process(String message) {
        return "[" + level + "] " + message;
    }
}

// 암호화 데코레이터
public class EncryptionDecorator extends LogDecorator {
    public EncryptionDecorator(LogStrategy wrapped) {
        super(wrapped);
    }
    
    @Override
    protected String process(String message) {
        return encrypt(message);
    }
    
    private String encrypt(String message) {
        // 암호화 로직
        return message;
    }
}

// 타임스탬프 + 레벨 + 파일 로거
LogStrategy logger = new TimestampDecorator(
    new LevelDecorator(Level.INFO,
        new FileLogStrategy("app.log")
    )
);

// 암호화 + 타임스탬프 + 콘솔 로거
LogStrategy secureLogger = new EncryptionDecorator(
    new TimestampDecorator(
        new ConsoleLogStrategy()
    )
);

// 순서 변경도 자유롭게
LogStrategy logger2 = new LevelDecorator(Level.ERROR,
    new TimestampDecorator(
        new EncryptionDecorator(
            new FileLogStrategy("error.log")
        )
    )
);

// 기본 버튼
public class Button {
    protected String text;
    
    public void render() {
        System.out.println("Button: " + text);
    }
}

// 테두리 버튼
public class BorderButton extends Button {
    @Override
    public void render() {
        System.out.println("┌─────────┐");
        super.render();
        System.out.println("└─────────┘");
    }
}

// 그림자 버튼
public class ShadowButton extends Button {
    @Override
    public void render() {
        super.render();
        System.out.println("  ▓▓▓▓▓▓▓");
    }
}

// 테두리 + 그림자 버튼 (중복!)
public class BorderShadowButton extends BorderButton {
    @Override
    public void render() {
        super.render();
        System.out.println("  ▓▓▓▓▓▓▓");
    }
}

// 그림자 + 테두리 버튼 (다른 순서, 또 중복!)
public class ShadowBorderButton extends ShadowButton {
    @Override
    public void render() {
        System.out.println("┌─────────┐");
        System.out.println("Button: " + text);
        System.out.println("└─────────┘");
        System.out.println("  ▓▓▓▓▓▓▓");
    }
}

// 컴포넌트 인터페이스
public interface Component {
    void render();
}

// 기본 버튼
public class Button implements Component {
    private String text;
    
    public Button(String text) {
        this.text = text;
    }
    
    @Override
    public void render() {
        System.out.println("Button: " + text);
    }
}

// 스타일 데코레이터
public abstract class ComponentDecorator implements Component {
    protected Component component;
    
    public ComponentDecorator(Component component) {
        this.component = component;
    }
}

// 테두리 스타일
public class BorderDecorator extends ComponentDecorator {
    public BorderDecorator(Component component) {
        super(component);
    }
    
    @Override
    public void render() {
        System.out.println("┌─────────┐");
        component.render();
        System.out.println("└─────────┘");
    }
}

// 그림자 스타일
public class ShadowDecorator extends ComponentDecorator {
    public ShadowDecorator(Component component) {
        super(component);
    }
    
    @Override
    public void render() {
        component.render();
        System.out.println("  ▓▓▓▓▓▓▓");
    }
}

// 색상 스타일
public class ColorDecorator extends ComponentDecorator {
    private String color;
    
    public ColorDecorator(String color, Component component) {
        super(component);
        this.color = color;
    }
    
    @Override
    public void render() {
        System.out.println("[" + color + "]");
        component.render();
    }
}

// 테두리 + 그림자
Component button1 = new BorderDecorator(
    new ShadowDecorator(
        new Button("Submit")
    )
);

// 색상 + 테두리 + 그림자
Component button2 = new ColorDecorator("blue",
    new BorderDecorator(
        new ShadowDecorator(
            new Button("Cancel")
        )
    )
);

// 런타임에 동적으로 추가
Component button = new Button("Click");
if (needsBorder) {
    button = new BorderDecorator(button);
}
if (needsShadow) {
    button = new ShadowDecorator(button);
}

// 기본 스트림
public abstract class Stream {
    public abstract byte[] read();
}

// 파일 스트림
public class FileStream extends Stream {
    @Override
    public byte[] read() {
        // 파일에서 읽기
    }
}

// 압축 파일 스트림
public class CompressedFileStream extends FileStream {
    @Override
    public byte[] read() {
        byte[] data = super.read();
        return decompress(data);
    }
}

// 암호화 파일 스트림
public class EncryptedFileStream extends FileStream {
    @Override
    public byte[] read() {
        byte[] data = super.read();
        return decrypt(data);
    }
}

// 압축 + 암호화 파일 스트림 (중복!)
public class CompressedEncryptedFileStream extends CompressedFileStream {
    @Override
    public byte[] read() {
        byte[] data = super.read();
        return decrypt(data);
    }
}

// 암호화 + 압축 파일 스트림 (다른 순서!)
public class EncryptedCompressedFileStream extends EncryptedFileStream {
    @Override
    public byte[] read() {
        byte[] data = super.read();
        return decompress(data);
    }
}

// 스트림 인터페이스
public abstract class InputStream {
    public abstract int read() throws IOException;
}

// 기본 파일 스트림
public class FileInputStream extends InputStream {
    @Override
    public int read() throws IOException {
        // 파일에서 읽기
    }
}

// 필터 스트림 (데코레이터)
public abstract class FilterInputStream extends InputStream {
    protected InputStream in;
    
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
    
    @Override
    public int read() throws IOException {
        return in.read();
    }
}

// 압축 해제 필터
public class DecompressionInputStream extends FilterInputStream {
    public DecompressionInputStream(InputStream in) {
        super(in);
    }
    
    @Override
    public int read() throws IOException {
        int data = in.read();
        return decompress(data);
    }
}

// 복호화 필터
public class DecryptionInputStream extends FilterInputStream {
    public DecryptionInputStream(InputStream in) {
        super(in);
    }
    
    @Override
    public int read() throws IOException {
        int data = in.read();
        return decrypt(data);
    }
}

// 버퍼링 필터
public class BufferedInputStream extends FilterInputStream {
    private byte[] buffer;
    
    public BufferedInputStream(InputStream in) {
        super(in);
        this.buffer = new byte[8192];
    }
    
    @Override
    public int read() throws IOException {
        // 버퍼링 로직
    }
}

// 파일 → 압축 해제 → 복호화
InputStream stream1 = new DecryptionInputStream(
    new DecompressionInputStream(
        new FileInputStream("data.bin")
    )
);

// 파일 → 복호화 → 압축 해제 → 버퍼링
InputStream stream2 = new BufferedInputStream(
    new DecompressionInputStream(
        new DecryptionInputStream(
            new FileInputStream("secure.dat")
        )
    )
);

// 할인 정책 인터페이스
public interface DiscountPolicy {
    Money calculate(Money price);
}

// 기본 정책: 금액 할인
public class AmountDiscount implements DiscountPolicy {
    private Money discountAmount;
    
    public AmountDiscount(Money amount) {
        this.discountAmount = amount;
    }
    
    @Override
    public Money calculate(Money price) {
        return price.minus(discountAmount);
    }
}

// 기본 정책: 비율 할인
public class PercentDiscount implements DiscountPolicy {
    private double percent;
    
    public PercentDiscount(double percent) {
        this.percent = percent;
    }
    
    @Override
    public Money calculate(Money price) {
        return price.minus(price.times(percent));
    }
}

// 부가 정책 기본 클래스
public abstract class DiscountDecorator implements DiscountPolicy {
    protected DiscountPolicy base;
    
    public DiscountDecorator(DiscountPolicy base) {
        this.base = base;
    }
}

// 중복 할인
public class DuplicateDiscount extends DiscountDecorator {
    public DuplicateDiscount(DiscountPolicy base) {
        super(base);
    }
    
    @Override
    public Money calculate(Money price) {
        Money discounted = base.calculate(price);
        return base.calculate(discounted);
    }
}

// 조건부 할인
public class ConditionalDiscount extends DiscountDecorator {
    private Money minimumAmount;
    
    public ConditionalDiscount(Money minimum, DiscountPolicy base) {
        super(base);
        this.minimumAmount = minimum;
    }
    
    @Override
    public Money calculate(Money price) {
        if (price.isGreaterThan(minimumAmount)) {
            return base.calculate(price);
        }
        return price;
    }
}

// 한도 할인
public class CappedDiscount extends DiscountDecorator {
    private Money maxDiscount;
    
    public CappedDiscount(Money maxDiscount, DiscountPolicy base) {
        super(base);
        this.maxDiscount = maxDiscount;
    }
    
    @Override
    public Money calculate(Money price) {
        Money discounted = base.calculate(price);
        Money discount = price.minus(discounted);
        
        if (discount.isGreaterThan(maxDiscount)) {
            return price.minus(maxDiscount);
        }
        return discounted;
    }
}

// 10% 할인을 2회 적용 (중복)
DiscountPolicy policy1 = new DuplicateDiscount(
    new PercentDiscount(0.1)
);

// 1000원 할인, 단 10000원 이상일 때만, 최대 2000원까지
DiscountPolicy policy2 = new CappedDiscount(Money.wons(2000),
    new ConditionalDiscount(Money.wons(10000),
        new AmountDiscount(Money.wons(1000))
    )
);

// 사용
Money originalPrice = Money.wons(15000);
Money finalPrice = policy2.calculate(originalPrice);

// ❌ 너무 많은 래핑
Component component = new Decorator1(
    new Decorator2(
        new Decorator3(
            new Decorator4(
                new Decorator5(
                    new Decorator6(
                        new BaseComponent()
                    )
                )
            )
        )
    )
);

// ✅ 필요한 만큼만
Component component = new Decorator1(
    new Decorator2(
        new BaseComponent()
    )
);

/**
 * 올바른 순서:
 * 1. Compression (압축)
 * 2. Encryption (암호화)
 * 3. Buffering (버퍼링)
 * 
 * 잘못된 순서:
 * Buffering → Compression → Encryption
 * (버퍼링이 가장 안쪽에 있으면 효과 없음)
 */

// 디버깅을 위한 toString 구현
public abstract class LogDecorator implements LogStrategy {
    @Override
    public String toString() {
        return getClass().getSimpleName() + 
               "(" + wrapped.toString() + ")";
    }
}

// 출력: TimestampDecorator(LevelDecorator(FileLogStrategy))