/*=========================================================================
 * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * one or more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */
/*
 * StructSetOrResultsSet.java
 * Utlity Class : Can be used to compare the results (StructSet OR ResultsSet) under the scenario without/with Index Usage.
 * Created on June 13, 2005, 11:16 AM
 */

package com.gemstone.gemfire.cache.query.functional;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

import com.gemstone.gemfire.LogWriter;
import com.gemstone.gemfire.cache.query.CacheUtils;
import com.gemstone.gemfire.cache.query.FunctionDomainException;
import com.gemstone.gemfire.cache.query.NameResolutionException;
import com.gemstone.gemfire.cache.query.Query;
import com.gemstone.gemfire.cache.query.QueryInvocationTargetException;
import com.gemstone.gemfire.cache.query.SelectResults;
import com.gemstone.gemfire.cache.query.Struct;
import com.gemstone.gemfire.cache.query.TypeMismatchException;
import com.gemstone.gemfire.cache.query.internal.CompiledGroupBySelect;
import com.gemstone.gemfire.cache.query.internal.CompiledSelect;
import com.gemstone.gemfire.cache.query.internal.CompiledSortCriterion;
import com.gemstone.gemfire.cache.query.internal.CompiledValue;
import com.gemstone.gemfire.cache.query.internal.DefaultQuery;
import com.gemstone.gemfire.cache.query.internal.ExecutionContext;
import com.gemstone.gemfire.cache.query.internal.OrderByComparator;
import com.gemstone.gemfire.cache.query.internal.QueryObserverAdapter;
import com.gemstone.gemfire.cache.query.internal.QueryObserverHolder;
import com.gemstone.gemfire.cache.query.internal.parse.OQLLexerTokenTypes;
import com.gemstone.gemfire.cache.query.types.ObjectType;
import com.gemstone.gemfire.internal.util.ArrayUtils;

/**
 * @author vikramj, shobhit
 */
public class StructSetOrResultsSet extends TestCase {

 
  public void CompareQueryResultsWithoutAndWithIndexes(Object[][] r, int len,
      String queries[]) {
    CompareQueryResultsWithoutAndWithIndexes(r, len, false, queries);
  }

  /** Creates a new instance of StructSetOrResultsSet */
  public void CompareQueryResultsWithoutAndWithIndexes(Object[][] r, int len,
      boolean checkOrder, String queries[]) {

    Collection coll1 = null;
    Collection coll2 = null;
    Iterator itert1 = null;
    Iterator itert2 = null;
    ObjectType type1, type2;
    for (int j = 0; j < len; j++) {
      type1 = ((SelectResults) r[j][0]).getCollectionType().getElementType();
      type2 = ((SelectResults) r[j][1]).getCollectionType().getElementType();
      if ((type1.getClass().getName()).equals(type2.getClass().getName())) {
        CacheUtils.log("Both SelectResults are of the same Type i.e.--> "
            + ((SelectResults) r[j][0]).getCollectionType().getElementType());
      } else {
        CacheUtils.log("Classes are : " + type1.getClass().getName() + " "
            + type2.getClass().getName());
        fail("FAILED:Select result Type is different in both the cases."
            + "; failed query=" + queries[j]);
      }
      if (((SelectResults) r[j][0]).size() == ((SelectResults) r[j][1]).size()) {
        CacheUtils.log("Both SelectResults are of Same Size i.e.  Size= "
            + ((SelectResults) r[j][1]).size());
      } else {
        fail("FAILED:SelectResults size is different in both the cases. Size1="
            + ((SelectResults) r[j][0]).size() + " Size2 = "
            + ((SelectResults) r[j][1]).size() + "; failed query=" + queries[j]);
      }
      
      if (checkOrder) {
        coll2 = (((SelectResults) r[j][1]).asList());
        coll1 = (((SelectResults) r[j][0]).asList());
      } else {
        coll2 = (((SelectResults) r[j][1]).asSet());
        coll1 = (((SelectResults) r[j][0]).asSet());
      }
      // boolean pass = true;
      itert1 = coll1.iterator();
      itert2 = coll2.iterator();
      while (itert1.hasNext()) {
        Object p1 = itert1.next();
        if (!checkOrder) {
          itert2 = coll2.iterator();
        }

        boolean exactMatch = false;
        while (itert2.hasNext()) {
          Object p2 = itert2.next();
          if (p1 instanceof Struct) {
            Object[] values1 = ((Struct) p1).getFieldValues();
            Object[] values2 = ((Struct) p2).getFieldValues();
            assertEquals(values1.length, values2.length);
            boolean elementEqual = true;
            for (int i = 0; i < values1.length; ++i) {
              // CacheUtils.log("Comparing: " + values1[i] + " with: " +
              // values2[i]);
              elementEqual = elementEqual
                  && ((values1[i] == values2[i]) || values1[i]
                      .equals(values2[i]));
            }
            exactMatch = elementEqual;
          } else {
            // CacheUtils.log("Comparing: " + p1 + " with: " + p2);
            exactMatch = (p2 == p1) || p2.equals(p1);
          }
          if (exactMatch || checkOrder) {
            break;
          }
        }
        if (!exactMatch) {
          fail("Atleast one element in the pair of SelectResults "
              + "supposedly identical, is not equal " + "Match not found for :"
              + p1 + "; failed query=" + queries[j] + "; element unmatched ="
              + p1 + ";p1 class=" + p1.getClass() + " ; other set has ="
              + coll2);
        }
      }
    }
  }

