package com.randomnoun.common;
   
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Comparator;
   import java.util.HashMap;
   import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Set;
  import java.util.Spliterator;
  import java.util.function.Consumer;
  import java.util.function.Predicate;
  import java.util.function.UnaryOperator;
  import java.util.stream.Stream;
  
  /**
   * The ErrorList class is a a fairly generic class for containing validation errors for
   * input forms, similar to the struts ActionErrors class. 
   * 
   * <p>Each error within this class can contain a 'short' and 'long' description, 
   * where the short description is normally two-word categorisation of the error 
   * and the longer description describes what has happened and how to fix the problem; 
   * (e.g. shortText="Missing field", longText="The field 'id' is mandatory. Please enter a value for this field."). 
   * 
   * <p>In the UI, the short description is normally rendered in bold before the long
   * description. 
   * 
   * <p>An individual error also may contain a severity, 
   * and list of fields that it applies to (defined by a comma-separate string of field names)
   * An error without a severity supplied is assumed to be {@link #SEVERITY_INVALID}, 
   * and an error without any fields supplied is assumed to be associated with the entire form, 
   * rather than a specific set of fields.
   * 
   * <p>Errors are inserted into an ErrorList by using one of the addError methods:
   * <ul>
   * <li> {@link #addError(String, String)} - add an invalid form error
   * <li> {@link #addError(String, String, int)} - add an form error with a specific severity
   * <li> {@link #addError(String, String, String)} - add an invalid field error  
   * <li> {@link #addError(String, String, String, int)} - add an invalid field error with a specific severity 
   * </ul>
   * 
   * @author knoxg
   */
  public class ErrorList implements List<ErrorList.ErrorData>, Serializable {
  
  	/** Generated serialVersionUID */
  	private static final long serialVersionUID = 4246736116021572339L;
  	
  	// uses an ArrayList by default, but by calling makeThreadsafe(), will wrap the backing array 
  	// in a Collections.synchronizedList()
  	List<ErrorList.ErrorData> delegate;
  	boolean threadsafe = false;
  	
  	/** Severity level indicating 'not an error' (e.g. informational only). Used to indicate successful operations */
      public static final int SEVERITY_OK = 0; // Not an error
  
      /** invalid user-supplied data; end-user can fix situation */
      public static final int SEVERITY_INVALID = 1;
  
      /** invalid system-supplied data; end-user cannot fix situation */
      public static final int SEVERITY_ERROR = 2;
  
      /** internal error (e.g. EJB/LDAP connection failure) */
      public static final int SEVERITY_FATAL = 3;
  
      /** unrecoverable internal error (can't think of anything here, but the world ending could be one */
      public static final int SEVERITY_PANIC = 4;
  
      // these were created after the 5 above, which is why they have higher ID numbers
      // at a later stage will renumber these so that
      // OK < INFO < WARNING < INVALID < ERROR < FATAL < PANIC
      
      /** information message; can be used in addition to SEVERITY_OK for additional text */
      public static final int SEVERITY_INFO = 5;
  
      /** possibly incorrect user-supplied data; operation still succeeds but may return incorrect results */
      public static final int SEVERITY_WARNING = 6;
  
      
      /** ErrorInfo inner class - contains information related to
       *  a single error
       */
      public static class ErrorData extends HashMap<String, Object>
      {
          /** Generated serialVersionUID */
  		private static final long serialVersionUID = -176737615399095851L;
  
  		/**
           * Creates a new ErrorInfo object.
           *
           * @param shortText a short, descriptive string for this error
           * @param longText  a more lengthy description of this error
           * @param errorField    comma-separated list of field names that caused
           *                    this error
           * @param severity    the severity of this error
          */
         public ErrorData(String shortText, String longText, String errorField,
             int severity)
         {
             super();
             put("shortText", shortText);
             put("longText", longText);
             put("field", errorField);
             put("severity", Integer.valueOf(severity));
         }
 
         @Override
 		public int hashCode() {
 			return super.hashCode();
 		}
 
 		@Override
 		public boolean equals(Object obj) {
 			return super.equals(obj);
 		}
 
 		/** Retrieves the type for this error
          *  @return   the type for this error
          */
         public String getShortText()
         {
             return (String) get("shortText");
         }
 
         /** Retrieves the description for this error
          *  @return   the description for this error
          */
         public String getLongText()
         {
             return (String) get("longText");
         }
 
         /** Retrieves a comma-separated list of fields that caused this error
          *  @return   a comma-separated list of fields that caused this error
          */
         public String getField()
         {
             return (String) get("field");
         }
 
         /** Retrieves the severity of this error
          *  @return   the severity of this error
          */
         public int getSeverity()
         {
             return ((Integer) get("severity")).intValue();
         }
 
         /** Retrieves a string representation of this error
          *  @return   a string representation of this error
          */
         public String toString()
         {
             return "{shortText='" + getShortText() + "', longText='" + getLongText() +
               "', fields='" + getField() + "', severity=" + getSeverity() + "}";
         }
     }
 
     /**
      * Create a new, empty ErrorData object.
      */
     public ErrorList()
     {
         delegate = new ArrayList<>();
     }
     
     
     /** Convert the backing store for this ErrorList to a Collections.synchronizedList, suitable for use in multithreaded applications.
      * Note that iterations on this collection must still be synchronised.
      */
     public synchronized void makeThreadsafe() {
     	if (!threadsafe) {
     		delegate = Collections.synchronizedList(delegate);
     		threadsafe = true;
     	}
     }
     
     /** Removes any duplicate errors in this ErrorList */
     public void removeDuplicates() {
         Set<ErrorList.ErrorData> uniqueData = new HashSet<>();
         synchronized(delegate) {
 	        for (Iterator<ErrorList.ErrorData> i = this.iterator(); i.hasNext(); ) {
 	        	ErrorList.ErrorData ed = i.next();
 	            if (uniqueData.contains(ed)) {
 	            	i.remove();
 	            } else {
 	                uniqueData.add(ed);
 	            }
 	        }
         }
     }
 
     /**
      * Adds an error. This is the "real" addError() method; all others delegate to this
      * one.
      *
      * @param errorField  a comma-separated list of field names that caused this error
      * @param shortText a short string conveying the error type (e.g. 'Missing field')
      * @param longText  a longer string describing the nature of the error and how to resolve it
      *   (e.g. 'The field 'id' is mandatory. Please enter a value for this field.')
      * @param severity    the severity of this error (one of the SEVERITY_* constants of this class).
      *
      * @see SEVERITY_INVALID
      */
     public void addError(String errorField, String shortText, String longText,
         int severity)
     {
         delegate.add(new ErrorData(shortText, longText, errorField, severity));
     }
 
     /**
      * As per {@link #addError(String, String, String, int)}, with a default
      * severity of {@link #SEVERITY_ERROR}.
      *
      * @param errorField  a comma-separated list of field names that caused this error
      * @param shortText a short string conveying the error type (e.g. 'Missing field')
      * @param longText  a longer string describing the nature of the error and how to resolve it
      *   (e.g. 'The field 'id' is mandatory. Please enter a value for this field.')
      */
     public void addError(String errorField, String shortText, String longText)
     {
         addError(errorField, shortText, longText, SEVERITY_ERROR);
     }
 
     /**
      * Adds an error that isn't associated with any particular field
      *
      * @param shortText a short string conveying the error type (e.g. 'Missing field')
      * @param longText  a longer string describing the nature of the error and how to resolve it
      *   (e.g. 'The field 'id' is mandatory. Please enter a value for this field.')
      * @param severity  the severity of this error (one of the SEVERITY_* constants of this class)
      *
      */
     public void addError(String shortText, String longText, int severity)
     {
         addError("", shortText, longText, severity);
     }
 
     /**
      * Adds an error that isn't associated with any particular field, with a default
      * severity of {@link #SEVERITY_ERROR}.
      *
      * @param shortText a short string conveying the error type (e.g. 'Missing field')
      * @param longText  a longer string describing the nature of the error and how to resolve it
      *   (e.g. 'The field 'id' is mandatory. Please enter a value for this field.')
      */
     public void addError(String shortText, String longText)
     {
         addError("", shortText, longText, SEVERITY_ERROR);
     }
 
     /**
      * Resets all errors contained within this object
      */
     public void clearErrors()
     {
         delegate.clear();
     }
 
     /**
      * Appends the errors contained within another ErrorData into this one.
      *
      * @param errorList
      *
      * @return <b>true</b> if there were any additional errors to embed and at least
      *   one of the errors had a severity of SEVERITY_ERROR or higher (worse),
      *   <b>false</b> otherwise.
      */
     public boolean addErrors(ErrorList errorList)
     {
         if (errorList == null) {
             return false;
         }
         if (errorList.size() == 0) {
             return false;
         }
         int maxSeverity = Integer.MIN_VALUE;
         int severity;
 
         for (int i = 0; i < errorList.size(); i++) {
             severity = errorList.getSeverityAt(i);
             add(errorList.get(i));
             if (severity > maxSeverity) {
                 maxSeverity = severity;
             }
         }
 
         if (maxSeverity >= SEVERITY_ERROR) {
             return true;
         } else {
             return false;
         }
     }
 
     /**
      * Returns true if an error has occured on the field
      * passed as a parameter to this method
      *
      * @return true if an error occured, false if not.
      */
     public boolean hasErrorOn(String field)
     {
         ErrorData errorInfo;
 
         synchronized(delegate) {
 	        for (Iterator<ErrorData> i = delegate.iterator(); i.hasNext(); ) {
 	            errorInfo = i.next();
 	            if (errorInfo.getField()!=null) {
 		            String[] errorFields = errorInfo.getField().split(",");
 		            for (int j = 0; j < errorFields.length; j++) {
 		                if (errorFields[j].equals(field)) {
 		                    return true;
 		                }
 		            }
 	            }
 	        }
         }
         return false;
     }
 
     /**
      * Returns true if there are any errors in this object
      *
      * @return True if the number of errors &gt; 0
      */
     public boolean hasErrors()
     {
         return size() > 0;
     }
 
     /**
      * Returns true if there are any errors of the specified severity or higher
      * Note that our severities aren't in increasing severity order any more so this method is now deprecated
      *
      * @param severity a SEVERITY_* constant
      *
      * @return True if the number of errors at the specified severity or higher &gt; 0
      * @deprecated
      */
     public boolean hasErrors(int severity)
     {
     	synchronized(delegate) {
 	        for (Iterator<ErrorData> i = this.iterator(); i.hasNext(); ){
 	            ErrorData errorData = (ErrorData) i.next();
 	            if (errorData.getSeverity() >= severity ) { 
 	                return true;
 	            }
 	        }
     	}
         return false;
     }
 
 
     /**
      * Returns the maximum severity of all current errors.
      * Note that our severities aren't in increasing severity order any more so this method is now deprecated
      *
      * @return the severity ranking of the most severe error, or -1 if
      *   there are no errors contained within this ErrorData object.
      * @deprecated  
      */
     public int maxErrorSeverity()
     {
         int maxSeverity = -1;
         int curSeverity;
 
         synchronized(delegate) {
 	        for (int i = 0; i < size(); i++) {
 	            curSeverity = getSeverityAt(i);
 	            if (curSeverity > maxSeverity) {
 	                maxSeverity = curSeverity;
 	            }
 	        }
         }
         return maxSeverity;
     }
 
     /**
      * Returns the number of errors in this object
      *
      * @return The number of errors in this object
      */
     public int size() {
         return delegate.size();
     }
 
     /**
      * Same as {@link #size()}. Only here to allow us to access the object in JSTL
      *
      * @return The number of errors in this object
      */
     public int getSize() {
         return size();
     }
 
     /**
      * Returns the shortText string of the pos'th error
      */
     public String getShortTextAt(int pos) {
         return ((ErrorData) delegate.get(pos)).getShortText();
     }
 
     /**
      * Returns the longText of the pos'th error
      */
     public String getLongTextAt(int pos) {
         return ((ErrorData) delegate.get(pos)).getLongText();
     }
 
     /**
      * Returns the field of the pos'th error
      */
     public String getFieldAt(int pos) {
         return ((ErrorData) delegate.get(pos)).getField();
     }
 
     /**
      * Returns the severity of the pos'th error
      */
     public int getSeverityAt(int pos) {
         return ((ErrorData) delegate.get(pos)).getSeverity();
     }
 
     /**
      * Return all the errors within this object in a single string.
      * Suitable for inclusion within email alarms, logs etc...
      *
      * @return Newline-separated list of errors
      */
     public String toString() {
         StringBuffer sb = new StringBuffer();
         ErrorData errorData;
         synchronized(delegate) {
 	        for (Iterator<ErrorData> i = delegate.iterator(); i.hasNext(); ) {
 	            errorData = (ErrorData)i.next();
 	
 	            sb.append("#");
 	            sb.append(errorData.getShortText() + " - ");
 	            sb.append(errorData.getLongText());
 	            if (!Text.isBlank(errorData.getField())) {
 	            	sb.append(" [" + errorData.getField() + "]\n");
 	            }
 	        }
         }
         return sb.toString();
     }
     
     /** Return the JSON representation of this object
      *  
      * @return the JSON representation of this object
      */
     public String toJSON() {
         StringBuffer sb = new StringBuffer();
         ErrorList.ErrorData errorData;
         sb.append("[");
         for (int i=0; i<this.size(); i++) {
         	errorData = (ErrorData) get(i);
         	if (i>0) { sb.append(","); }
         	sb.append(
         	  "{\"shortText\":\"" + Text.escapeJavascript(errorData.getShortText()) + "\"," +
         	  "\"longText\":\"" + Text.escapeJavascript(errorData.getLongText()) + "\"," +
         	  "\"fields\":\"" + Text.escapeJavascript(errorData.getField()) + "\"," +
         	  "\"severity\":" + errorData.getSeverity() + "}");
         }
         sb.append("]");
         return sb.toString();
     }
 
     /** Delegate methods */
     
 
     public void forEach(Consumer<? super ErrorData> action) {
 		delegate.forEach(action);
 	}
 
 	public boolean isEmpty() {
 		return delegate.isEmpty();
 	}
 
 	public boolean contains(Object o) {
 		return delegate.contains(o);
 	}
 
 	public Iterator<ErrorData> iterator() {
 		return delegate.iterator();
 	}
 
 	public Object[] toArray() {
 		return delegate.toArray();
 	}
 
 	public <T> T[] toArray(T[] a) {
 		return delegate.toArray(a);
 	}
 
 	public boolean add(ErrorData e) {
 		return delegate.add(e);
 	}
 
 	public boolean remove(Object o) {
 		return delegate.remove(o);
 	}
 
 	public boolean containsAll(Collection<?> c) {
 		return delegate.containsAll(c);
 	}
 
 	public boolean addAll(Collection<? extends ErrorData> c) {
 		return delegate.addAll(c);
 	}
 
 	public boolean addAll(int index, Collection<? extends ErrorData> c) {
 		return delegate.addAll(index, c);
 	}
 
 	public boolean removeAll(Collection<?> c) {
 		return delegate.removeAll(c);
 	}
 
 	public boolean retainAll(Collection<?> c) {
 		return delegate.retainAll(c);
 	}
 
 	public void replaceAll(UnaryOperator<ErrorData> operator) {
 		delegate.replaceAll(operator);
 	}
 
 	public boolean removeIf(Predicate<? super ErrorData> filter) {
 		return delegate.removeIf(filter);
 	}
 
 	public void sort(Comparator<? super ErrorData> c) {
 		delegate.sort(c);
 	}
 
 	public void clear() {
 		delegate.clear();
 	}
 
 	public boolean equals(Object o) {
 		return delegate.equals(o);
 	}
 
 	public int hashCode() {
 		return delegate.hashCode();
 	}
 
 	public ErrorData get(int index) {
 		return delegate.get(index);
 	}
 
 	public ErrorData set(int index, ErrorData element) {
 		return delegate.set(index, element);
 	}
 
 	public void add(int index, ErrorData element) {
 		delegate.add(index, element);
 	}
 
 	public Stream<ErrorData> stream() {
 		return delegate.stream();
 	}
 
 	public ErrorData remove(int index) {
 		return delegate.remove(index);
 	}
 
 	public Stream<ErrorData> parallelStream() {
 		return delegate.parallelStream();
 	}
 
 	public int indexOf(Object o) {
 		return delegate.indexOf(o);
 	}
 
 	public int lastIndexOf(Object o) {
 		return delegate.lastIndexOf(o);
 	}
 
 	public ListIterator<ErrorData> listIterator() {
 		return delegate.listIterator();
 	}
 
 	public ListIterator<ErrorData> listIterator(int index) {
 		return delegate.listIterator(index);
 	}
 
 	public List<ErrorData> subList(int fromIndex, int toIndex) {
 		return delegate.subList(fromIndex, toIndex);
 	}
 
 	public Spliterator<ErrorData> spliterator() {
 		return delegate.spliterator();
 	}
     
     
 }