// $Id: TestUtil.java 17620 2009-10-04 19:19:28Z hardy.ferentschik $
/*
 * JBoss, Home of Professional Open Source Copyright 2009, Red Hat, Inc. and/or
 * its affiliates, and individual contributors by the @authors tag. See the
 * copyright.txt in the distribution for a full listing of individual
 * contributors.
 *
 * 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.hibernate.jsr303.tck.util;

import com.google.gwt.core.client.GWT;
import com.google.gwt.regexp.shared.MatchResult;
import com.google.gwt.regexp.shared.RegExp;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.validation.Configuration;
import javax.validation.ConstraintViolation;
import javax.validation.MessageInterpolator;
import javax.validation.Path;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.Validation;
import javax.validation.bootstrap.GenericBootstrap;
import javax.validation.metadata.ConstraintDescriptor;
import javax.validation.metadata.ElementDescriptor;
import javax.validation.metadata.PropertyDescriptor;
import javax.validation.spi.ValidationProvider;

/**
 * Modified by Google.
 * <ul>
 * <li>Use RegExp instead of Pattern</li>
 * </ul>
 * @author Hardy Ferentschik
 */
public final class TestUtil {

  private static String VALIDATION_PROVIDER_TEST_CLASS = "validation.provider";

  private static ValidationProvider<?> validationProviderUnderTest;

  private TestUtil() {
  }

  public static Validator getValidatorUnderTest() {
    return getValidatorFactoryUnderTest().getValidator();
  }

  public static ValidationProvider<?> getValidationProviderUnderTest() {
    if (validationProviderUnderTest == null) {
      instantiateValidationProviderUnderTest();
    }
    return validationProviderUnderTest;
  }

  public static ValidatorFactory getValidatorFactoryUnderTest() {
    Configuration<?> config = getConfigurationUnderTest();
    return config.buildValidatorFactory();
  }

  public static Configuration<?> getConfigurationUnderTest() {
    if (validationProviderUnderTest == null) {
      instantiateValidationProviderUnderTest();
    }

    GenericBootstrap bootstrap = Validation.byDefaultProvider();
    return bootstrap.configure();
  }

  public static MessageInterpolator getDefaultMessageInterpolator() {
    Configuration<?> config = getConfigurationUnderTest();
    return config.getDefaultMessageInterpolator();
  }

  public static <T> void assertCorrectNumberOfViolations(
      Set<ConstraintViolation<T>> violations, int expectedViolations) {
    assertEquals(violations.size(), expectedViolations,
        "Wrong number of constraint violations. Expected: "
            + expectedViolations + " Actual: " + violations.size());
  }

  public static <T> void assertCorrectConstraintViolationMessages(
      Set<ConstraintViolation<T>> violations, String... messages) {
    List<String> actualMessages = new ArrayList<String>();
    for (ConstraintViolation<?> violation : violations) {
      actualMessages.add(violation.getMessage());
    }

    assertTrue(actualMessages.size() == messages.length,
        "Wrong number or error messages. Expected: " + messages.length
            + " Actual: " + actualMessages.size());

    for (String expectedMessage : messages) {
      assertTrue(actualMessages.contains(expectedMessage), "The message '"
          + expectedMessage
          + "' should have been in the list of actual messages: "
          + actualMessages);
      actualMessages.remove(expectedMessage);
    }
    assertTrue(actualMessages.isEmpty(),
        "Actual messages contained more messages as specified expected messages");
  }

  public static <T> void assertCorrectConstraintTypes(
      Set<ConstraintViolation<T>> violations,
      Class<?>... expectedConsraintTypes) {
    List<String> actualConstraintTypes = new ArrayList<String>();
    for (ConstraintViolation<?> violation : violations) {
      actualConstraintTypes.add(((Annotation) violation.getConstraintDescriptor().getAnnotation()).annotationType().getName());
    }

    assertEquals(expectedConsraintTypes.length, actualConstraintTypes.size(),
        "Wrong number of constraint types.");

    for (Class<?> expectedConstraintType : expectedConsraintTypes) {
      assertTrue(
          actualConstraintTypes.contains(expectedConstraintType.getName()),
          "The constraint type " + expectedConstraintType.getName()
              + " is not in the list of actual violated constraint types: "
              + actualConstraintTypes);
    }
  }

