/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright 2005-2011 the ConQAT Project                                   |
|                                                                          |
| 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.conqat.engine.commons.util;

import java.lang.reflect.Field;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

import javax.annotation.Nullable;

import org.conqat.engine.core.core.ConQATException;
import org.conqat.lib.commons.collections.IdentityHashSet;
import org.conqat.lib.commons.reflect.ReflectionUtils;
import org.conqat.lib.commons.string.StringUtils;

import com.teamscale.commons.lang.ToStringHelpers;

/**
 * Validator that checks whether all values of an object are non-null unless
 * explicitly specified as {@link Nullable}.
 */
public class NullableFieldValidator {

        /**
         * Ensures that the given object is not null and that all its fields are set
         * (throws {@link ConQATException} otherwise). Arrays and other iterables are
         * checked recursively, as well as all fields of the given object (but only if
         * their type is defined in ConQAT/Teamscale packages).
         *
         * If you get a false positive for a field from this method, annotate the field
         * as {@link Nullable}.
         */
        public static <T> T ensureAllFieldsNonNull(T parsedObject, String queryContent) throws ConQATException {
                if (StringUtils.isEmpty(queryContent)) {
                        // Returns null, but that's okay for empty queries
                        return parsedObject;
                }

                try {
                        return ensureAllFieldsNonNull(parsedObject);
                } catch (ConQATException e) {
                        throw new ConQATException(e.getMessage() + "\nQuery: " + queryContent, e);
                }
        }

        /**
         * Ensures that the given object is not null and that all its fields are set
         * (throws {@link ConQATException} otherwise). Arrays and other iterables are
         * checked recursively, as well as all fields of the given object (but only if
         * their type is defined in ConQAT/Teamscale packages).
         *
         * If you get a false positive for a field from this method, annotate the field
         * as {@link Nullable}.
         */
        public static <T> T ensureAllFieldsNonNull(T parsedObject) throws ConQATException {
                if (parsedObject == null) {
                        throw createNullObjectException("<null>", "whole object");
                }

                Deque<Object> objectsToCheck = new ArrayDeque<>();
                if (ReflectionUtils.isIterable(parsedObject)) {
                        objectsToCheck.addAll(checkIterableAndGetContainedFields(parsedObject, "<object in given iterable>"));
                } else {
                        objectsToCheck.push(parsedObject);
                }

                IdentityHashSet<Object> visitedObjects = new IdentityHashSet<>();
                while (!objectsToCheck.isEmpty()) {
                        Object objectToCheck = objectsToCheck.pop();
                        if (!visitedObjects.add(objectToCheck)) {
                                // We have already checked this object
                                continue;
                        }
                        objectsToCheck.addAll(checkObjectAndGetReferencedFields(objectToCheck));
                }
                return parsedObject;
        }

        /** Create a null object exception. */
        private static <T> ConQATException createNullObjectException(T object, String checkedPart) {
                return new ConQATException("The query contained input that would have been deserialized to null (" + checkedPart
                                + ").\nResulting object: " + ToStringHelpers.toReflectiveStringHelper(object)
                                + " - Missing @Nullable annotation?");
        }

        /** Checks a single object and returns the fields it references. */
        private static List<Object> checkObjectAndGetReferencedFields(Object objectToCheck) throws ConQATException {
                List<Object> referencedObjects = new ArrayList<>();
                for (Field field : ReflectionUtils.getAllFields(objectToCheck.getClass())) {
                        if (JsonUtils.isNotSerialized(field) || fieldMaySkipNullCheck(field)) {
                                continue;
                        }

                        field.setAccessible(true);
                        try {
                                Object referencedObject = field.get(objectToCheck);
                                if (referencedObject == null) {
                                        throw createNullObjectException(objectToCheck, "at field " + field.getName());
                                }

                                if (ReflectionUtils.isIterable(referencedObject)) {
                                        referencedObjects.addAll(checkIterableAndGetContainedFields(referencedObject, field.getName()));
                                        // We don't need to add the container object to referenced
                                        // objects
                                        continue;
                                }

                                // Check for correct package. This can only be done down here, if we included it
                                // in fieldMaySkipNullCheck() we would also skip over iterable Java core types
                                if (field.getType().getPackage() != null
                                                && StringUtils.containsOneOf(field.getType().getPackage().getName(), "teamscale", "conqat")) {
                                        referencedObjects.add(referencedObject);
                                }
                        } catch (IllegalArgumentException | IllegalAccessException e) {
                                throw new ConQATException("Could not access field", e);
                        }
                }
                return referencedObjects;
        }

        /** Check */
        private static List<Object> checkIterableAndGetContainedFields(Object arrayOrIterable, String checkedField)
                        throws ConQATException {
                List<Object> containedObjects = new ArrayList<>();
                for (Object containedObject : ReflectionUtils.asIterable(arrayOrIterable)) {
                        if (containedObject == null) {
                                throw createNullObjectException(arrayOrIterable, "at field " + checkedField);
                        }
                        containedObjects.add(containedObject);
                }
                return containedObjects;
        }

        /**
         * Whether a field is relevant for the null check, i.e. it (a) can be null, and
         * (b) is not expected to actually be null.
         */
        private static boolean fieldMaySkipNullCheck(Field field) {
                return field.getType().isPrimitive() || field.isAnnotationPresent(Nullable.class)
                                || field.getName().contains("$");
        }
}