  public void compareExternallySortedQueriesWithOrderBy(String[] queries,
      Object[][] baseResults) throws Exception {
    for (int i = 0; i < queries.length; i++) {
      Query q = null;
      try {
        String query = queries[i];
        int indexOfOrderBy = query.indexOf("order ");
        query = query.substring(0, indexOfOrderBy);
        q = CacheUtils.getQueryService().newQuery(query);
        CacheUtils.getLogger().info("Executing query: " + query);
        baseResults[i][1] = q.execute();
        int unorderedResultsSize =  ((SelectResults) baseResults[i][1]).size(); 
        if(unorderedResultsSize == 0) {
          fail("The test results size is 0 , it possibly is not validating anything. rewrite the test");
        }
        Wrapper wrapper = getOrderByComparatorAndLimitForQuery(queries[i],unorderedResultsSize );
        if (wrapper.validationLevel != ValidationLevel.NONE) {
          Object[] externallySorted = ((SelectResults) baseResults[i][1])
              .toArray();
          if (wrapper.validationLevel != ValidationLevel.MATCH_ONLY) {
            Arrays.sort(externallySorted, wrapper.obc);
          }
          if (wrapper.limit != -1) {
            if (externallySorted.length > wrapper.limit) {
              Object[] newExternallySorted = new Object[wrapper.limit];
              System.arraycopy(externallySorted, 0, newExternallySorted, 0,
                  wrapper.limit);
              externallySorted = newExternallySorted;
            }
          }
          StructSetOrResultsSet ssOrrs1 = new StructSetOrResultsSet();
          ssOrrs1.compareQueryResultsWithExternallySortedResults(
              (SelectResults) baseResults[i][0], externallySorted, queries[i],
              wrapper);


        }
      } catch (Exception e) {
        e.printStackTrace();
        fail("query with index=" + i + " has failed. failed query="
            + queries[i]);
      }

    }
  }

  private void compareQueryResultsWithExternallySortedResults(SelectResults sr,
      Object[] externallySorted, String query, Wrapper wrapper) {

    if (sr.size() == externallySorted.length) {
      CacheUtils.log("Both SelectResults are of Same Size i.e.  Size= "
          + sr.size());
    } else {
      fail("FAILED:SelectResults size is different in both the cases. Size1="
          + sr.size() + " Size2 = " + externallySorted.length
          + "; failed query=" + query);
    }

    Collection coll1 = null;
    coll1 = sr.asList();
    int j = 0;
    if (wrapper.validationLevel != ValidationLevel.ORDER_BY_ONLY) {
      for (Object o : externallySorted) {
        boolean removed = coll1.remove(o);
        if (!removed) {
          LogWriter logger = CacheUtils.getLogger();
          logger.error("order by inconsistency at element index = " + j);
          logger.error(" query result =****");
          logger.error(" query result =" + coll1.toString());
          logger.error(" query result elementType=" + sr.getCollectionType().getElementType());
          logger.error(" externally sorted result =****");
          logger.error(ArrayUtils.toString(externallySorted));
         
          fail("failed query due to element mismatch=" + query);
        }
        ++j;
      }
      assertTrue(coll1.isEmpty());
    }

    if (wrapper.validationLevel != ValidationLevel.MATCH_ONLY) {
      coll1 = sr.asList();
      Iterator itert1 = coll1.iterator();
      int i = 0;
      for (Object o : externallySorted) {

        if (wrapper.obc.compare(o, itert1.next()) != 0) {
          LogWriter logger = CacheUtils.getLogger();
          logger.error("order by inconsistency at element index = " + i);
          logger.error(" query result =****");
          logger.error(" query result =" + coll1.toString());
          logger.error(" externally sorted result =****");
          logger.error(ArrayUtils.toString(externallySorted));
          fail("failed query due to order mismatch=" + query);
        }
        ++i;
      }
    }
  }