  public static <T> void assertCorrectPropertyPaths(
      Set<ConstraintViolation<T>> violations, String... propertyPaths) {
    List<Path> propertyPathsOfViolations = new ArrayList<Path>();
    for (ConstraintViolation<?> violation : violations) {
      propertyPathsOfViolations.add(violation.getPropertyPath());
    }

    assertEquals(propertyPaths.length, propertyPathsOfViolations.size(),
        "Wrong number of property paths. Expected: " + propertyPaths.length
            + " Actual: " + propertyPathsOfViolations.size());

    for (String propertyPath : propertyPaths) {
      Path expectedPath = PathImpl.createPathFromString(propertyPath);
      boolean containsPath = false;
      for (Path actualPath : propertyPathsOfViolations) {
        if (assertEqualPaths(expectedPath, actualPath)) {
          containsPath = true;
          break;
        }
      }
      if (!containsPath) {
        fail(expectedPath
            + " is not in the list of path instances contained in the actual constraint violations: "
            + propertyPathsOfViolations);
      }
    }
  }

  public static <T> void assertConstraintViolation(
      ConstraintViolation<T> violation, Class<?> rootBean, Object invalidValue,
      String propertyPath) {
    Path expectedPath = PathImpl.createPathFromString(propertyPath);
    if (!assertEqualPaths(violation.getPropertyPath(), expectedPath)) {
      fail("Property paths differ. Actual: " + violation.getPropertyPath()
          + " Expected: " + expectedPath);
    }

    assertEquals(violation.getRootBeanClass(), rootBean, "Wrong root bean.");
    assertEquals(violation.getInvalidValue(), invalidValue,
        "Wrong invalid value.");
  }

  public static boolean assertEqualPaths(Path p1, Path p2) {
    Iterator<Path.Node> p1Iterator = p1.iterator();
    Iterator<Path.Node> p2Iterator = p2.iterator();
    while (p1Iterator.hasNext()) {
      Path.Node p1Node = p1Iterator.next();
      if (!p2Iterator.hasNext()) {
        return false;
      }
      Path.Node p2Node = p2Iterator.next();

      // do the comparison on the node values
      if (p2Node.getName() == null) {
        if (p1Node.getName() != null) {
          return false;
        }
      } else if (!p2Node.getName().equals(p1Node.getName())) {
        return false;
      }

      if (p2Node.isInIterable() != p1Node.isInIterable()) {
        return false;
      }

      if (p2Node.getIndex() == null) {
        if (p1Node.getIndex() != null) {
          return false;
        }
      } else if (!p2Node.getIndex().equals(p1Node.getIndex())) {
        return false;
      }

      if (p2Node.getKey() == null) {
        if (p1Node.getKey() != null) {
          return false;
        }
      } else if (!p2Node.getKey().equals(p1Node.getKey())) {
        return false;
      }
    }

    return !p2Iterator.hasNext();
  }

