/*
 * Hibernate Validator, declare and validate application constraints
 *
 * License: Apache License, Version 2.0
 * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
 */
package org.hibernate.validator.constraints;

import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Documented;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

import org.hibernate.validator.constraints.Mod11Check.List;

Modulo 11 check constraint.
 Allows to validate that a series of digits passes the Mod11 checksum algorithm. For the most common Mod11 variant the sum calculation is done by multiplying a weight from the rightmost digit (excluding the check digit) to the leftmost. The weight starts with 2 and increases by 1 for each digit. Then the result is used to calculate the check digit using 11 - ( sum % 11 ). 

Example: The check digit for 24187 is 3

Sum = 7x2 + 8x3 + 1x4 + 4x5 + 2x6 = 74 

11 - (74 % 11) = 11 - 8 = 3, so "24187-3" is a valid character sequence.

 The Mod11 calculation can result in 10 or 11; per default 10 is treated as 'X' and 11 as '0', this behavior can be changed using the options treatCheck10As and treatCheck10As. 
 Some implementations do the sum calculation in the reverse order (left to right); specify the processing direction ProcessingDirection.LEFT_TO_RIGHT in this case. 
 The supported type is CharSequence. null is considered valid. 
Author:
George Gastaldi, Hardy Ferentschik, Victor Rezende dos Santos/**
 * Modulo 11 check constraint.
 * <p>
 * Allows to validate that a series of digits passes the Mod11 checksum
 * algorithm.
 * For the most common Mod11 variant the sum calculation is done by multiplying a weight from
 * the rightmost digit (excluding the check digit) to the leftmost. The weight
 * starts with 2 and increases by 1 for each digit. Then the result is used to
 * calculate the check digit using {@code 11 - ( sum % 11 )}.
 * </p>
 * <p>
 * Example: The check digit for 24187 is 3<br>
 * Sum = 7x2 + 8x3 + 1x4 + 4x5 + 2x6 = 74 <br>
 * 11 - (74 % 11) = 11 - 8 = 3, so "24187-3" is a valid character sequence.
 * </p>
 * <p>
 * The Mod11 calculation can result in 10 or 11; per default 10 is treated as
 * {@code 'X'} and 11 as {@code '0'}, this behavior can be changed using the
 * options {@code treatCheck10As} and {@code treatCheck10As}.
 * </p>
 * <p>
 * Some implementations do the sum calculation in the reverse order (left to right);
 * specify the processing direction {@link ProcessingDirection#LEFT_TO_RIGHT} in
 * this case.
 * </p>
 * <p>
 * The supported type is {@code CharSequence}. {@code null} is considered valid.
 * </p>
 *
 * @author George Gastaldi
 * @author Hardy Ferentschik
 * @author Victor Rezende dos Santos
 */
@Documented
@Constraint(validatedBy = { })
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Repeatable(List.class)
public @interface Mod11Check {
	String message() default "{org.hibernate.validator.constraints.Mod11Check.message}";

	Class<?>[] groups() default { };

	Class<? extends Payload>[] payload() default { };

	
Returns:
The threshold for the Mod11 algorithm multiplier growth, if no value is specified the multiplier will grow indefinitely/**
	 * @return The threshold for the Mod11 algorithm multiplier growth, if no value is specified the multiplier will grow indefinitely
	 */
	int threshold() default Integer.MAX_VALUE;

	
Returns:
the start index (inclusive) for calculating the checksum. If not specified 0 is assumed./**
	 * @return the start index (inclusive) for calculating the checksum. If not specified 0 is assumed.
	 */
	int startIndex() default 0;

	
Returns:
the end index (inclusive) for calculating the checksum. If not specified the whole value is considered/**
	 * @return the end index (inclusive) for calculating the checksum. If not specified the whole value is considered
	 */
	int endIndex() default Integer.MAX_VALUE;

	
Returns:
The index of the check digit in the input. Per default it is assumed that the check digit is the last
digit of the specified range. If set, the digit at the specified index is used. If set
the following must hold true:
 checkDigitIndex > 0 && (checkDigitIndex < startIndex || checkDigitIndex >= endIndex./**
	 * @return The index of the check digit in the input. Per default it is assumed that the check digit is the last
	 * digit of the specified range. If set, the digit at the specified index is used. If set
	 * the following must hold true:<br>
	 * {@code checkDigitIndex > 0 && (checkDigitIndex < startIndex || checkDigitIndex >= endIndex}.
	 */
	int checkDigitIndex() default -1;

	
Returns:
Whether non-digit characters in the validated input should be ignored (true) or result in a validation error (false)./**
	 * @return Whether non-digit characters in the validated input should be ignored ({@code true}) or result in a
	 * validation error ({@code false}).
	 */
	boolean ignoreNonDigitCharacters() default false;

	
Returns:
The char that represents the check digit when the Mod11 checksum equals 10. If not specified 'X' is assumed./**
	 * @return The {@code char} that represents the check digit when the Mod11
	 * checksum equals 10. If not specified {@code 'X'} is assumed.
	 */
	char treatCheck10As() default 'X';

	
Returns:
The char that represents the check digit when the Mod11 checksum equals 11. If not specified '0' is assumed./**
	 * @return The {@code char} that represents the check digit when the Mod11
	 * checksum equals 11. If not specified {@code '0'} is assumed.
	 */
	char treatCheck11As() default '0';

	
Returns:
Returns RIGHT_TO_LEFT if the Mod11 checksum must be done from the rightmost to the leftmost digit. e.g. Code 12345-?: 

RIGHT_TO_LEFT the sum (5*2 + 4*3 + 3*4 + 2*5 + 1*6) with check digit 5
LEFT_TO_RIGHT the sum (1*2 + 2*3 + 3*4 + 4*5 + 5*6) with check digit 7
 If not specified RIGHT_TO_LEFT is assumed, it is the default Mod11 behavior./**
	 * @return Returns {@code RIGHT_TO_LEFT} if the Mod11 checksum must be done from the rightmost to the leftmost digit.
	 * e.g. Code 12345-?:
	 * <ul>
	 * <li>{@code RIGHT_TO_LEFT} the sum (5*2 + 4*3 + 3*4 + 2*5 + 1*6) with check digit 5</li>
	 * <li>{@code LEFT_TO_RIGHT} the sum (1*2 + 2*3 + 3*4 + 4*5 + 5*6) with check digit 7</li>
	 * </ul>
	 * If not specified {@code RIGHT_TO_LEFT} is assumed, it is the default Mod11 behavior.
	 */
	ProcessingDirection processingDirection() default ProcessingDirection.RIGHT_TO_LEFT;

	
Defines several @Mod11Check annotations on the same element. /**
	 * Defines several {@code @Mod11Check} annotations on the same element.
	 */
	@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
	@Retention(RUNTIME)
	@Documented
	public @interface List {
		Mod11Check[] value();
	}

	enum ProcessingDirection {
		RIGHT_TO_LEFT,
		LEFT_TO_RIGHT
	}
}