  public Wrapper getOrderByComparatorAndLimitForQuery(String orderByQuery,
      int unorderedResultSize) throws FunctionDomainException,
      TypeMismatchException, NameResolutionException,
      QueryInvocationTargetException, NoSuchFieldException, SecurityException,
      IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    DefaultQuery q = (DefaultQuery) CacheUtils.getQueryService().newQuery(
        orderByQuery);
    CompiledSelect cs = q.getSimpleSelect();    
    List<CompiledSortCriterion> orderByAttribs = null;
    if(cs.getType() == CompiledValue.GROUP_BY_SELECT) {
      Field originalOrderByMethod = CompiledGroupBySelect.class.getDeclaredField("originalOrderByClause");
      originalOrderByMethod.setAccessible(true);
      orderByAttribs = ( List<CompiledSortCriterion>)originalOrderByMethod.get(cs);
    }else {
      orderByAttribs = cs.getOrderByAttrs();
    }
    ObjectType resultType = cs.getElementTypeForOrderByQueries();
    ExecutionContext context = new ExecutionContext(null, CacheUtils.getCache());
    final OrderByComparator obc = new OrderByComparator(orderByAttribs,
        resultType, context);
    Comparator baseComparator = obc;
    if (resultType.isStructType()) {
      baseComparator = new Comparator<Struct>() {
        @Override
        public int compare(Struct o1, Struct o2) {
          return obc.compare(o1.getFieldValues(), o2.getFieldValues());

        }
      };
    }
    final Comparator secondLevelComparator = baseComparator;
    final Comparator finalComparator = new Comparator() {

      @Override
      public int compare(Object o1, Object o2) {
        final boolean[] orderByColsEqual = new boolean[] { false };
        QueryObserverHolder.setInstance(new QueryObserverAdapter() {
          @Override
          public void orderByColumnsEqual() {
            orderByColsEqual[0] = true;
          }
        });
        int result = secondLevelComparator.compare(o1, o2);
        if (result != 0 && orderByColsEqual[0]) {
          result = 0;
        }
        return result;
      }

    };

    Field hasUnmappedOrderByColsField = CompiledSelect.class
        .getDeclaredField("hasUnmappedOrderByCols");
    hasUnmappedOrderByColsField.setAccessible(true);
    boolean skip = ((Boolean) hasUnmappedOrderByColsField.get(cs))
        .booleanValue();
    ValidationLevel validationLevel = ValidationLevel.ALL;
    
    int limit ;
    
    if(cs.getType() == CompiledValue.GROUP_BY_SELECT) {
      Field limitCVField = CompiledGroupBySelect.class.getDeclaredField("limit");
      limitCVField.setAccessible(true);
      CompiledValue limitCV = ( CompiledValue)limitCVField.get(cs);
      Method evaluateLimitMethod = CompiledSelect.class.getDeclaredMethod("evaluateLimitValue",
          ExecutionContext.class, CompiledValue.class );
      evaluateLimitMethod.setAccessible(true);
      limit = ((Integer)evaluateLimitMethod.invoke(null, context, limitCV)).intValue();
    }else {
      limit = cs.getLimitValue(null);
    }
   