  public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz,
      String property) {
    Validator validator = getValidatorUnderTest();
    return validator.getConstraintsForClass(clazz).getConstraintsForProperty(
        property);
  }

  public static Set<ConstraintDescriptor<?>> getConstraintDescriptorsFor(
      Class<?> clazz, String property) {
    ElementDescriptor elementDescriptor = getPropertyDescriptor(clazz, property);
    return elementDescriptor.getConstraintDescriptors();
  }

  public static Object getInputStreamForPath(String path) {

    return null;
  }

  private static <U extends ValidationProvider<?>> void instantiateValidationProviderUnderTest() {
      validationProviderUnderTest = GWT.create(ValidationProvider.class);
  }

  public static class PathImpl implements Path {

    /**
     * Regular expression used to split a string path into its elements.
     *
     * @see <a href="http://www.regexplanet.com/simple/index.jsp">Regular
     *      expression tester</a>
     */
    private static final RegExp pathPattern = RegExp.compile("(\\w+)(\\[(\\w*)\\])?(\\.(.*))*");

    private static final String PROPERTY_PATH_SEPARATOR = ".";

    private final List<Node> nodeList;

    public static PathImpl createPathFromString(String propertyPath) {
      if (propertyPath == null) {
        throw new IllegalArgumentException(
            "null is not allowed as property path.");
      }

      if (propertyPath.length() == 0) {
        return createNewPath(null);
      }

      return parseProperty(propertyPath);
    }

    public static PathImpl createNewPath(String name) {
      PathImpl path = new PathImpl();
      NodeImpl node = new NodeImpl(name);
      path.addNode(node);
      return path;
    }

    private PathImpl() {
      nodeList = new ArrayList<Node>();
    }

    public void addNode(Node node) {
      nodeList.add(node);
    }

    public Iterator<Path.Node> iterator() {
      return nodeList.iterator();
    }

    @Override
    public String toString() {
      StringBuilder builder = new StringBuilder();
      Iterator<Path.Node> iter = iterator();
      while (iter.hasNext()) {
        Node node = iter.next();
        builder.append(node.toString());
        if (iter.hasNext()) {
          builder.append(PROPERTY_PATH_SEPARATOR);
        }
      }
      return builder.toString();
    }

    private static PathImpl parseProperty(String property) {
      PathImpl path = new PathImpl();
      String tmp = property;
      do {
        MatchResult matcher = pathPattern.exec(tmp);
        if (matcher != null) {
          String value = matcher.getGroup(1);
          String indexed = matcher.getGroup(2);
          String index = matcher.getGroup(3);
          NodeImpl node = new NodeImpl(value);

          if (indexed != null && indexed.length() > 0) {
            node.setInIterable(true);
          }
          if (index != null && index.length() > 0) {
            try {
              Integer i = Integer.parseInt(index);
              node.setIndex(i);
            } catch (NumberFormatException e) {
              node.setKey(index);
            }
          }
          path.addNode(node);
          tmp = matcher.getGroup(5);
        } else {
          throw new IllegalArgumentException("Unable to parse property path "
              + property);
        }
      } while (tmp != null && tmp.length() > 0);
      return path;
    }
  }

  public static class NodeImpl implements Path.Node {

    private static final String INDEX_OPEN = "[";
    private static final String INDEX_CLOSE = "]";

    private final String name;
    private boolean isInIterable;
    private Integer index;
    private Object key;

    public NodeImpl(String name) {
      this.name = name;
    }

    NodeImpl(Path.Node node) {
      this.name = node.getName();
      this.isInIterable = node.isInIterable();
      this.index = node.getIndex();
      this.key = node.getKey();
    }

    public String getName() {
      return name;
    }

    public boolean isInIterable() {
      return isInIterable;
    }

    public void setInIterable(boolean inIterable) {
      isInIterable = inIterable;
    }

    public Integer getIndex() {
      return index;
    }

    public void setIndex(Integer index) {
      isInIterable = true;
      this.index = index;
    }

    public Object getKey() {
      return key;
    }

    public void setKey(Object key) {
      isInIterable = true;
      this.key = key;
    }

    @Override
    public String toString() {
      StringBuilder builder = new StringBuilder(name == null ? "" : name);
      if (isInIterable) {
        builder.append(INDEX_OPEN);
        if (getIndex() != null) {
          builder.append(getIndex());
        } else if (getKey() != null) {
          builder.append(getKey());
        }
        builder.append(INDEX_CLOSE);
      }
      return builder.toString();
    }
  }
}