/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.infinispan.schematic.internal.schema;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.infinispan.schematic.SchemaLibrary.ProblemType;
import org.infinispan.schematic.document.Document;
import org.infinispan.schematic.document.Document.Field;
import org.infinispan.schematic.document.JsonSchema;
import org.infinispan.schematic.document.JsonSchema.Type;
import org.infinispan.schematic.document.Null;
import org.infinispan.schematic.document.Path;
import org.infinispan.schematic.document.Symbol;
import org.infinispan.schematic.internal.document.Paths;

public class JsonSchemaValidatorFactory implements Validator.Factory {

    private CompositeValidator topLevelValidator = new CompositeValidator();
    private final Problems problems;
    private final URI uri;

    protected JsonSchemaValidatorFactory( URI uri,
                                          Problems problems ) {
        this.uri = uri;
        this.problems = problems;
    }

    @Override
    public Validator create( Document schemaDocument,
                             Path pathToDoc ) {
        CompositeValidator validators = new CompositeValidator();
        if (this.topLevelValidator == null) {
            this.topLevelValidator = validators;
        }

        // Dereference any "$ref" value, replacing this schema document with the referenced one ...
        Validator derefValidator = dereference(schemaDocument, pathToDoc, problems);
        if (derefValidator != null) {
            return derefValidator;
        }

        addValidatorsForTypes(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForProperties(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForPatternProperties(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForItems(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForRequired(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMinimum(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMaximum(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMinimumItems(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMaximumItems(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForUniqueItems(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForPattern(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMinimumLength(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForMaximumLength(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForEnum(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForDivisibleBy(schemaDocument, pathToDoc, problems, validators);
        addValidatorsForDisallowedTypes(schemaDocument, pathToDoc, problems, validators);

        switch (validators.size()) {
            case 0:
                return null;
            case 1:
                return validators.getFirst();
            default:
                return validators;
        }
    }

    protected Validator dereference( Document schemaDocument,
                                     Path pathToDoc,
                                     Problems problems ) {
        String ref = schemaDocument.getString("$ref");
        if (ref == null) {
            return null;
        }
        if ("#".equals(ref)) {
            return topLevelValidator;
        }
        // Try to resolve the absolute or relative key ...
        // See if this is a relative URI ...
        String resolvedReference = null;
        URI refUri = null;
        try {
            refUri = new URI(ref);
            URI resolvedUri = this.uri.resolve(refUri);
            resolvedReference = resolvedUri.toString();
        } catch (URISyntaxException e) {
            problems.recordWarning(pathToDoc, "The URI of the referenced schema '" + uri + "' is not a valid URI");
        }
        if (uri.equals(resolvedReference)) {
            return topLevelValidator;
        }
        if (!ref.equals(resolvedReference)) {
            // The resolved reference is different than what we just looked up, so look it up ...
            assert resolvedReference != null;
            return new ResolvingValidator(resolvedReference);
        }
        return null;
    }

    protected void addValidatorsForTypes( Document parent,
                                          Path parentPath,
                                          Problems problems,
                                          CompositeValidator validators ) {
        Object value = parent.get("type");
        if (value instanceof String) {
            // Simple type ...
            Type type = JsonSchema.Type.byName((String)value);
            if (type == Type.ANY || type == Type.UNKNOWN) return;
            validators.add(new TypeValidator(type));
        } else if (value instanceof List<?>) {
            // Union type ...
            List<Validator> unionValidators = new ArrayList<Validator>();
            List<?> types = (List<?>)value;
            for (Object obj : types) {
                Validator validator = null;
                if (obj instanceof Document) {
                    // It's either a schema or a reference to a schema ...
                    Document schemaOrRef = (Document)obj;
                    validator = create(schemaOrRef, parentPath.with("type"));
                } else if (obj instanceof String) {
                    Type type = JsonSchema.Type.byName((String)obj);
                    if (type == Type.ANY || type == Type.UNKNOWN) continue;
                    validator = new TypeValidator(type);
                }
                if (validator != null) unionValidators.add(validator);
            }
            if (unionValidators.size() == 1) {
                // Just one validator ...
                validators.add(unionValidators.get(0));
            } else if (unionValidators.size() > 1) {
                // More than one validator, so use a union ...
                validators.add(new UnionValidator(unionValidators));
            }
        }
    }

    protected void addValidatorsForProperties( Document parent,
                                               Path parentPath,
                                               Problems problems,
                                               CompositeValidator validators ) {
        Document properties = parent.getDocument("properties");
        Set<String> propertiesWithSchemas = new HashSet<String>();
        if (properties != null && properties.size() != 0) {
            for (Field field : properties.fields()) {
                String name = field.getName();
                Object value = field.getValue();
                Path path = Paths.path(parentPath, "properties", name);
                if (!(value instanceof Document)) {
                    problems.recordError(path, "Expected a nested object");
                }
                Document propertySchema = (Document)value;
                Validator propertyValidator = create(propertySchema, path);
                if (propertyValidator != null) {
                    validators.add(new PropertyValidator(name, propertyValidator));
                }
                propertiesWithSchemas.add(name);
            }
        }

        // Check the additional properties ...
        boolean additionalPropertiesAllowed = parent.getBoolean("additionalProperties", true);
        if (!additionalPropertiesAllowed) {
            validators.add(new NoOtherAllowedPropertiesValidator(propertiesWithSchemas));
        } else {
            Document additionalSchema = parent.getDocument("additionalProperties");
            if (additionalSchema != null) {
                Path path = parentPath.with("additionalProperties");
                Validator additionalValidator = create(additionalSchema, path);
                if (additionalValidator != null) {
                    validators.add(new AllowedPropertiesValidator(propertiesWithSchemas, additionalValidator));
                }
            }
            // Otherwise, additional properties are allowed so we need to do nothing
        }

    }

    protected void addValidatorsForPatternProperties( Document parent,
                                                      Path parentPath,
                                                      Problems problems,
                                                      CompositeValidator validators ) {
        Document properties = parent.getDocument("patternProperties");
        if (properties != null && properties.size() != 0) {
            for (Field field : properties.fields()) {
                String name = field.getName();
                Object value = field.getValue();
                Path path = Paths.path(parentPath, "patternProperties", name);
                if (!(value instanceof Document)) {
                    problems.recordError(path, "Expected a nested object");
                }
                Document propertySchema = (Document)value;
                try {
                    Pattern namePattern = Pattern.compile(name);
                    Validator propertyValidator = create(propertySchema, path);
                    if (propertyValidator != null) {
                        validators.add(new PatternPropertyValidator(namePattern, propertyValidator));
                    }
                } catch (PatternSyntaxException e) {
                    problems.recordError(path, "Expected the field name to be a regular expression");
                }
            }
        }
    }

    protected void addValidatorsForItems( Document parent,
                                          Path parentPath,
                                          Problems problems,
                                          CompositeValidator validators ) {
        Object items = parent.get("items");
        if (Null.matches(items)) return;

        Path path = parentPath.with("items");
        String requiredName = parentPath.getLast();
        if (requiredName == null) return;

        // Either a schema or an array of schemas ...
        if (items instanceof Document) {
            Document schema = (Document)items;
            Validator validator = create(schema, path);
            if (validator != null) {
                validators.add(new AllItemsMatchValidator(requiredName, validator));
            }
        } else if (items instanceof List<?>) {
            // This is called "tuple typing" in the spec, and can also have 'additionalItems' ...
            List<?> array = (List<?>)items;
            List<Validator> itemValidators = new ArrayList<Validator>(array.size());
            for (Object item : array) {
                if (item instanceof Document) {
                    Validator validator = create((Document)item, path);
                    if (validator != null) {
                        itemValidators.add(validator);
                    }
                }
            }
            // Check the additional items ...
            boolean additionalItemsAllowed = parent.getBoolean("additionalItems", true);
            Validator additionalItemsValidator = null;
            if (!additionalItemsAllowed) {
                additionalItemsValidator = new NotValidValidator();
            } else {
                // additional items are allowed, but check whether there is a schema for the additional items ...
                Document additionalItems = parent.getDocument("additionalItems");
                if (additionalItems != null) {
                    Path additionalItemsPath = parentPath.with("additionalItems");
                    additionalItemsValidator = create(additionalItems, additionalItemsPath);
                }
            }

            if (!itemValidators.isEmpty()) {
                validators.add(new EachItemMatchesValidator(requiredName, itemValidators, additionalItemsValidator,
                                                            additionalItemsAllowed));
            }
        }
    }

    protected void addValidatorsForRequired( Document parent,
                                             Path parentPath,
                                             Problems problems,
                                             CompositeValidator validators ) {
        Boolean required = parent.getBoolean("required", Boolean.FALSE);
        if (required.booleanValue()) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new RequiredValidator(requiredName));
            }
        }
    }

    protected void addValidatorsForMinimum( Document parent,
                                            Path parentPath,
                                            Problems problems,
                                            CompositeValidator validators ) {
        Number minimum = parent.getNumber("minimum");
        if (minimum != null) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                if (parent.getBoolean("exclusiveMinimum", Boolean.FALSE)) {
                    validators.add(new ExclusiveMinimumValidator(requiredName, minimum));
                } else {
                    validators.add(new MinimumValidator(requiredName, minimum));
                }
            }
        }
    }

    protected void addValidatorsForMaximum( Document parent,
                                            Path parentPath,
                                            Problems problems,
                                            CompositeValidator validators ) {
        Double maximum = parent.getDouble("maximum");
        if (maximum != null) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                if (parent.getBoolean("exclusiveMinimum", Boolean.FALSE)) {
                    validators.add(new ExclusiveMaximumValidator(requiredName, maximum));
                } else {
                    validators.add(new MaximumValidator(requiredName, maximum));
                }
            }
        }
    }

    protected void addValidatorsForMinimumItems( Document parent,
                                                 Path parentPath,
                                                 Problems problems,
                                                 CompositeValidator validators ) {
        int minimum = parent.getInteger("minItems", 0);
        if (minimum > 0) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new MinimumItemsValidator(requiredName, minimum));
            }
        }
    }

    protected void addValidatorsForMaximumItems( Document parent,
                                                 Path parentPath,
                                                 Problems problems,
                                                 CompositeValidator validators ) {
        int maximum = parent.getInteger("maxItems", 0);
        if (maximum > 0) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new MaximumItemsValidator(requiredName, maximum));
            }
        }
    }

    protected void addValidatorsForUniqueItems( Document parent,
                                                Path parentPath,
                                                Problems problems,
                                                CompositeValidator validators ) {
        if (parent.getBoolean("uniqueItems", false)) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new UniqueItemsValidator(requiredName));
            }
        }
    }

    protected void addValidatorsForPattern( Document parent,
                                            Path parentPath,
                                            Problems problems,
                                            CompositeValidator validators ) {
        String regex = parent.getString("pattern");
        if (regex != null) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                try {
                    Pattern pattern = Pattern.compile(regex);
                    validators.add(new PatternValidator(requiredName, pattern));
                } catch (PatternSyntaxException e) {
                    problems.recordError(parentPath.with("pattern"),
                                         "The supplied value '" + regex
                                         + "' is expected to be a valid regular expression, but there was an error at position "
                                         + e.getIndex() + ": " + e.getDescription());
                }
            }
        }
    }

    protected void addValidatorsForMinimumLength( Document parent,
                                                  Path parentPath,
                                                  Problems problems,
                                                  CompositeValidator validators ) {
        int minimumLength = parent.getInteger("minimumLength", 0);
        if (minimumLength > 0) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new MinimumLengthValidator(requiredName, minimumLength));
            }
        }
    }

    protected void addValidatorsForMaximumLength( Document parent,
                                                  Path parentPath,
                                                  Problems problems,
                                                  CompositeValidator validators ) {
        int maximumLength = parent.getInteger("maximumLength", 0);
        if (maximumLength > 0) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new MaximumLengthValidator(requiredName, maximumLength));
            }
        }
    }

    protected void addValidatorsForEnum( Document parent,
                                         Path parentPath,
                                         Problems problems,
                                         CompositeValidator validators ) {
        List<?> enumValues = parent.getArray("enum");
        if (enumValues != null && !enumValues.isEmpty()) {
            String requiredName = parentPath.getLast();
            if (requiredName != null) {
                validators.add(new EnumValidator(requiredName, enumValues));
            }
        }
    }

    protected void addValidatorsForDivisibleBy( Document parent,
                                                Path parentPath,
                                                Problems problems,
                                                CompositeValidator validators ) {
        Number denominator = parent.getNumber("divisibleBy", 1);
        if (denominator != null) {
            int denominatorIntValue = denominator.intValue();
            if (denominatorIntValue != 0 && denominatorIntValue != 1) {
                String requiredName = parentPath.getLast();
                if (requiredName != null) {
                    validators.add(new DivisibleByValidator(requiredName, denominator.intValue()));
                }
            }
        }
    }

    protected void addValidatorsForDisallowedTypes( Document parent,
                                                    Path parentPath,
                                                    Problems problems,
                                                    CompositeValidator validators ) {
        Object disallowed = parent.get("disallowed");
        if (Null.matches(disallowed)) return;
        String requiredName = parentPath.getLast();
        if (requiredName != null) {
            EnumSet<Type> disallowedTypes = Type.typesWithNames(disallowed);
            validators.add(new DisallowedTypesValidator(requiredName, disallowedTypes));
        }
    }

    protected class TypeValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final Type type;

        public TypeValidator( Type type ) {
            this.type = type;
            assert this.type != null;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document document,
                              Path pathToDocument,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue == null) {
                if (fieldName != null) {
                    fieldValue = document.get(fieldName);
                } else {
                    // We're supposed to check the whole document is the correct type ...
                    fieldValue = document;
                }
            }
            if (fieldValue != null) {
                Type actual = Type.typeFor(fieldValue);
                if (!type.isEquivalent(actual)) {
                    // See if the value is convertable ...
                    Object converted = type.convertValueFrom(fieldValue, actual);
                    Path pathToField = fieldName != null ? pathToDocument.with(fieldName) : pathToDocument;
                    String reason = "Field value for '" + pathToField + "' expected to be of type " + type + " but was of type "
                                    + actual;
                    if (converted != null) {
                        // We could convert the value, so record this as a special error ...
                        problems.recordTypeMismatch(pathToField, reason, actual, fieldValue, type, converted);
                    } else {
                        problems.recordError(pathToField, reason);
                    }
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "Type is '" + type + "'";
        }
    }

    protected static interface ValidatorCollection extends Iterable<Validator> {
    }

    protected class UnionValidator implements Validator, ValidatorCollection {
        private static final long serialVersionUID = 1L;
        private final List<Validator> validators;

        public UnionValidator( List<Validator> validators ) {
            this.validators = validators;
            assert this.validators != null && !this.validators.isEmpty();
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document document,
                              Path pathToDocument,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            // Try each validator with a new problems; the first one to return without any problems passes ...
            ValidationResult problemsForMostSuccesses = null;
            int mostSuccesses = -1;
            for (Validator validator : validators) {
                ValidationResult newProblems = new ValidationResult();
                validator.validate(fieldValue, fieldName, document, pathToDocument, newProblems, resolver);
                if (!newProblems.hasErrors()) {
                    problems.recordSuccess();
                    return;
                }
                if (newProblems.successCount() > mostSuccesses) {
                    mostSuccesses = newProblems.successCount();
                    problemsForMostSuccesses = newProblems;
                }
            }
            // All unioned types had problems, but record the problems with the one that had the most successful validations ...
            if (problemsForMostSuccesses != null) problemsForMostSuccesses.recordIn(problems);
        }

        @Override
        public Iterator<Validator> iterator() {
            return validators.iterator();
        }

        @Override
        public String toString() {
            return "Union of " + validators.size() + " validators";
        }
    }

    protected class ResolvingValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String schemaUri;

        public ResolvingValidator( String schemaUri ) {
            this.schemaUri = schemaUri;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document document,
                              Path pathToDocument,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            SchemaDocument resolved = resolver.get(schemaUri, problems);
            if (resolved == null) {
                problems.recordError(pathToDocument.with(fieldName), "Unable to find referenced schema '" + schemaUri + "'");
            } else {
                problems.recordSuccess();
                resolved.getValidator().validate(fieldValue, fieldName, document, pathToDocument, problems, resolver);
            }
        }

        @Override
        public String toString() {
            return "Resolves to schema '" + schemaUri + "'";
        }
    }

    protected static class RequiredValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;

        public RequiredValidator( String propertyName ) {
            this.propertyName = propertyName;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (Null.matches(fieldValue) && fieldName != null) {
                if (pathToParent.size() == 0) {
                    problems.recordError(pathToParent.with(fieldName), "The top-level '" + fieldName + "' field is required");
                } else {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' is required");
                }
            } else {
                problems.recordSuccess();
            }
        }

        @Override
        public String toString() {
            return "required '" + propertyName + "'";
        }
    }

    protected static abstract class NumericValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Number number;
        private final double value;

        protected NumericValidator( String propertyName,
                                    Number number ) {
            this.propertyName = propertyName;
            this.number = number;
            this.value = number.doubleValue();
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof Number) {
                Number actualNumber = (Number)fieldValue;
                double actualValue = actualNumber.doubleValue();
                if (isValid(value, actualValue)) {
                    problems.recordSuccess();
                } else {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' is '" + actualNumber + "' but must be "
                                                                       + ruleDescription() + " '" + number + "'");
                }
            }
            // otherwise the value is not a number and the minimum doesn't apply
        }

        /**
         * Evaluate whether the actual value and expected value violate the schema rule.
         * 
         * @param expectedValue the expected value
         * @param actualValue the actual value
         * @return true if the value is valid, or false if there is an error
         */
        protected abstract boolean isValid( double expectedValue,
                                            double actualValue );

        protected abstract String ruleDescription();

        @Override
        public String toString() {
            return "'" + propertyName + "' is '" + ruleDescription() + " '" + number + "'";
        }
    }

    protected static class MinimumValidator extends NumericValidator {
        private static final long serialVersionUID = 1L;

        public MinimumValidator( String propertyName,
                                 Number minimum ) {
            super(propertyName, minimum);
        }

        @Override
        protected boolean isValid( double minimum,
                                   double actualValue ) {
            return actualValue >= minimum;
        }

        @Override
        protected String ruleDescription() {
            return "greater than or equal to";
        }
    }

    /**
     * Validation rule that states fails if the actual value is equal to or less than the minimum value.
     */
    protected static class ExclusiveMinimumValidator extends NumericValidator {
        private static final long serialVersionUID = 1L;

        public ExclusiveMinimumValidator( String propertyName,
                                          Number minimum ) {
            super(propertyName, minimum);
        }

        @Override
        protected boolean isValid( double minimum,
                                   double actualValue ) {
            return actualValue > minimum;
        }

        @Override
        protected String ruleDescription() {
            return "greater than";
        }
    }

    protected static class MaximumValidator extends NumericValidator {
        private static final long serialVersionUID = 1L;

        public MaximumValidator( String propertyName,
                                 Number maximum ) {
            super(propertyName, maximum);
        }

        @Override
        protected boolean isValid( double maximum,
                                   double actualValue ) {
            return actualValue <= maximum;
        }

        @Override
        protected String ruleDescription() {
            return "less than or equal to";
        }
    }

    protected static class ExclusiveMaximumValidator extends NumericValidator {
        private static final long serialVersionUID = 1L;

        public ExclusiveMaximumValidator( String propertyName,
                                          Number maximum ) {
            super(propertyName, maximum);
        }

        @Override
        protected boolean isValid( double maximum,
                                   double actualValue ) {
            return actualValue < maximum;
        }

        @Override
        protected String ruleDescription() {
            return "less than";
        }
    }

    protected static class MinimumLengthValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final int minimumLength;

        public MinimumLengthValidator( String propertyName,
                                       int minimumLength ) {
            this.propertyName = propertyName;
            this.minimumLength = minimumLength;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof String || fieldValue instanceof Symbol) {
                String value = fieldValue.toString();
                if (value.length() < minimumLength) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had " + value.length()
                                                                       + " characters, but was expected to have at least "
                                                                       + minimumLength);
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' has a minimum length of " + minimumLength;
        }
    }

    protected static class MaximumLengthValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final int maximumLength;

        public MaximumLengthValidator( String propertyName,
                                       int maximumLength ) {
            this.propertyName = propertyName;
            this.maximumLength = maximumLength;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof String || fieldValue instanceof Symbol) {
                String value = fieldValue.toString();
                if (value.length() > maximumLength) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had " + value.length()
                                                                       + " characters, but was expected to have no more than "
                                                                       + maximumLength);
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' has a maximum length of " + maximumLength;
        }
    }

    protected static class DivisibleByValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final int denominator;

        public DivisibleByValidator( String propertyName,
                                     int denominator ) {
            this.propertyName = propertyName;
            this.denominator = denominator;
            assert this.denominator != 0;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (Null.matches(fieldValue)) return;
            if (fieldValue instanceof Integer) {
                int value = ((Integer)fieldValue).intValue();
                if (value % denominator != 0) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had a value of " + value
                                                                       + " and was not divisible by " + denominator);
                } else {
                    problems.recordSuccess();
                }
            } else if (fieldValue instanceof Long) {
                long value = ((Long)fieldValue).longValue();
                if (value % denominator != 0L) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had a value of " + value
                                                                       + " and was not divisible by " + denominator);
                } else {
                    problems.recordSuccess();
                }
            } else if (fieldValue instanceof Short) {
                int value = ((Short)fieldValue).intValue();
                if (value % denominator != 0) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had a value of " + value
                                                                       + " and was not divisible by " + denominator);
                } else {
                    problems.recordSuccess();
                }
            } else if (fieldValue instanceof Float) {
                float value = ((Float)fieldValue).floatValue();
                if (value % denominator != 0.0f) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had a value of " + value
                                                                       + " and was not divisible by " + denominator);
                } else {
                    problems.recordSuccess();
                }
            } else if (fieldValue instanceof Double) {
                double value = ((Double)fieldValue).floatValue();
                if (value % denominator != 0.0d) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' had a value of " + value
                                                                       + " and was not divisible by " + denominator);
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' must be divisible by " + denominator;
        }
    }

    protected static abstract class ItemCountValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final int number;

        protected ItemCountValidator( String propertyName,
                                      int number ) {
            this.propertyName = propertyName;
            this.number = number;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof List) {
                List<?> array = (List<?>)fieldValue;
                if (evaluate(number, array.size())) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' has '" + array.size() + "' values but should have "
                                                                       + ruleDescription() + " '" + number + "'");
                } else {
                    problems.recordSuccess();
                }
            }
            // otherwise the value is not a number and the minimum doesn't apply
        }

        protected abstract boolean evaluate( double value,
                                             double actualValue );

        protected abstract String ruleDescription();

        @Override
        public String toString() {
            return "'" + propertyName + "' has '" + ruleDescription() + " '" + number + "' items";
        }
    }

    protected static class MinimumItemsValidator extends ItemCountValidator {
        private static final long serialVersionUID = 1L;

        public MinimumItemsValidator( String propertyName,
                                      int minimum ) {
            super(propertyName, minimum);
        }

        @Override
        protected boolean evaluate( double minimumCount,
                                    double actualCount ) {
            return minimumCount < actualCount;
        }

        @Override
        protected String ruleDescription() {
            return "at least";
        }
    }

    protected static class MaximumItemsValidator extends ItemCountValidator {
        private static final long serialVersionUID = 1L;

        public MaximumItemsValidator( String propertyName,
                                      int maximum ) {
            super(propertyName, maximum);
        }

        @Override
        protected boolean evaluate( double maximumCount,
                                    double actualCount ) {
            return maximumCount < actualCount;
        }

        @Override
        protected String ruleDescription() {
            return "no more than";
        }
    }

    protected static class UniqueItemsValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;

        public UniqueItemsValidator( String propertyName ) {
            this.propertyName = propertyName;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            // This only applies if the value is a JSON array ...
            if (fieldValue instanceof List) {
                List<?> array = (List<?>)fieldValue;
                Set<?> uniqueValues = new HashSet<Object>(array);
                int numDups = array.size() - uniqueValues.size();
                if (numDups != 0) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' must contain unique values, but contains " + numDups
                                                                       + " duplicate values");
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' contains unique items";
        }
    }

    protected static class PatternValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Pattern pattern;

        public PatternValidator( String propertyName,
                                 Pattern pattern ) {
            this.propertyName = propertyName;
            this.pattern = pattern;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof String || fieldValue instanceof Symbol) {
                String value = fieldValue.toString();
                Matcher matcher = pattern.matcher(value);
                if (!matcher.matches()) {
                    problems.recordError(pathToParent.with(fieldName),
                                         "The '" + fieldName + "' field on '" + pathToParent
                                         + "' failed match the pattern specified by '" + pattern.pattern() + "'");
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' matches pattern '" + pattern.pattern() + "'";
        }
    }

    protected static class EnumValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Set<String> values;

        public EnumValidator( String propertyName,
                              Collection<?> values ) {
            this.propertyName = propertyName;
            this.values = new HashSet<String>(values.size());
            for (Object value : values) {
                this.values.add(value.toString().toLowerCase());
            }
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (!propertyName.equals(fieldName)) return;
            // This only applies if the value is a JSON array ...
            if (fieldValue instanceof List) {
                for (Object value : (List<?>)fieldValue) {
                    if (values.contains(value.toString().toLowerCase())) {
                        problems.recordSuccess();
                    } else {
                        problems.recordError(pathToParent.with(fieldName),
                                             "The '" + fieldName + "' field on '" + pathToParent + "' contains a value '" + value
                                             + "' in the array that is not part of the enumeration: " + values);
                    }
                }
            } else if (fieldValue != null) {
                if (values.contains(fieldValue.toString().toLowerCase())) {
                    problems.recordSuccess();
                } else {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' has a value of '" + fieldValue
                                                                       + "' that is not part of the enumeration: " + values);
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' contains values from enumeration: " + values;
        }
    }

    protected static class DisallowedTypesValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final EnumSet<Type> disallowedTypes;

        public DisallowedTypesValidator( String propertyName,
                                         EnumSet<Type> disallowedTypes ) {
            this.propertyName = propertyName;
            this.disallowedTypes = disallowedTypes;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            Type type = Type.typeFor(fieldValue);
            if (type != Type.NULL) {
                if (disallowedTypes.contains(type)) {
                    problems.recordError(pathToParent.with(fieldName), "The '" + fieldName + "' field on '" + pathToParent
                                                                       + "' contains a value '" + fieldValue + "' whose type '"
                                                                       + type + "' is disallowed.");
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' may not have values with the types " + disallowedTypes;
        }
    }

    /**
     * The {@link Validator} for item values that should all match a single schema.
     * 
     * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
     * @since 5.1
     */
    protected static class AllItemsMatchValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Validator itemValidator;
        private final SingleProblem itemProblems = new SingleProblem();

        public AllItemsMatchValidator( String propertyName,
                                       Validator itemValidator ) {
            this.propertyName = propertyName;
            this.itemValidator = itemValidator;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof List) {
                // Each item in the list must match the itemValidator or additionalItemsValidator ...
                List<?> items = (List<?>)fieldValue;
                Path path = pathToParent.with(fieldName);
                int i = 1;
                boolean success = true;
                for (Object item : items) {
                    itemProblems.clear();
                    itemValidator.validate(item, fieldName, parent, pathToParent, itemProblems, resolver);
                    if (itemProblems.hasProblem()) {
                        problems.recordError(path, "The '" + fieldName + "' field on '" + pathToParent
                                                   + "' is an array, but the " + i + th(i)
                                                   + " item does not satisfy the schema for the " + i + th(i) + " item");
                        success = false;
                    }
                    ++i;
                }
                if (success) problems.recordSuccess();
            } else if (parent instanceof List) {
                // we are dealing with an optional array of items
                List<?> items = (List<?>)parent;
                int i = 1;
                boolean success = true;
                for (Object item : items) {
                    itemProblems.clear();
                    if (item instanceof Document) {
                        itemValidator.validate(null, null, (Document)item, pathToParent, itemProblems, resolver);
                        if (itemProblems.hasProblem()) {
                            success = false;
                        }
                    } else {
                        fieldName = item.toString();
                        Path path = pathToParent.with(fieldName);
                        itemValidator.validate(item, fieldName, parent, pathToParent, itemProblems, resolver);
                        if (itemProblems.hasProblem()) {
                            problems.recordError(path, "The '" + fieldName + "' field on '" + pathToParent
                                                       + "' is an array, but the " + i + th(i)
                                                       + " item does not satisfy the schema for the " + i + th(i) + " item");
                            success = false;
                        }
                    }
                    ++i;
                }
                if (success) problems.recordSuccess();
            }

        }

        @Override
        public String toString() {
            return "'" + propertyName + "' may be an array with items matching the schema: " + itemValidator;
        }
    }

    /**
     * The {@link Validator} for "tuple typing", when item values should each match a corresponding schema or, if applicable, an
     * additional items schema.
     * 
     * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
     * @since 5.1
     */
    protected static class EachItemMatchesValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final List<Validator> itemValidators;
        private final Validator additionalItemsValidator;
        private final SingleProblem itemProblems = new SingleProblem();
        private final boolean additionalItemsAllowed;

        public EachItemMatchesValidator( String propertyName,
                                         List<Validator> itemValidators,
                                         Validator additionalItemsValidator,
                                         boolean additionalItemsAllowed ) {
            this.propertyName = propertyName;
            this.itemValidators = itemValidators;
            this.additionalItemsValidator = additionalItemsValidator;
            this.additionalItemsAllowed = additionalItemsAllowed;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue instanceof List) {
                // Each item in the list must match the itemValidator or additionalItemsValidator ...
                List<?> items = (List<?>)fieldValue;
                Path path = pathToParent.with(fieldName);
                int i = 0;
                Iterator<?> itemIterator = items.iterator();
                Iterator<Validator> itemValidatorIterator = itemValidators.iterator();
                boolean success = true;
                while (itemIterator.hasNext() && itemValidatorIterator.hasNext()) {
                    ++i;
                    Object item = itemIterator.next();
                    Validator itemValidator = itemValidatorIterator.next();
                    itemValidator.validate(item, fieldName, parent, pathToParent, itemProblems, resolver);
                }
                if (additionalItemsAllowed && additionalItemsValidator != null) {
                    while (itemIterator.hasNext()) {
                        ++i;
                        Object item = itemIterator.next();
                        itemProblems.clear();
                        additionalItemsValidator.validate(item, fieldName, parent, pathToParent, itemProblems, resolver);
                        if (itemProblems.hasProblem()) {
                            problems.recordError(path,
                                                 "The '"
                                                 + fieldName
                                                 + "' field on '"
                                                 + pathToParent
                                                 + "' is an array, but the "
                                                 + i
                                                 + th(i)
                                                 + " item does have a corresponding schema and does not satisfy the additional items schema)");
                            success = false;
                        }
                    }
                } else if (!additionalItemsAllowed) {
                    while (itemIterator.hasNext()) {
                        ++i;
                        problems.recordError(path,
                                             "The '" + fieldName + "' field on '" + pathToParent + "' is an array, but the " + i
                                             + th(i)
                                             + " item does have a corresponding schema (and no additional items were specified)");
                        success = false;
                    }
                }
                if (success) problems.recordSuccess();
            }
        }

        @Override
        public String toString() {
            return "'" + propertyName + "' may be an array with items matching the schemas: " + itemValidators
                   + (additionalItemsValidator == null ? "" : " or the additional items schema " + additionalItemsValidator);
        }
    }

    protected static class NotValidValidator implements Validator {
        private static final long serialVersionUID = 1L;

        public NotValidValidator() {
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            problems.recordError(pathToParent, "");
        }

        @Override
        public String toString() {
            return "not valid";
        }
    }

    protected static String th( int i ) {
        switch (i) {
            case 1:
                return "st";
            case 2:
                return "nd";
            case 3:
                return "rd";
        }
        return "th";
    }

    protected static RequiredValidator getRequiredValidator( Validator validator ) {
        if (validator instanceof RequiredValidator) return (RequiredValidator)validator;
        if (validator instanceof ValidatorCollection) {
            for (Validator val : ((ValidatorCollection)validator)) {
                if (val instanceof RequiredValidator) return (RequiredValidator)val;
            }
        }
        return null;
    }

    protected static class PropertyValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Validator validator;
        private final RequiredValidator required;

        public PropertyValidator( String propertyName,
                                  Validator validator ) {
            this.propertyName = propertyName;
            this.validator = validator;
            this.required = getRequiredValidator(validator);
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldName == null) {
                fieldName = propertyName;
            }
            if (fieldValue == null) {
                fieldValue = parent.get(propertyName);
            }
            if (fieldValue == null) {
                if (required != null) {
                    // The field is required ...
                    required.validate(fieldValue, fieldName, parent, pathToParent, problems, resolver);
                }
                return;
            }
            if (fieldValue instanceof Document) {
                validator.validate(null, null, (Document)fieldValue, pathToParent.with(fieldName), problems, resolver);
            } else {
                validator.validate(fieldValue, fieldName, parent, pathToParent, problems, resolver);
            }
        }

        @Override
        public String toString() {
            return "property '" + propertyName + "': " + validator.toString();
        }
    }

    protected static class PatternPropertyValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final Pattern propertyNamePattern;
        private final Validator validator;

        public PatternPropertyValidator( Pattern propertyNamePattern,
                                         Validator validator ) {
            this.propertyNamePattern = propertyNamePattern;
            this.validator = validator;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue == null) return;
            Matcher matcher = propertyNamePattern.matcher(fieldName);
            if (matcher.matches()) {
                // Apply the validator to the field value ...
                validator.validate(fieldValue, fieldName, parent, pathToParent, problems, resolver);
            }
        }

        @Override
        public String toString() {
            return "pattern property '" + propertyNamePattern.pattern() + "': " + validator.toString();
        }
    }

    protected static class AllowedPropertiesValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final Set<String> allowedPropertyNames;
        private final Validator validator;

        public AllowedPropertiesValidator( Set<String> allowedPropertyNames,
                                           Validator validator ) {
            this.allowedPropertyNames = allowedPropertyNames;
            this.validator = validator;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldName != null && !allowedPropertyNames.contains(fieldName)) {
                // Then the field is not handled by an explicit schema, so we need to check it here
                validator.validate(fieldValue, fieldName, parent, pathToParent, problems, resolver);
            } else if (fieldName == null) {
                // we need to validate each defined additional property which has a schema
                for (Field field : parent.fields()) {
                    if (field.getValue() instanceof Document) {
                        validator.validate(null,
                                           null,
                                           (Document)field.getValue(),
                                           pathToParent.with(field.getName()),
                                           problems,
                                           resolver);
                    } else {
                        validator.validate(field.getValue(), field.getName(), parent, pathToParent, problems, resolver);
                    }
                }
            }
        }

        @Override
        public String toString() {
            return "additional properties allowed: " + validator.toString();
        }
    }

    protected static class NoOtherAllowedPropertiesValidator implements Validator {
        private static final long serialVersionUID = 1L;
        private final Set<String> allowedPropertyNames;

        public NoOtherAllowedPropertiesValidator( Set<String> allowedPropertyNames ) {
            this.allowedPropertyNames = allowedPropertyNames;
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            if (fieldValue == null) {
                if (fieldName == null) {
                    // Go through all of the fields in the document ...
                    for (Field field : parent.fields()) {
                        validate(field.getValue(), field.getName(), parent, pathToParent, problems, resolver);
                    }
                }
            } else {
                if (!allowedPropertyNames.contains(fieldName)) {
                    // Then the field is not handled by an explicit schema, so it's not allowed ...
                    problems.recordError(pathToParent.with(fieldName),
                                         "The '" + fieldName + "' field on '" + pathToParent
                                         + "' is not defined in the schema and the schema does not allow additional properties.");
                } else {
                    problems.recordSuccess();
                }
            }
        }

        @Override
        public String toString() {
            return "additional properties not allowed";
        }
    }

    protected static class CompositeValidator implements Validator, ValidatorCollection {
        private static final long serialVersionUID = 1L;

        private final List<Validator> validators = new ArrayList<Validator>();

        public CompositeValidator() {
        }

        protected void add( Validator validator ) {
            this.validators.add(validator);
        }

        protected int size() {
            return this.validators.size();
        }

        protected Validator getFirst() {
            return this.validators.get(0);
        }

        @Override
        public void validate( Object fieldValue,
                              String fieldName,
                              Document parent,
                              Path pathToParent,
                              Problems problems,
                              SchemaDocumentResolver resolver ) {
            for (Validator validator : validators) {
                try {
                    validator.validate(fieldValue, fieldName, parent, pathToParent, problems, resolver);
                } catch (Throwable t) {
                    problems.recordError(pathToParent, t.getMessage(), t);
                }
            }
        }

        @Override
        public Iterator<Validator> iterator() {
            return validators.iterator();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            for (Validator validator : validators) {
                sb.append(validator.toString());
                sb.append("\n");
            }
            return sb.toString();
        }
    }

    protected static class SingleProblem implements Problems {
        private ProblemType type;
        private Path path;
        private String message;
        private Throwable exception;
        private Object actualValue;
        private Object convertedValue;
        private Type actualType;
        private Type requiredType;
        private boolean mismatch = false;
        private boolean success = false;

        @Override
        public void recordSuccess() {
            success = true;
        }

        @Override
        public void recordError( Path path,
                                 String message ) {
            this.type = ProblemType.ERROR;
            this.path = path;
            this.message = message;
            this.exception = null;
            this.actualValue = null;
            this.convertedValue = null;
            this.actualType = null;
            this.requiredType = null;
            this.mismatch = false;
            this.success = false;
        }

        @Override
        public void recordError( Path path,
                                 String message,
                                 Throwable exception ) {
            this.type = ProblemType.ERROR;
            this.path = path;
            this.message = message;
            this.exception = exception;
            this.actualValue = null;
            this.convertedValue = null;
            this.actualType = null;
            this.requiredType = null;
            this.mismatch = false;
            this.success = false;
        }

        @Override
        public void recordWarning( Path path,
                                   String message ) {
            this.type = ProblemType.WARNING;
            this.path = path;
            this.message = message;
            this.exception = null;
            this.actualValue = null;
            this.convertedValue = null;
            this.actualType = null;
            this.requiredType = null;
            this.mismatch = false;
            this.success = false;
        }

        @Override
        public void recordTypeMismatch( Path path,
                                        String message,
                                        Type actualType,
                                        Object actualValue,
                                        Type requiredType,
                                        Object convertedValue ) {
            this.type = ProblemType.ERROR;
            this.path = path;
            this.message = message;
            this.exception = null;
            this.actualValue = actualValue;
            this.convertedValue = convertedValue;
            this.actualType = actualType;
            this.requiredType = requiredType;
            this.mismatch = true;
            this.success = false;
        }

        public boolean hasProblem() {
            return this.type != null;
        }

        public void recordIn( Problems otherProblems ) {
            if (success) {
                otherProblems.recordSuccess();
                return;
            }
            switch (type) {
                case ERROR:
                    if (this.mismatch) {
                        otherProblems.recordTypeMismatch(this.path,
                                                         this.message,
                                                         this.actualType,
                                                         this.actualValue,
                                                         this.requiredType,
                                                         this.convertedValue);
                    } else {
                        otherProblems.recordError(this.path, this.message, this.exception);
                    }
                    break;
                case WARNING:
                    otherProblems.recordWarning(this.path, this.message);
                    break;
            }
        }

        public void clear() {
            this.type = null;
            this.success = false;
        }
    }
}
