package com.jesusbornd.leviticus;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public class Leviticus_22_Chapter_Lv3 {

    record Offering(String name, boolean hasDefect, boolean isSick, boolean isTooYoung) {}

    static class OfferingValidator {
        private final List<Function<Offering, String>> checks = new ArrayList<>();

        OfferingValidator addCheck(String failMsg, Function<Offering, Boolean> test) {
            checks.add(o -> test.apply(o) ? failMsg : null);
            return this;
        }

        List<String> validate(Offering o) {
            List<String> errors = new ArrayList<>();
            for (Function<Offering, String> check : checks) {
                String result = check.apply(o);
                if (result != null) errors.add(result);
            }
            return errors;
        }

        void accept(Offering o) {
            List<String> errors = validate(o);
            if (errors.isEmpty()) {
                System.out.println(o.name() + " → 수락 / Accepted");
            } else {
                System.out.println(o.name() + " → 거부 / Rejected: " + errors);
            }
        }
    }

    public static void main(String[] args) {
        OfferingValidator validator = new OfferingValidator()
            .addCheck("흠 있음 / Has defect",  Offering::hasDefect)
            .addCheck("병든 것 / Sick",         Offering::isSick)
            .addCheck("너무 어림 / Too young",  Offering::isTooYoung);

        List<Offering> offerings = List.of(
            new Offering("흠 없는 수소",  false, false, false),
            new Offering("흠 있는 양",    true,  false, false),
            new Offering("병든 염소",     false, true,  false),
            new Offering("갓 태어난 새끼", false, false, true)
        );

        offerings.forEach(validator::accept);
    }
}

from dataclasses import dataclass
from typing import Callable

@dataclass
class Offering:
    name: str
    has_defect: bool
    is_sick: bool
    is_too_young: bool


class OfferingValidator:
    def __init__(self):
        self._checks: list[tuple[str, Callable[[Offering], bool]]] = []

    def add_check(self, fail_msg: str, test: Callable[[Offering], bool]) -> "OfferingValidator":
        self._checks.append((fail_msg, test))
        return self

    def validate(self, o: Offering) -> list[str]:
        return [msg for msg, test in self._checks if test(o)]

    def accept(self, o: Offering):
        errors = self.validate(o)
        if not errors:
            print(f"{o.name} → 수락 / Accepted")
        else:
            print(f"{o.name} → 거부 / Rejected: {errors}")


if __name__ == "__main__":
    validator = (
        OfferingValidator()
        .add_check("흠 있음 / Has defect", lambda o: o.has_defect)
        .add_check("병든 것 / Sick",        lambda o: o.is_sick)
        .add_check("너무 어림 / Too young", lambda o: o.is_too_young)
    )

    offerings = [
        Offering("흠 없는 수소",   False, False, False),
        Offering("흠 있는 양",     True,  False, False),
        Offering("병든 염소",      False, True,  False),
        Offering("갓 태어난 새끼", False, False, True),
    ]

    for o in offerings:
        validator.accept(o)