public class FixedFeePolicy extends BasicRatePolicy {
    private Money amount;      // 단위 요금
    private Duration seconds;  // 단위 시간

    public FixedFeePolicy(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 DateTimeInterval {
    private LocalDateTime from;
    private LocalDateTime to;

    // 정적 팩토리 메서드들
    public static DateTimeInterval of(LocalDateTime from, LocalDateTime to) {
        return new DateTimeInterval(from, to);
    }

    public static DateTimeInterval toMidnight(LocalDateTime from) {
        return new DateTimeInterval(
                from,
                LocalDateTime.of(from.toLocalDate(), LocalTime.of(23, 59, 59))
        );
    }

    public static DateTimeInterval fromMidnight(LocalDateTime to) {
        return new DateTimeInterval(
                LocalDateTime.of(to.toLocalDate(), LocalTime.of(0, 0)),
                to
        );
    }

    public static DateTimeInterval during(LocalDate date) {
        return new DateTimeInterval(
                LocalDateTime.of(date, LocalTime.of(0, 0)),
                LocalDateTime.of(date, LocalTime.of(23, 59, 59))
        );
    }

    // 핵심 메서드: 일자별로 분리
    public List<DateTimeInterval> splitByDay() {
        if (days() > 0) {
            return split(days());
        }
        return Arrays.asList(this);
    }

    private List<DateTimeInterval> split(long days) {
        List<DateTimeInterval> result = new ArrayList<>();
        addFirstDay(result);      // 첫날: from ~ 자정
        addMiddleDays(result, days); // 중간날들: 0시 ~ 자정
        addLastDay(result);       // 마지막날: 자정 ~ to
        return result;
    }
}

public class Call {
    private DateTimeInterval interval;

    public Call(LocalDateTime from, LocalDateTime to) {
        this.interval = DateTimeInterval.of(from, to);
    }

    public Duration getDuration() {
        return interval.duration();
    }

    public List<DateTimeInterval> splitByDay() {
        return interval.splitByDay();
    }

    public DateTimeInterval getInterval() {
        return interval;
    }
}

public class TimeOfDayDiscountPolicy extends BasicRatePolicy {
    private List<LocalTime> starts = new ArrayList<>();
    private List<LocalTime> ends = new ArrayList<>();
    private List<Duration> durations = new ArrayList<>();
    private List<Money> amounts = new ArrayList<>();

    @Override
    protected Money calculateCallFee(Call call) {
        Money result = Money.ZERO;

        // 일자별로 분리
        for (DateTimeInterval interval : call.splitByDay()) {
            // 각 시간대별 규칙 적용
            for (int loop = 0; loop < starts.size(); loop++) {
                result = result.plus(
                        amounts.get(loop).times(
                                Duration.between(
                                        from(interval, starts.get(loop)),
                                        to(interval, ends.get(loop))
                                ).getSeconds() / durations.get(loop).getSeconds()
                        )
                );
            }
        }

        return result;
    }

    private LocalTime from(DateTimeInterval interval, LocalTime from) {
        return interval.getFrom().toLocalTime().isBefore(from)
                ? from
                : interval.getFrom().toLocalTime();
    }

    private LocalTime to(DateTimeInterval interval, LocalTime to) {
        return interval.getTo().toLocalTime().isAfter(to)
                ? to
                : interval.getTo().toLocalTime();
    }
}

public class DayOfWeekDiscountRule {
    private List<DayOfWeek> dayOfWeeks = new ArrayList<>();
    private Duration duration = Duration.ZERO;
    private Money amount = Money.ZERO;

    public DayOfWeekDiscountRule(List<DayOfWeek> dayOfWeeks,
            Duration duration,
            Money amount) {
        this.dayOfWeeks = dayOfWeeks;
        this.duration = duration;
        this.amount = amount;
    }

    public Money calculate(DateTimeInterval interval) {
        if (dayOfWeeks.contains(interval.getFrom().getDayOfWeek())) {
            return amount.times(
                    interval.duration().getSeconds() / duration.getSeconds()
            );
        }
        return Money.ZERO;
    }
}

public class DayOfWeekDiscountPolicy extends BasicRatePolicy {
    private List<DayOfWeekDiscountRule> rules = new ArrayList<>();

    public DayOfWeekDiscountPolicy(List<DayOfWeekDiscountRule> rules) {
        this.rules = rules;
    }

    @Override
    protected Money calculateCallFee(Call call) {
        Money result = Money.ZERO;

        // 일자별로 분리
        for (DateTimeInterval interval : call.getInterval().splitByDay()) {
            // 각 규칙 적용
            for (DayOfWeekDiscountRule rule : rules) {
                result = result.plus(rule.calculate(interval));
            }
        }

        return result;
    }
}

public class DurationDiscountRule extends FixedFeePolicy {
    private Duration from;  // 구간 시작
    private Duration to;    // 구간 종료

    public DurationDiscountRule(Duration from, Duration to,
            Money amount, Duration seconds) {
        super(amount, seconds);
        this.from = from;
        this.to = to;
    }

    public Money calculate(Call call) {
        // 통화 시간이 구간 범위를 벗어나면 0원
        if (call.getDuration().compareTo(to) > 0) {
            return Money.ZERO;
        }
        if (call.getDuration().compareTo(from) < 0) {
            return Money.ZERO;
        }

        // 부모 클래스 재사용을 위한 임시 Phone 생성
        Phone phone = new Phone(null);
        phone.call(new Call(
                call.getFrom().plus(from),
                call.getDuration().compareTo(to) > 0
                        ? call.getFrom().plus(to)
                        : call.getTo()
        ));

        return super.calculateFee(phone);
    }
}

public class DurationDiscountPolicy extends BasicRatePolicy {
    private List<DurationDiscountRule> rules = new ArrayList<>();

    public DurationDiscountPolicy(List<DurationDiscountRule> rules) {
        this.rules = rules;
    }

    @Override
    protected Money calculateCallFee(Call call) {
        Money result = Money.ZERO;

        for (DurationDiscountRule rule : rules) {
            result = result.plus(rule.calculate(call));
        }

        return result;
    }
}

public class ReservationAgency {
    public Reservation reserve(Screening screening,
            Customer customer,
            int audienceCount) {
        Movie movie = screening.getMovie();

        boolean discountable = false;

        // 조건 로직 1: 할인 조건 판단
        for (DiscountCondition condition : movie.getDiscountConditions()) {
            if (condition.getType() == DiscountConditionType.PERIOD) {
                // 기간 조건인 경우
                // ... 복잡한 로직
            } else {
                // 회차 조건인 경우
                // ... 복잡한 로직
            }

            if (discountable) {
                break;
            }
        }

        Money fee;

        // 조건 로직 2: 할인 정책 판단
        if (discountable) {
            Money discountAmount = Money.ZERO;

            switch (movie.getMovieType()) {
                case AMOUNT_DISCOUNT:
                    // 금액 할인 정책
                    discountAmount = movie.getDiscountAmount();
                    break;
                case PERCENT_DISCOUNT:
                    // 비율 할인 정책
                    discountAmount = movie.getFee()
                            .times(movie.getDiscountPercent());
                    break;
                case NONE_DISCOUNT:
                    // 할인 없음
                    discountAmount = Money.ZERO;
                    break;
            }

            fee = movie.getFee()
                    .minus(discountAmount)
                    .times(audienceCount);
        } else {
            fee = movie.getFee().times(audienceCount);
        }

        return new Reservation(customer, screening, fee, audienceCount);
    }
}

public abstract class DiscountPolicy {
    private List<DiscountCondition> conditions = new ArrayList<>();

    public DiscountPolicy(DiscountCondition... conditions) {
        this.conditions = Arrays.asList(conditions);
    }

    public Money calculateDiscountAmount(Screening screening) {
        for (DiscountCondition each : conditions) {
            if (each.isSatisfiedBy(screening)) {
                return getDiscountAmount(screening);
            }
        }
        return screening.getMovieFee();
    }

    abstract protected Money getDiscountAmount(Screening screening);
}

public class Movie {
    private DiscountPolicy discountPolicy;

    public Money calculateMovieFee(Screening screening) {
        // 조건 로직 없음!
        // 단순히 메시지 전송
        return fee.minus(discountPolicy.calculateDiscountAmount(screening));
    }
}

public class Movie {
    private String title;        // ✅ private 데이터
    private Duration runningTime;
    private Money fee;

    // public 메서드로만 접근
    public Money getFee() {
        return fee;
    }
}

public class DiscountPolicy {
    // public - 외부에서 호출
    public Money calculateDiscountAmount(Screening screening) {
        for (DiscountCondition each : conditions) {
            if (each.isSatisfiedBy(screening)) {
                return getDiscountAmount(screening);
            }
        }
        return Money.ZERO;
    }

    // protected - 서브클래스에서만 오버라이드
    abstract protected Money getDiscountAmount(Screening screening);
}

public class Movie {
    private DiscountPolicy discountPolicy;  // ✅ 합성

    public Movie(String title, Duration runningTime,
            Money fee, DiscountPolicy discountPolicy) {
        this.title = title;
        this.runningTime = runningTime;
        this.fee = fee;
        this.discountPolicy = discountPolicy;
    }
}

public class Movie {
    private DiscountPolicy discountPolicy;  // 추상 타입

    public Money calculateMovieFee(Screening screening) {
        // 구체 타입을 알 필요 없음!
        return fee.minus(discountPolicy.calculateDiscountAmount(screening));
    }
}

// 추상화
public abstract class DiscountPolicy {
    abstract protected Money getDiscountAmount(Screening screening);
}

// 변하는 부분들 (서브타입)
public class AmountDiscountPolicy extends DiscountPolicy {
    @Override
    protected Money getDiscountAmount(Screening screening) {
        return discountAmount;
    }
}

public class PercentDiscountPolicy extends DiscountPolicy {
    @Override
    protected Money getDiscountAmount(Screening screening) {
        return screening.getMovieFee().times(percent);
    }
}

// 변하지 않는 부분
public class Movie {
    private DiscountPolicy discountPolicy;  // 추상화에 의존!

    public Movie(String title, Duration runningTime,
            Money fee, DiscountPolicy discountPolicy) {
        // 의존성 주입
        this.discountPolicy = discountPolicy;
    }

    public Money calculateMovieFee(Screening screening) {
        // 구체 타입을 알 필요 없음
        return fee.minus(discountPolicy.calculateDiscountAmount(screening));
    }
}

public interface FeeCondition {
    /**
     * 통화 기간 중 적용조건을 만족하는 구간들을 반환
     */
    List<DateTimeInterval> findTimeIntervals(Call call);
}

public class FeePerDuration {
    private Money fee;        // 단위 요금
    private Duration duration;  // 단위 시간

    public FeePerDuration(Money fee, Duration duration) {
        this.fee = fee;
        this.duration = duration;
    }

    public Money calculate(DateTimeInterval interval) {
        return fee.times(
                Math.ceil(
                        (double) interval.duration().toNanos() /
                                duration.toNanos()
                )
        );
    }
}

public class FeeRule {
    private FeeCondition feeCondition;      // 적용조건
    private FeePerDuration feePerDuration;  // 단위요금

    public FeeRule(FeeCondition feeCondition,
            FeePerDuration feePerDuration) {
        this.feeCondition = feeCondition;
        this.feePerDuration = feePerDuration;
    }

    public Money calculateFee(Call call) {
        return feeCondition.findTimeIntervals(call)  // 조건 만족 구간
                .stream()
                .map(each -> feePerDuration.calculate(each))  // 각 구간 요금
                .reduce(Money.ZERO, (first, second) -> first.plus(second));  // 합계
    }
}

public final class BasicRatePolicy implements RatePolicy {
    private List<FeeRule> feeRules = new ArrayList<>();

    public BasicRatePolicy(FeeRule... feeRules) {
        this.feeRules = Arrays.asList(feeRules);
    }

    @Override
    public Money calculateFee(Phone phone) {
        return phone.getCalls()
                .stream()
                .map(call -> calculate(call))
                .reduce(Money.ZERO, (first, second) -> first.plus(second));
    }

    private Money calculate(Call call) {
        return feeRules
                .stream()
                .map(rule -> rule.calculateFee(call))
                .reduce(Money.ZERO, (first, second) -> first.plus(second));
    }
}

public class TimeOfDayFeeCondition implements FeeCondition {
    private LocalTime from;
    private LocalTime to;

    public TimeOfDayFeeCondition(LocalTime from, LocalTime to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public List<DateTimeInterval> findTimeIntervals(Call call) {
        return call.getInterval().splitByDay()
                .stream()
                .filter(each -> from(each).isBefore(to(each)))
                .map(each -> DateTimeInterval.of(
                        LocalDateTime.of(each.getFrom().toLocalDate(), from(each)),
                        LocalDateTime.of(each.getTo().toLocalDate(), to(each))
                ))
                .collect(Collectors.toList());
    }

    private LocalTime from(DateTimeInterval interval) {
        return interval.getFrom().toLocalTime().isBefore(from)
                ? from
                : interval.getFrom().toLocalTime();
    }

    private LocalTime to(DateTimeInterval interval) {
        return interval.getTo().toLocalTime().isAfter(to)
                ? to
                : interval.getTo().toLocalTime();
    }
}

FeeRule rule1 = new FeeRule(
        new TimeOfDayFeeCondition(LocalTime.of(0, 0), LocalTime.of(19, 0)),
        new FeePerDuration(Money.wons(18), Duration.ofSeconds(10))
);

FeeRule rule2 = new FeeRule(
        new TimeOfDayFeeCondition(LocalTime.of(19, 0), LocalTime.of(24, 0)),
        new FeePerDuration(Money.wons(15), Duration.ofSeconds(10))
);

BasicRatePolicy policy = new BasicRatePolicy(rule1, rule2);

public class DayOfWeekFeeCondition implements FeeCondition {
    private List<DayOfWeek> dayOfWeeks = new ArrayList<>();

    public DayOfWeekFeeCondition(DayOfWeek... dayOfWeeks) {
        this.dayOfWeeks = Arrays.asList(dayOfWeeks);
    }

    @Override
    public List<DateTimeInterval> findTimeIntervals(Call call) {
        return call.getInterval()
                .splitByDay()
                .stream()
                .filter(each ->
                        dayOfWeeks.contains(each.getFrom().getDayOfWeek()))
                .collect(Collectors.toList());
    }
}

FeeRule weekdayRule = new FeeRule(
        new DayOfWeekFeeCondition(
                DayOfWeek.MONDAY, DayOfWeek.TUESDAY, DayOfWeek.WEDNESDAY,
                DayOfWeek.THURSDAY, DayOfWeek.FRIDAY
        ),
        new FeePerDuration(Money.wons(38), Duration.ofSeconds(10))
);

FeeRule weekendRule = new FeeRule(
        new DayOfWeekFeeCondition(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY),
        new FeePerDuration(Money.wons(19), Duration.ofSeconds(10))
);

BasicRatePolicy policy = new BasicRatePolicy(weekdayRule, weekendRule);

public class DurationFeeCondition implements FeeCondition {
    private Duration from;
    private Duration to;

    public DurationFeeCondition(Duration from, Duration to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public List<DateTimeInterval> findTimeIntervals(Call call) {
        if (call.getInterval().duration().compareTo(from) < 0) {
            return Collections.emptyList();
        }

        return Arrays.asList(DateTimeInterval.of(
                call.getInterval().getFrom().plus(from),
                call.getInterval().duration().compareTo(to) > 0
                        ? call.getInterval().getFrom().plus(to)
                        : call.getInterval().getTo()
        ));
    }
}

FeeRule initialRule = new FeeRule(
        new DurationFeeCondition(Duration.ZERO, Duration.ofMinutes(1)),
        new FeePerDuration(Money.wons(50), Duration.ofSeconds(10))
);

FeeRule afterRule = new FeeRule(
        new DurationFeeCondition(Duration.ofMinutes(1), Duration.ofHours(10)),
        new FeePerDuration(Money.wons(20), Duration.ofSeconds(10))
);

BasicRatePolicy policy = new BasicRatePolicy(initialRule, afterRule);

public class FixedFeeCondition implements FeeCondition {
    @Override
    public List<DateTimeInterval> findTimeIntervals(Call call) {
        // 전체 통화 시간을 그대로 반환
        return Arrays.asList(call.getInterval());
    }
}

FeeRule rule = new FeeRule(
        new FixedFeeCondition(),  // 항상 만족하는 조건
        new FeePerDuration(Money.wons(18), Duration.ofSeconds(10))
);

BasicRatePolicy policy = new BasicRatePolicy(rule);