/*
    * Copyright 2007 the original author or authors.
    *
    * 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 net.sf.valjax;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.context.NoSuchMessageException;
  import org.springframework.context.i18n.LocaleContextHolder;
  import org.springframework.context.support.MessageSourceAccessor;
  import org.springframework.validation.BindException;
  import org.springframework.validation.FieldError;
  import org.springframework.web.servlet.ModelAndView;
  import org.springframework.web.servlet.mvc.SimpleFormController;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  
  /***
   * SimpleFormController that configures the response, view and
   * the model needed for Ajax.
   *
   * <p>Uses the same workflow as described in the parent implementation.
   * Any <code>BindException</code> errors are processed and transformed
   * using {@link #getErrors getErrors} into a String that can be properly
   * digested in the Ajax response.
   *
   * <p>You will need to use the {@link #setValidatorView setValidatorView}
   *  to provide the default configuration as shown here:</p>
   *
   * <pre class="code">
   *    &lt;property name="validatorView"&gt;
   *      &lt;value>valjax-response&lt;/value&gt;
   *    &lt;/property&gt;
   * </pre>
   *
   * @author     Zach Legein
   *
   */
  public class AjaxSimpleFormController extends SimpleFormController {
    protected static final Log log = LogFactory.getLog(AjaxSimpleFormController.class);
    private String validatorResponse;
    private String validatorView;
  
    /***
     * Proccess the form submission with any validation errors.
     *
     * <p>Check to see if the incoming {@link HttpServletRequest request}
     * is an Ajax call or not. If it is then {@link #processAjaxSubmit processAjaxSubmit},
     * otherwise we let {@link #processFormSubmission} do its job.
     *
     * @see #processAjaxSubmit
     */
    @Override
    public ModelAndView processFormSubmission(HttpServletRequest request, HttpServletResponse response, Object command,
      BindException errors)
            throws Exception {
  
      // todo: not sure if we need to do this or not, if multiple forms, maybe?
      if (request.getParameter("valjax") != null) {
        return processAjaxSubmit(errors);
      }
  
      return super.processFormSubmission(request, response, command, errors);
    }
  
    /***
     * Provide the <code>ModelAndView</code> to use for
     * the Ajax response.
     *
     * <p>Returns a new ModelAndView, setting the view as described
     * in {@link #setValidatorView setValidatorView} with the errors
     * from {@link #getErrors getErrors} loaded into the model with
     * {@link #setValidatorResponse setValidatorResponse} as the key
     * to the errors. This key is then used in the view to lookup the
     * error messages for the form.</p>
     *
     *
     * @param errors Rejects from the validator
     * @return ModelAndView to return
     *
    * @see #getErrors
    * @see # setValidatorResponse
    * @see # setValidatorView
    */
   public ModelAndView processAjaxSubmit(BindException errors) {
     
      Map<String, String> map = new HashMap<String, String>();
 
     if (validatorResponse == null) validatorResponse = "validatorResponse";
 
     try {
       map.put(validatorResponse, getErrors(errors));
 
       return new ModelAndView(validatorView, map);
     }
     catch (Exception ex) {
       map.put(validatorResponse, "[['id','msg'],['errors','Validation Framework Error: " + ex.getMessage() + "']]");
       log.error("Validation Framework Error: " + ex.getMessage(), ex);
 
       return new ModelAndView(validatorView, map);
     }
   }
 
   /***
    * Formats the {@link BindException errors} to be used in the AJax response.
    *
    * <p>Each error is wrapped in '[ ]' with the name of the field and
    * a list of all the errors for that field, using the '|' as a delimeter
    * for each field error. The pairing in the first '[ ]' are the preset
    * names used to identify the field and the error message(s).</p>
    * <pre class="code">
    * Multiple fields with errors:
    * [['id','msg'],['name','Required Field'],['number','Please enter a value between 10 and 20']]
    *
    * Multiple errors on the same field:
    * [['id','msg'],['name','Required Field | Invalid Last Name']]
    *
    * Multiple errors on the same field and multiple fields with errors:
    * [['id','msg'],['name','Required Field | Invalid Last Name'],['number','Please enter a value between 10 and 20']]
    * </pre>   
    *
    * @param errors Validation errors to format.
    * @return Ajax representation of the errors
    *
    */
   protected String getErrors(BindException errors) {
     MessageSourceAccessor msa = getMessageSourceAccessor();
     StringBuffer buffer       = new StringBuffer("[['id','msg']");
     Locale locale             = LocaleContextHolder.getLocale();
 
     for (Object obj : errors.getFieldErrors()) {
       FieldError error = (FieldError) obj;
 
       try {
         buffer.append(",['").append(error.getField()).append('\'');
         buffer.append(",'").append(msa.getMessage(error.getCode(), error.getArguments(), locale)).append("']");
       }
       catch (NoSuchMessageException ex) {
         buffer.append(",['").append(error.getField()).append("','Message code does not exist: ").append(
             error.getCode()).append("']");
         log.error("Message code does not exist: " + error.getCode(), ex);
       }
     }
 
     buffer.append(']');
 
     return buffer.toString();
   }
 
   /***
    * The view the Ajax response will use to lookup
    * errors.
    *
    * <p>This is required and needs to be set. The mandatory default
    * is as follows.</p>
    *
    * <pre class="code">
    *    &lt;property name="validatorView"&gt;
    *      &lt;value>valjax-response&lt;/value&gt;
    *    &lt;/property&gt;
    * </pre>
    *
    * <p>This corresponds to the <code>valjax-response.jsp</code> file
    * that is used as the view when returning errors.
    *
    * @param validatorView Name of the view when there are errors.
    */
   public void setValidatorView(String validatorView) {
     this.validatorView = validatorView;
   }
 
   /***
    * Token to use in the <code>validatorView</code> file
    * to allow Ajax to lookup the errors.
    *
    * <p>Default setting, if one is not set:
    * <b>validatorResponse</b></p>
    *
    * @param validatorResponse Name of the token to use to lookup errors.
    */
   @SuppressWarnings({ "UnusedDeclaration" })
   public void setValidatorResponse(String validatorResponse) {
     this.validatorResponse = validatorResponse;
   }
 }