// Your domain object stays clean — no annotations
record User(String name, String email, int age, Address address) {}

// Rules live where they belong — in a dedicated validator
var validator = validator(User.class)
    .field("name",    User::name,    notBlank(), maxLength(100))
    .field("email",   User::email,   notBlank(), email())
    .field("age",     User::age,     between(18, 120))
    .nested("address", User::address, addressValidator())
    .build();

// Results are sealed — the compiler forces you to handle both cases
switch (validator.validate(user)) {
    case Valid   v -> proceed(user);
    case Invalid e -> respond(e.summary());
}

import static validy.core.Valify.*;

var userValidator = validator(User.class)
    .field("name",  User::name,  notBlank(), maxLength(100))
    .field("email", User::email, notBlank(), email())
    .field("age",   User::age,   between(18, 120))
    .build();

// Basic — runs all Default rules
ValidationResult result = userValidator.validate(user);

// With groups — runs Default + specified groups
ValidationResult result = userValidator.validate(user, OnCreate.class);

// Pattern matching on the result
switch (result) {
    case Valid   v -> System.out.println("All good!");
    case Invalid e -> System.err.println(e.summary());
}

// Callbacks
result.ifValid(() -> persist(user));
result.ifInvalid(e -> log.warn(e.summary()));

// Boolean check
if (result.isValid()) { ... }

// Inline
Rule<String> strongPassword = minLength(8)
    .and(matches(".*[A-Z].*").withMessage("$", "must contain an uppercase letter"))
    .and(matches(".*[0-9].*").withMessage("$", "must contain a digit"))
    .and(matches(".*[!@#$%^&*].*").withMessage("$", "must contain a special character"));

// Reusable static method
static Rule<String> ukPostcode() {
    return matches("^[A-Z]{1,2}\\d[\\dA-Z]? ?\\d[A-Z]{2}$")
        .withMessage("$", "must be a valid UK postcode");
}

// From a predicate + message
Rule<User> adultOnly = rule(u -> u.age() >= 18, "must be 18 or older");

// Both must pass — all errors collected
Rule<String> name = notBlank().and(maxLength(100));

// First success wins — short-circuits
Rule<String> id = uuid().or(numeric());

// Invert
Rule<String> notAnEmail = email().negate("must NOT be an email");

// Adapt to a different type
Rule<String> noSwearWords = ...;
Rule<Comment> cleanComment = noSwearWords.contramap(Comment::body);

var addressValidator = validator(Address.class)
    .field("street", Address::street, notBlank())
    .field("city",   Address::city,   notBlank())
    .field("zip",    Address::zip,    matches("^\\d{5}$"))
    .build();

var userValidator = validator(User.class)
    .field("name", User::name, notBlank())
    .nested("address", User::address, addressValidator)
    // child error "zip" surfaces as "address.zip"
    .build();

// Validate each string element
.field("tags", Post::tags, notEmpty(), eachElement(notBlank()))

// Validate each object with its own validator
.field("addresses", User::addresses, notEmpty(), eachElement(addressValidator))

// Errors are indexed automatically:
// "[0].zip"    → first address, zip field
// "[1]"        → second element (object-level error)
// "[2].street" → third address, street field

// 1. Declare groups — plain interfaces, no annotations, no registration
public interface OnCreate extends ValidationGroup {}
public interface OnUpdate extends ValidationGroup {}

// 2. Assign rules to groups
var validator = validator(User.class)
    .field("name",     User::name,     notBlank())                          // Default — always
    .field("email",    User::email,    notBlank(), email())                 // Default — always
    .field("password", User::password, strongPassword()).groups(OnCreate.class) // create only
    .field("id",       User::id,       notNull()).groups(OnUpdate.class)        // update only
    .rule(u -> u.password().equals(u.confirm())
        ? valid() : invalid("confirm", "must match")).groups(OnCreate.class)
    .build();

// 3. Run with the right group
validator.validate(user);                    // Default only
validator.validate(user, OnCreate.class);   // Default + OnCreate
validator.validate(user, OnUpdate.class);   // Default + OnUpdate
validator.validate(user, OnCreate.class, OnPublish.class); // multiple groups

@Configuration
class ValifyConfig {

    @Bean
    ValidatorRegistry validatorRegistry() {
        return ValidatorRegistry.builder()
            .register(CreateUserRequest.class, UserValidators.createUser())
            .register(UpdateUserRequest.class, UserValidators.updateUser())
            .build();
    }

    @Bean
    ValidationExceptionHandler validationExceptionHandler() {
        return new ValidationExceptionHandler();
    }
}

@RestController
@RequestMapping("/users")
class UserController {

    @PostMapping
    ResponseEntity<UserResponse> create(@RequestBody @Validated CreateUserRequest req) {
        // Validation passed — proceed
        return ResponseEntity.ok(userService.create(req));
    }
}

public final class AppRules {

    public static Rule<String> strongPassword() {
        return minLength(8)
            .and(matches(".*[A-Z].*").withMessage("$", "must contain an uppercase letter"))
            .and(matches(".*[0-9].*").withMessage("$", "must contain a digit"))
            .and(matches(".*[!@#$%^&*].*").withMessage("$", "must contain a special character"));
    }

    public static Rule<String> usZip() {
        return matches("^\\d{5}(-\\d{4})?$")
            .withMessage("$", "must be a valid US ZIP code");
    }

    public static Rule<String> slug() {
        return matches("^[a-z0-9]+(?:-[a-z0-9]+)*$")
            .withMessage("$", "must be a valid URL slug");
    }
}

interface Step1 extends ValidationGroup {}
interface Step2 extends ValidationGroup {}
interface Step3 extends ValidationGroup {}

var signupValidator = validator(SignupForm.class)
    .field("name",  SignupForm::name,  notBlank()).groups(Step1.class)
    .field("email", SignupForm::email, email())   .groups(Step1.class)
    .field("street", SignupForm::street, notBlank()).groups(Step2.class)
    .field("zip",    SignupForm::zip,    usZip())  .groups(Step2.class)
    .field("card",   SignupForm::card,   notBlank()).groups(Step3.class)
    .build();

// Each step validates only what the user has filled in so far
signupValidator.validate(form, Step1.class);
signupValidator.validate(form, Step1.class, Step2.class);
signupValidator.validate(form, Step1.class, Step2.class, Step3.class);

@Service
class OrderService {

    private final Validator<CreateOrderRequest> validator = OrderValidators.create();

    public Order createOrder(CreateOrderRequest request) {
        switch (validator.validate(request, OnCreate.class)) {
            case Valid   v -> { return persist(request); }
            case Invalid e -> throw new ValidationException(e.errors());
        }
    }
}

class UserValidatorTest {

    // No Spring context — validators are plain objects
    private final Validator<CreateUserRequest> validator = UserValidators.createUser();

    @Test
    void blank_name_fails_on_name_field() {
        var req    = new CreateUserRequest("", "a@b.com", 25, "P@ssw0rd!", "P@ssw0rd!");
        var result = validator.validate(req, OnCreate.class);

        assertThat(result.isValid()).isFalse();
        result.ifInvalid(e ->
            assertThat(e.errors()).anyMatch(err -> err.field().equals("name"))
        );
    }

    @Test
    void valid_request_passes() {
        var req = new CreateUserRequest("Alice", "alice@example.com", 30, "P@ssw0rd!", "P@ssw0rd!");
        assertThat(validator.validate(req, OnCreate.class).isValid()).isTrue();
    }
}