package com.jesusbornd.leviticus;

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

public class Leviticus_21_Chapter_Lv3 {

    record Priest(String name, boolean hasDefect, boolean isMourning, boolean isMarriedImproperly) {}

    static class DisqualificationChecker {
        private final List<Predicate<Priest>> rules = new ArrayList<>();
        private final List<String>            labels = new ArrayList<>();

        DisqualificationChecker add(String label, Predicate<Priest> rule) {
            rules.add(rule);
            labels.add(label);
            return this;
        }

        List<String> failures(Priest p) {
            List<String> result = new ArrayList<>();
            for (int i = 0; i < rules.size(); i++) {
                if (rules.get(i).test(p)) result.add(labels.get(i));
            }
            return result;
        }

        void evaluate(Priest p) {
            List<String> f = failures(p);
            if (f.isEmpty()) {
                System.out.println(p.name() + " → 직무 수행 가능 / Qualified");
            } else {
                System.out.println(p.name() + " → 결격 / Disqualified: " + f);
            }
        }
    }

    public static void main(String[] args) {
        DisqualificationChecker checker = new DisqualificationChecker()
            .add("신체 결함",   Priest::hasDefect)
            .add("부정 애도",   Priest::isMourning)
            .add("부당 결혼",   Priest::isMarriedImproperly);

        List<Priest> candidates = List.of(
            new Priest("아론",   false, false, false),
            new Priest("나답",   true,  false, false),
            new Priest("아비후", false, true,  false),
            new Priest("엘르아살", false, false, true)
        );

        candidates.forEach(checker::evaluate);
    }
}

from dataclasses import dataclass
from typing import Callable

@dataclass
class Priest:
    name: str
    has_defect: bool
    is_mourning: bool
    is_married_improperly: bool


class DisqualificationChecker:
    def __init__(self):
        self._rules: list[tuple[str, Callable[[Priest], bool]]] = []

    def add(self, label: str, rule: Callable[[Priest], bool]) -> "DisqualificationChecker":
        self._rules.append((label, rule))
        return self

    def failures(self, p: Priest) -> list[str]:
        return [label for label, rule in self._rules if rule(p)]

    def evaluate(self, p: Priest):
        f = self.failures(p)
        if not f:
            print(f"{p.name} → 직무 수행 가능 / Qualified")
        else:
            print(f"{p.name} → 결격 / Disqualified: {f}")


if __name__ == "__main__":
    checker = (
        DisqualificationChecker()
        .add("신체 결함", lambda p: p.has_defect)
        .add("부정 애도", lambda p: p.is_mourning)
        .add("부당 결혼", lambda p: p.is_married_improperly)
    )

    candidates = [
        Priest("아론",     False, False, False),
        Priest("나답",     True,  False, False),
        Priest("아비후",   False, True,  False),
        Priest("엘르아살", False, False, True),
    ]

    for priest in candidates:
        checker.evaluate(priest)