/*
    * Copyright 2011 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.osedu.org/licenses/ECL-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.kuali.student.r2.common.datadictionary.util;
  
  import org.kuali.rice.core.api.data.DataType;
  import org.kuali.student.r2.common.datadictionary.infc.AttributeDefinitionInfc;
  import org.kuali.student.r2.common.datadictionary.infc.DictionaryEntry;
  import org.kuali.student.r2.common.exceptions.InvalidParameterException;
  import org.kuali.student.r2.common.exceptions.OperationFailedException;
  import org.kuali.student.r2.common.infc.Comparison;
  import org.kuali.student.r2.common.infc.Criteria;
  import org.kuali.student.r2.common.util.date.DateFormatters;
  
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
   /**
   * A class that validates the criteria against the dictionary
   *
   * It also sets the parsedValues and parsedOperators so they may be used in the implementation
   * The call sequence is sometehing like this:
   * <ol>
   * <li>construct this validator
   * <li>Configure this validator with criteria to be valiated
   * <li>Get the dictionary entry of the object to be validated by calling DataDictionaryServiceInfc.getDataDictionaryEntry (the ref object's URI)
   * <li>Configure this validator with the dictionary entry that you just got from the dictionary
   * <li>Call the validate () method which will throw exceptions if problems
   * <li>get the parsed values (@see getParsedValues ()) and use them in the implementation
   * <li>Get the parsed operators and use in the implementation, if you want
   * </ol>
   * @author nwright
   */
  public class CriteriaValidatorParser {
  
      public enum Operator {
  
          EQ, IN, GT, LT, NEQ, GTE, LTE, LIKE, BETWEEN;
      }
      private Criteria criteria;
      private DictionaryEntry dictionaryEntry;
      private transient List<Object> parsedValues;
      private transient List<Operator> parsedOperators;
  
      public CriteriaValidatorParser() {
      }
  
      public Criteria getCriteria() {
          return criteria;
      }
  
      public void setCriteria(Criteria criteria) {
          this.criteria = criteria;
      }
  
      public DictionaryEntry getDictionaryEntry() {
          return dictionaryEntry;
      }
  
      public void setDictionaryEntry(DictionaryEntry dictionaryEntry) {
          this.dictionaryEntry = dictionaryEntry;
      }
  
      /**
       * Get the string operators translated as an Operator enum
       * @return list of operators in the same ordinal position as the supplied operators in the list of ComparisonInfc objects
       */
      public List<Operator> getParsedOperators() {
          return parsedOperators;
      }
  
      /**
       * The values parsed as their respective data types, String, Date, Integer, etc.
       *
       * Special considerations:
       * IN operators return a List of one or more parsed values who's order is the samne as the order in the ComparisonInfc
       * BETWEEN operators return a list of two parsed values who's values coorespond to the from to values of a between operation.
       *
       * @return a list of parsed values in the same ordinal positions as the unparsed values in the list of ComparisonInfc objects
       */
      public List<Object> getParsedValues() {
          return parsedValues;
      }
  
  
 
     /**
      * Validate the criteria thowing an InvalidParameterException if there are problems
      *
      * TODO: Consider getting all the errors and throw them as a group instead of as we find them
      *
      * @throws InvalidParameterException
      * @throws OperationFailedException
      */
     public void validate()
             throws InvalidParameterException,
             OperationFailedException {
         parsedValues = new ArrayList<Object>();
         parsedOperators = new ArrayList <Operator> ();
         if (this.criteria.getComparisons() == null) {
             throw new InvalidParameterException ("Comparisons list is null -- to select all specify an empty list");
         }
         int i = 0;
         for (Comparison comparison : this.criteria.getComparisons()) {
             this.validate(i, comparison);
             i++;
         }
     }
 
     private void validate(int i, Comparison comparison)
             throws InvalidParameterException,
             OperationFailedException {
         String fieldKey = comparison.getFieldKey();
         String operator = comparison.getOperator();
         List<String> values = comparison.getValues();
         AttributeDefinitionInfc ad = this.getAttributeDefinition(fieldKey);
         if (ad == null) {
             throw new InvalidParameterException("The " + i + "th comparison's field key " + fieldKey + " is not defined in the dictionary");
         }
         if (operator == null) {
             throw new InvalidParameterException("The " + i + "th comparison's operator is null");
         }
         if (operator.equals("=")) {
             this.parsedOperators.add(Operator.EQ);
         } else if (operator.equals("<")) {
             this.parsedOperators.add(Operator.LT);
         } else if (operator.equals(">")) {
             this.parsedOperators.add(Operator.GT);
         } else if (operator.equals("!=")) {
             this.parsedOperators.add(Operator.NEQ);
         } else if (operator.equals("<=")) {
             this.parsedOperators.add(Operator.LTE);
         } else if (operator.equals(">=")) {
             this.parsedOperators.add(Operator.GTE);
         } else if (operator.equals("in")) {
             this.parsedOperators.add(Operator.IN);
         } else if (operator.equals("between")) {
             this.parsedOperators.add(Operator.BETWEEN);
         } else if (operator.equals("like")) {
             this.parsedOperators.add(Operator.LIKE);
             if (ad.getDataType().equals (DataType.STRING)) {
             throw new InvalidParameterException("The " + i + "th comparison's operator is LIKE which can only be applied to strings, " + ad.getDataType() + " is invalid.");
             }
         } else {
             throw new InvalidParameterException("The " + i + "th comparison's operator, " + operator + ", is invalid.");
         }
         if (values == null) {
             throw new InvalidParameterException("The " + i + "th comparison's values list is required and cannot be null");
         }
         if (values.isEmpty()) {
             throw new InvalidParameterException("The " + i + "th comparison's values list is required and cannot be an empty list");
         }
         if (values.get(0) == null) {
             if (!operator.equals("=") && !operator.equals("!=")) {
                 throw new InvalidParameterException("The " + i + "th comparison's value is null but the operator " + operator + " is a comparison operator that does not apply");
             }
             return;
         }
         if (operator.equals("between")) {
             if (values.size() != 2) {
                 throw new InvalidParameterException("The " + i + "th comparison is a between operator which requires two values, found " + values.size());
             }
             if (values.get(0) == null) {
                 throw new InvalidParameterException("The " + i + "th comparison is a between operator but the first value is null");
             }
             if (values.get(1) == null) {
                 throw new InvalidParameterException("The " + i + "th comparison is a between operator but the second value is null");
             }
         } else if (values.size() > 1) {
             if (!operator.equals("in")) {
                 throw new InvalidParameterException("The " + i + "th comparison's value is a list but the operator " + operator + " is a comparison operator that does not apply");
             }
         }
         switch (ad.getDataType()) {
             case STRING:
                 break;
             case DATE:
             case TRUNCATED_DATE:
                 break;
             case BOOLEAN:
                 if (! operator.equals("=") && !operator.equals("!=")) {
                     throw new InvalidParameterException("The " + i + "th comparison's operator " + operator + " is a comparison operator that does not apply to the field's boolean data type");
                 }
             case INTEGER:
             case FLOAT:
             case DOUBLE:
             case LONG:
                 break;
 //            case COMPLEX:
 //                if (! operator.equals("=") && !operator.equals("!=")) {
 //                    throw new InvalidParameterException("The " + i + "th comparison's operator " + operator + " is a comparison operator that does not apply to the field's complex data type");
 //                }
 //                if (values.get(0) == null) {
 //                    throw new InvalidParameterException("The " + i + "th comparison's value is not null but attribute type is complex. Complex can only be checked to see if it is null or not null");
 //                }
         }
         parsedValues.add(parseValues(i, ad.getDataType(), comparison.getValues(), comparison.getIsIgnoreCase()));
     }
 
     private Object parseValues(int i, DataType dataType, List<String> values, boolean ignoreCase)
             throws InvalidParameterException {
         if (values.size() == 1) {
             return parseValue(i, dataType, values.get(0), ignoreCase);
         }
         List<Object> list = new ArrayList<Object>();
         for (String value : values) {
             list.add(parseValue(i, dataType, value, ignoreCase));
         }
         return list;
     }
 
     private Object parseValue(int i, DataType dataType, String value, boolean ignoreCase)
             throws InvalidParameterException {
         if (value == null) {
             return null;
         }
         switch (dataType) {
             case STRING:
                 return parseString(i, value, ignoreCase);
             case DATE:
                 return parseDateTime(i, value);
             case TRUNCATED_DATE:
                 return parseDate(i, value);
             case BOOLEAN:
                 return parseBoolean(i, value);
             case INTEGER:
                 return parseInteger(i, value);
             case FLOAT:
                 return parseFloat(i, value);
             case DOUBLE:
                 return parseDouble(i, value);
             case LONG:
                 return parseLong(i, value);
 //            case COMPLEX:
 //                throw new InvalidParameterException("The " + i + "th comparison's value is not null but attribute type is complex. Complex can only be checked to see if it is null or not null");
             default:
                 throw new IllegalArgumentException("Unknown/unhandled datatype " + dataType);
         }
     }
 
     private String parseString(int i, String cv, boolean ignoreCase) throws InvalidParameterException {
         if (cv == null) {
             return null;
         }
         if (ignoreCase) {
             return cv.toLowerCase();
         }
         return cv;
     }
 
     private Timestamp parseDateTime(int i, String cv) throws InvalidParameterException {
         try {
             return new Timestamp(DateFormatters.DEFAULT_TIMESTAMP_FORMATTER.parse(cv).getTime());
         } catch (IllegalArgumentException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a dateTime");
         }
     }
 
     private Date parseDate(int i, String cv) throws InvalidParameterException {
         try {
             return DateFormatters.DEFAULT_DATE_FORMATTER.parse(cv);
         } catch (IllegalArgumentException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a date");
         }
     }
 
     private Integer parseInteger(int i, String cv) throws InvalidParameterException {
         try {
             return Integer.parseInt(cv);
         } catch (NumberFormatException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an integer");
         }
     }
 
     private Long parseLong(int i, String cv) throws InvalidParameterException {
         try {
             return Long.parseLong(cv);
         } catch (NumberFormatException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a Long");
         }
     }
 
     private Boolean parseBoolean(int i, String cv) throws InvalidParameterException {
         if (cv.equalsIgnoreCase("true")) {
             return Boolean.TRUE;
         }
         if (cv.equalsIgnoreCase("false")) {
             return Boolean.FALSE;
         }
         throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as a Boolean");
 
     }
 
     private Float parseFloat(int i, String cv) throws InvalidParameterException {
         try {
             return Float.parseFloat(cv);
         } catch (NumberFormatException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an float");
         }
     }
 
     private Double parseDouble(int i, String cv) throws InvalidParameterException {
         try {
             return Double.parseDouble(cv);
         } catch (NumberFormatException ex) {
             throw new InvalidParameterException("The " + i + "th comparison's value " + cv + " cannot be parsed as an double");
         }
     }
 
     private String initLower(String str) {
         if (str == null) {
             return null;
         }
         if (str.length() == 0) {
             return str;
         }
         if (str.length() == 1) {
             return str.toLowerCase();
         }
         return str.substring(0, 1).toLowerCase() + str.substring(1);
     }
 
     private boolean calcIsList(AttributeDefinitionInfc ad) {
         if (ad.getMaxOccurs() == null) {
             return false;
         }
         if (ad.getMaxOccurs() <= 1) {
             return false;
         }
         return true;
 
     }
 
     private AttributeDefinitionInfc getAttributeDefinition(String fk)
             throws InvalidParameterException,
             OperationFailedException {
         for (AttributeDefinitionInfc ad : this.dictionaryEntry.getAttributes()) {
             if (ad.getName().equals(fk)) {
                 return ad;
             }
         }
        return null;
     }
 
 }