package org.kuali.student.common.dictionary.service.impl;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Set;

 import java.util.regex.Pattern;

 import java.util.regex.PatternSyntaxException;

 import org.kuali.student.common.dictionary.dto.CaseConstraint;

 import org.kuali.student.common.dictionary.dto.DataType;

 import org.kuali.student.common.dictionary.dto.FieldDefinition;

 import org.kuali.student.common.dictionary.dto.LookupConstraint;

 import org.kuali.student.common.dictionary.dto.ObjectStructureDefinition;

 import org.kuali.student.common.dictionary.dto.ValidCharsConstraint;

 import org.kuali.student.common.dictionary.dto.WhenConstraint;

 import org.kuali.student.common.validator.ServerDateParser;

 import org.kuali.student.common.validator.ValidatorUtils;

 public class DictionaryValidator

 {

  private ObjectStructureDefinition os;

  private boolean processSubStructures = false;

  private Set<ObjectStructureDefinition> alreadyValidated;

  public DictionaryValidator (ObjectStructureDefinition os,

                              Set<ObjectStructureDefinition> alreadyValidated,

                              boolean processSubstructures)

  {

   this.os = os;

   this.alreadyValidated = alreadyValidated;

   this.processSubStructures = processSubstructures;

  }

  public List<String> validate ()

  {

   List<String> errors = new ArrayList ();

   if (os.getName () == null)

   {

    errors.add ("The name cannbe be left null");

   }

   if (os.getBusinessObjectClass () != null)

   {

    errors.add (

      "The business object class is not used and should not be filled in");

   }

 //  else if (this.getClass (os.getName ()) == null)

 //  {

 //   errors.add ("The name does not exist on the class path");

 //  }

   if (os.getAttributes () == null)

   {

    errors.add ("getAttribues () is null -- null for field defintion");

    return errors;

   }

   if (os.getAttributes ().size () == 0)

   {

    errors.add ("No fields defined for complex object structure");

    return errors;

   }

   Set<String> fieldNames = new HashSet ();

   for (FieldDefinition fd : os.getAttributes ())

   {

    if (fd.getName () != null)

    {

     if ( ! fieldNames.add (fd.getName ()))

     {

      errors.add (fd.getName () + " is defined more than once");

     }

    }

    errors.addAll (validateField (fd));

   }

   return errors;

  }

 // private Class getClass (String className)

 // {

 //  try

 //  {

 //   return Class.forName (className);

 //  }

 //  catch (ClassNotFoundException ex)

 //  {

 //   return null;

 //  }

 // }

  private List<String> validateField (FieldDefinition fd)

  {

   List<String> errors = new ArrayList ();

   if (fd.getName () == null)

   {

    errors.add ("name cannot be null");

   }

   else if (fd.getName ().trim ().equals (""))

   {

    errors.add ("name cannot be blank");

   }

   if (fd.getDataType ().equals (DataType.COMPLEX))

   {

    errorIfNotNull (errors, fd, "exclusiveMin", fd.getExclusiveMin ());

    errorIfNotNull (errors, fd, "inclusiveMax", fd.getInclusiveMax ());

    errorIfNotNull (errors, fd, "max length", fd.getMaxLength ());

    errorIfNotNull (errors, fd, "min length", fd.getMinLength ());

    errorIfNotNull (errors, fd, "valid chars", fd.getValidChars ());

    errorIfNotNull (errors, fd, "lookup", fd.getLookupDefinition ());

    if (fd.getDataObjectStructure () == null)

    {

     errors.add (

       "field " + fd.getName ()

       + " does not have an object structure definition but it required on a complex type");

    }

    else

    {

     if (this.processSubStructures)

     {

      if (alreadyValidated.add (fd.getDataObjectStructure ()))

      {

       errors.addAll (new DictionaryValidator (fd.getDataObjectStructure (),

                                               alreadyValidated,

                                               processSubStructures).validate ());

      }

     }

    }

   }

   validateConversion (errors, fd.getName (), "defaultValue", fd.getDataType (), fd.getDefaultValue ());

   validateConversion (errors, fd.getName (), "exclusiveMin", fd.getDataType (), fd.getExclusiveMin ());

   validateConversion (errors, fd.getName (), "inclusiveMax", fd.getDataType (), fd.getInclusiveMax ());

   //TODO: Cross compare to make sure min is not greater than max and that default value is valid itself

   if (fd.getMaxLength () != null)

   {

    try

    {

     Integer.parseInt (fd.getMaxLength ());

    }

    catch (NumberFormatException ex)

    {

     errors.add (

       "field " + fd.getName ()

       + " has a maxlength that is not an integer");

    }

   }

   if (fd.getLookupDefinition () != null)

   {

    errors.addAll (validateLookup (fd, fd.getLookupDefinition ()));

   }

   if (fd.getCaseConstraint () != null)

   {

    errors.addAll (validateCase (fd, fd.getCaseConstraint ()));

   }

   if (fd.getValidChars () != null)

   {

    errors.addAll (validateValidChars (fd, fd.getValidChars ()));

   }

   return errors;

  }

  private void errorIfNotNull (List<String> errors, FieldDefinition fd,

                               String validation,

                               Object value)

  {

   if (value != null)

   {

    errors.add ("field " + fd.getName () + " has a " + validation

                + " but it cannot be specified on a complex type");

   }

  }

  private Object validateConversion (List<String> errors, String fieldName,

                                     String propertyName, DataType dataType,

                                     Object value)

  {

   if (value == null)

   {

    return null;

   }

   switch (dataType)

   {

    case STRING:

     return value.toString ().trim ();

 //    case DATE, TRUNCATED_DATE, BOOLEAN, INTEGER, FLOAT, DOUBLE, LONG, COMPLEX

    case LONG:

     try

     {

      return ValidatorUtils.getLong (value);

     }

     catch (NumberFormatException ex)

     {

      errors.add (

        "field " + fieldName

        + " has a " + propertyName

        + " that cannot be converted into a long integer");

     }

     return null;

    case INTEGER:

     try

     {

      return ValidatorUtils.getInteger (value);

     }

     catch (NumberFormatException ex)

     {

      errors.add (

        "field " + fieldName

        + " has a " + propertyName + " that cannot be converted into an integer");

     }

     return null;

    case FLOAT:

     try

     {

      return ValidatorUtils.getFloat (value);

     }

     catch (NumberFormatException ex)

     {

      errors.add (

        "field " + fieldName

        + " has a " + propertyName

        + " that cannot be converted into a floating point value");

     }

     return null;

    case DOUBLE:

     try

     {

      return ValidatorUtils.getFloat (value);

     }

     catch (NumberFormatException ex)

     {

      errors.add (

        "field " + fieldName

        + " has a " + propertyName

        + " that cannot be converted into a double sized floating point value");

     }

     return null;

    case BOOLEAN:

     if (value instanceof Boolean)

     {

      return ((Boolean) value).booleanValue ();

     }

     if (value instanceof String)

     {

      if (((String) value).trim ().equalsIgnoreCase ("true"))

      {

       return true;

      }

      if (((String) value).trim ().equalsIgnoreCase ("false"))

      {

       return true;

      }

     }

     errors.add (

       "field " + fieldName

       + " has a " + propertyName

       + " that cannot be converted into a boolean true/false");

     return null;

    case DATE:

    case TRUNCATED_DATE:

     if (value instanceof Date)

     {

      return (Date) value;

     }

     try

     {

      // TODO: make the date parser configurable like the validator is

      return new ServerDateParser ().parseDate (value.toString ());

     }

     catch (Exception e)

     {

      errors.add (

        "field " + fieldName

        + " has a " + propertyName

        + " that cannot be converted into a date");

     }

     return null;

    default:

      errors.add (

        "field " + fieldName

        + " has a " + propertyName

        + " that cannot be converted into an unknown/unhandled data type");

     return null;

   }

  }

  private List<String> validateValidChars (FieldDefinition fd,

                                           ValidCharsConstraint vc)

  {

   List<String> errors = new ArrayList ();

   String validChars = vc.getValue ();

   int typIdx = validChars.indexOf (":");

   String processorType = "regex";

   if (-1 == typIdx)

   {

    validChars = "[" + validChars + "]*";

   }

   else

   {

    processorType = validChars.substring (0, typIdx);

    validChars = validChars.substring (typIdx + 1);

   }

   if ( ! processorType.equalsIgnoreCase ("regex"))

   {

    errors.add (

      "field " + fd.getName ()

      + " has an invalid valid chars processor type: a simple list of characters or a regex: is supported");

    return errors;

   }

   try

   {

    Pattern pattern = Pattern.compile (validChars);

   }

   catch (PatternSyntaxException ex)

   {

    errors.add ("field " + fd.getName ()

                + " has in invalid character pattern for a regular expression: "

                + validChars);

   }

   return errors;

  }

  private List<String> validateLookup (FieldDefinition fd, LookupConstraint lc)

  {

   List<String> errors = new ArrayList ();

   if (lc.getParams () == null)

   {

    errors.add ("field " + fd.getName () + " has a lookup with null parameters");

   }

   //TODO: more validation

   return errors;

  }

  public static final String GREATER_THAN_EQUAL = "greater_than_equal";

  public static final String LESS_THAN_EQUAL = "less_than_equal";

  public static final String GREATER_THAN = "greater_than";

  public static final String LESS_THAN = "less_than";

  public static final String EQUALS = "equals";

  public static final String NOT_EQUAL = "not_equal";

  private static final String[] VALID_OPERATORS =

  {

   NOT_EQUAL, EQUALS, GREATER_THAN_EQUAL, LESS_THAN_EQUAL, GREATER_THAN, LESS_THAN

  };

  private List<String> validateCase (FieldDefinition fd, CaseConstraint cc)

  {

   List<String> errors = new ArrayList ();

   if (cc.getOperator () == null)

   {

    errors.add ("field " + fd.getName ()

                + " has a case constraint with no operator");

   }

   else

   {

    boolean found = false;

    for (int i = 0; i < VALID_OPERATORS.length; i ++)

    {

     if (VALID_OPERATORS[i].equalsIgnoreCase (cc.getOperator ()))

     {

      found = true;

      break;

     }

    }

    if ( ! found)

    {

     errors.add ("field " + fd.getName ()

                 + " has a case constraint with an unknown operator "

                 + cc.getOperator ());

    }

   }

   if (cc.getFieldPath () == null)

   {

    errors.add (

      "field " + fd.getName ()

      + " has a case constraint with a null for the field to use for the comparison");

   }

   else if (cc.getFieldPath ().trim ().equals (""))

   {

    errors.add (

      "field " + fd.getName ()

      + " has a case constraint with blanks for the field to use for the comparison");

   }

   if (cc.getWhenConstraint () == null)

   {

    errors.add ("field " + fd.getName ()

                + " has a case constraint but null when statements");

    return errors;

   }

   if (cc.getWhenConstraint ().size () == 0)

   {

    errors.add ("field " + fd.getName ()

                + " has a case constraint but has no when statements");

   }

   for (WhenConstraint wc : cc.getWhenConstraint ())

   {

    if (wc.getConstraint () == null)

    {

     errors.add (

       "field " + fd.getName ()

       + " has a as case constraint with a when statement that has no overriding constraints specified");

    }

   }

   //TODO: more validation

   return errors;

  }

 }