    if (limit != -1 && limit < unorderedResultSize) {
      // chances are that results will not match
      if (skip) {
        validationLevel = ValidationLevel.NONE;
      } else {
        validationLevel = ValidationLevel.ORDER_BY_ONLY;
      }
    } else {
      if (skip) {
        validationLevel = ValidationLevel.MATCH_ONLY;
      }
    }
    return new Wrapper(finalComparator, limit, validationLevel);

  }

  enum ValidationLevel {
    ALL, ORDER_BY_ONLY, MATCH_ONLY, NONE
  }

  private static class Wrapper {
    final Comparator obc;
    final int limit;
    final ValidationLevel validationLevel;

    Wrapper(Comparator obc, int limit, ValidationLevel validationLevel) {
      this.obc = obc;
      this.limit = limit;
      this.validationLevel = validationLevel;
    }
  }

  /** Creates a new instance of StructSetOrResultsSet */
  public void CompareCountStarQueryResultsWithoutAndWithIndexes(Object[][] r,
      int len, boolean checkOrder, String queries[]) {

    Integer count1, count2;
    Iterator<Integer> itert1, itert2;
    SelectResults result1, result2;
    boolean exactMatch = true;
    for (int j = 0; j < len; j++) {
      result1 = ((SelectResults) r[j][0]);
      result2 = ((SelectResults) r[j][1]);
      assertEquals(queries[j], 1, result1.size());
      assertEquals(queries[j], 1, result2.size());

      if ((result1.asList().get(0).getClass().getName()).equals(result2
          .asList().get(0).getClass().getName())) {
        CacheUtils.log("Both SelectResults are of the same Type i.e.--> "
            + ((SelectResults) r[j][0]).getCollectionType().getElementType());
      } else {
        fail("FAILED:Select result Type is different in both the cases."
            + "; failed query=" + queries[j]);
      }

      if (((SelectResults) r[j][0]).size() == ((SelectResults) r[j][1]).size()) {
        CacheUtils.log("Both SelectResults are of Same Size i.e.  Size= "
            + ((SelectResults) r[j][1]).size());
      } else {
        fail("FAILED:SelectResults size is different in both the cases. Size1="
            + ((SelectResults) r[j][0]).size() + " Size2 = "
            + ((SelectResults) r[j][1]).size() + "; failed query=" + queries[j]);
      }

      // boolean pass = true;
      itert1 = result1.iterator();
      itert2 = result2.iterator();
      while (itert1.hasNext()) {
        Integer p1 = itert1.next();
        Integer p2 = itert2.next();
        CacheUtils.log("result1: " + p1 + "result2: " + p2);
        exactMatch &= p1.intValue() == p2.intValue();

      }
      if (!exactMatch) {
        fail("Atleast one element in the pair of SelectResults supposedly identical, is not equal "
            + "; failed query=" + queries[j]);
      }
    }
  }

  /**
   * Compares two ArrayLists containing query results with/without order.
   *
   * @param r
   *          Array of ArrayLists
   * @param len
   *          Length of array of ArrayLists
   * @param checkOrder
   * @param queries
   */
  public void CompareQueryResultsAsListWithoutAndWithIndexes(Object[][] r,
      int len, boolean checkOrder, String queries[]) {
    CompareQueryResultsAsListWithoutAndWithIndexes(r, len, checkOrder, true,
        queries);
  }

  public void CompareQueryResultsAsListWithoutAndWithIndexes(Object[][] r,
      int len, boolean checkOrder, boolean checkClass, String queries[]) {
    Integer count1, count2;
    Iterator<Integer> itert1, itert2;
    ArrayList result1, result2;
    for (int j = 0; j < len; j++) {
      result1 = ((ArrayList) r[j][0]);
      result2 = ((ArrayList) r[j][1]);
      result1.trimToSize();
      result2.trimToSize();
      // assertFalse(queries[j], result1.size()==0);
      // assertFalse(queries[j], result2.size()==0);

      if (checkClass) {
        if ((result1.get(0).getClass().getName()).equals(result2.get(0)
            .getClass().getName())) {
          CacheUtils.log("Both SelectResults are of the same Type i.e.--> "
              + result1.get(0).getClass().getName());
        } else {
          fail("FAILED:Select result Type is different in both the cases."
              + result1.get(0).getClass().getName() + "and"
              + result1.get(0).getClass().getName() + "; failed query="
              + queries[j]);
        }
      }

      if (result1.size() == result2.size()) {
        CacheUtils.log("Both SelectResults are of Same Size i.e.  Size= "
            + result2.size());
      } else {
        fail("FAILED:SelectResults size is different in both the cases. Size1="
            + result1.size() + " Size2 = " + result2.size() + "; failed query="
            + queries[j]);
      }

      // boolean pass = true;
      itert1 = result1.iterator();
      itert2 = result2.iterator();
      while (itert1.hasNext()) {
        Object p1 = itert1.next();
        if (!checkOrder) {
          itert2 = result2.iterator();
        }

        boolean exactMatch = false;
        while (itert2.hasNext()) {
          Object p2 = itert2.next();
          if (p1 instanceof Struct) {
            Object[] values1 = ((Struct) p1).getFieldValues();
            Object[] values2 = ((Struct) p2).getFieldValues();
            assertEquals(values1.length, values2.length);
            boolean elementEqual = true;
            for (int i = 0; i < values1.length; ++i) {
              elementEqual = elementEqual
                  && ((values1[i] == values2[i]) || values1[i]
                      .equals(values2[i]));
            }
            exactMatch = elementEqual;
          } else {
            exactMatch = (p2 == p1) || p2.equals(p1);
          }
          if (exactMatch || checkOrder) {
            break;
          }
        }
        if (!exactMatch) {
          fail("Atleast one element in the pair of SelectResults supposedly identical, is not equal "
              + "; failed query=" + queries[j]);
        }
      }
    }
  }
}