/*
    * Copyright (c) 2002-2014, Mairie de Paris
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    *  1. Redistributions of source code must retain the above copyright notice
   *     and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright notice
   *     and the following disclaimer in the documentation and/or other materials
   *     provided with the distribution.
   *
   *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
   *     contributors may be used to endorse or promote products derived from
   *     this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * License 1.0
   */
  package fr.paris.lutece.plugins.formengine.web;
  
  import fr.paris.lutece.plugins.formengine.service.FormsRegistrationService;
  import fr.paris.lutece.plugins.formengine.util.JSONUtils;
  import fr.paris.lutece.portal.service.i18n.I18nService;
  import fr.paris.lutece.portal.service.message.SiteMessageException;
  import fr.paris.lutece.portal.service.plugin.Plugin;
  import fr.paris.lutece.portal.service.security.UserNotSignedException;
  import fr.paris.lutece.portal.service.template.AppTemplateService;
  import fr.paris.lutece.portal.service.util.AppHTTPSService;
  import fr.paris.lutece.portal.service.util.AppPathService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import fr.paris.lutece.portal.web.PortalJspBean;
  import fr.paris.lutece.portal.web.xpages.XPage;
  import fr.paris.lutece.portal.web.xpages.XPageApplication;
  import fr.paris.lutece.util.html.HtmlTemplate;
  
  import net.sf.json.JSON;
  import net.sf.json.JSONArray;
  import net.sf.json.JSONObject;
  import net.sf.json.JSONSerializer;
  
  import org.apache.commons.lang.ArrayUtils;
  import org.apache.commons.lang.StringUtils;
  
  import java.util.Arrays;
  import java.util.Enumeration;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSession;
  
  
  /**
   * Form Engine XPage Application
   *
   */
  public class FormEngineApp implements XPageApplication
  {
      // CONSTANTS
      private static final String SLASH = "/";
  
      // PARAMETERS
      private static final String PARAMETER_PAGE = "page";
      private static final String PARAMETER_FORM_NAME = "form";
      private static final String PARAMETER_SUBFORM_NAME = "subform";
      private static final String PARAMETER_ACTION_NAME = "action";
      private static final String PARAMETER_PORTAL_URI = "portalURI";
      private static final String PARAMETER_FIELD_NAME = "field_name";
      private static final String PARAMETER_FIELD_INDEX = "field_index";
  
      // PROPERTY
      private static final String PROPERTY_MESSAGE_SESSION_LOST = "formengine.session.lost";
      private static final String PROPERTY_MESSAGE_ERROR_REMOVING_FILE = "formengine.message.error.removingFile";
  
      // TEMPLATES
      private static final String TEMPLATE_ACCESS_ERROR = "/skin/plugins/formengine/access_error.html";
  
      /**
       * Get the xpage that display the form contents
       * @param request the http request
       * @param nMode The mode
       * @param plugin The plugin
       * @return the xpage for the forms
       * @throws UserNotSignedException If an authentication is required and the user is not signed
       * @throws SiteMessageException If an error occurs
       */
     public XPage getPage( HttpServletRequest request, int nMode, Plugin plugin )
         throws UserNotSignedException, SiteMessageException
     {
         XPage page = new XPage(  );
 
         // Set the upload filter site next url
         PortalJspBean.setUploadFilterSiteNextUrl( request );
 
         // retrieve the parameters
         String strFormName = request.getParameter( PARAMETER_FORM_NAME );
         String strSubFormName = request.getParameter( PARAMETER_SUBFORM_NAME );
 
         // get the form from its name
         Form form = FormsRegistrationService.getForm( strFormName );
 
         if ( ( form == null ) || form.isClosed( request.getLocale(  ) ) )
         {
             // if the form is not found, display an error message
             page.setContent( this.getAccessErrorMessage(  ) );
 
             return page;
         }
 
         SubForm subForm = getSubForm( request, form, strSubFormName );
 
         if ( form.preprocessRequest( request ) )
         {
             return page;
         }
 
         if ( subForm == null )
         {
             // if no subform was found, display an error
             page.setContent( this.getAccessErrorMessage(  ) );
 
             return page;
         }
 
         // don't forget to allow access to the first subform
         if ( subForm.getPreviousSubForm(  ) == null )
         {
             // grant access to the first subform
             subForm.setIsSubFormAllowed( request, true );
         }
 
         // display result
         page.setContent( subForm.display( request ) );
         page.setTitle( form.getTitle(  ) );
         page.setPathLabel( form.getTitle(  ) + " - " + subForm.getTitle(  ) );
 
         // reset errors
         form.resetErrors( request );
 
         // if we are at the last subform, clean the session
         if ( subForm.getNextSubForm(  ) == null )
         {
             form.validateDraft( request, form );
             form.flushSession( request );
         }
 
         return page;
     }
 
     /**
      * Set the display URL of a form depending on the given subform name
      * @param request the http request - gives the plugin name and the form name
      * @param strSubFormName the name of the subform to display
      * @return the url to display the given subform
      */
     public static String setUrl( HttpServletRequest request, String strSubFormName )
     {
         String strUrl = null;
         String strPluginName = SharedConstants.PLUGIN_NAME;
         String strFormName = request.getParameter( PARAMETER_FORM_NAME );
         String strFormPortalUrl = request.getParameter( PARAMETER_PORTAL_URI );
 
         // get the form from the name in request
         Form form = FormsRegistrationService.getForm( strFormName );
 
         if ( form != null )
         {
             strFormPortalUrl = strFormPortalUrl.replaceFirst( request.getContextPath(  ) + SLASH, "" );
 
             String strBaseURL;
 
             if ( AppHTTPSService.isHTTPSSupportEnabled(  ) )
             {
                 HttpSession session = request.getSession(  );
 
                 if ( session != null )
                 {
                     session.setAttribute( AppPathService.SESSION_BASE_URL, AppPathService.getBaseUrl( request ) );
                 }
 
                 strBaseURL = AppHTTPSService.getHTTPSUrl( request );
             }
             else
             {
                 strBaseURL = AppPathService.getBaseUrl( request );
             }
 
             strUrl = strBaseURL + strFormPortalUrl + "?" + PARAMETER_PAGE + "=" + strPluginName + "&" +
                 PARAMETER_FORM_NAME + "=" + strFormName;
 
             // if session is not lost
             if ( request.isRequestedSessionIdValid(  ) )
             {
                 strUrl = strUrl + "&" + PARAMETER_SUBFORM_NAME + "=" + strSubFormName;
             }
         }
 
         return strUrl;
     }
 
     public String getUploadedFiles( HttpServletRequest request )
     {
         String strFormName = request.getParameter( PARAMETER_FORM_NAME );
         String strSubFormName = request.getParameter( PARAMETER_SUBFORM_NAME );
         String strFieldName = request.getParameter( PARAMETER_FIELD_NAME );
 
         if ( StringUtils.isBlank( strFormName ) || StringUtils.isBlank( strFieldName ) )
         {
             return buildJsonErrorRemovingFile( request ).toString(  );
         }
 
         // find the subform
         Form form = FormsRegistrationService.getForm( strFormName );
 
         if ( form == null )
         {
             return buildJsonErrorRemovingFile( request ).toString(  );
         }
 
         SubForm subForm = null;
 
         if ( StringUtils.isNotBlank( strSubFormName ) )
         {
             subForm = form.getSubForm( strSubFormName );
         }
 
         if ( subForm == null )
         {
             // if upload is in first subform, no subform parameter available
             subForm = form.getFirstSubForm(  );
         }
 
         // merge asynchronous uploaded file with already uploaded files before deleting
         FormErrorsList listErrors = new FormErrorsList(  );
         subForm.mergeAsynchronousUploadedFiles( request, strFieldName, listErrors );
 
         JSONObject json = JSONUtils.getUploadedFileJSON( subForm.getFileItems( request, strFieldName ) );
 
         // Add errors
         for ( String strMessage : listErrors )
         {
             json.accumulate( JSONUtils.JSON_KEY_ERROR_MESSAGES, strMessage );
         }
 
         // we have to clear error list to prevent user from refreshing page
         form.resetErrors( request );
 
         // add field name
         json.element( JSONUtils.JSON_KEY_FIELD, strFieldName );
 
         return json.toString(  );
     }
 
     /**
      * Remove an asynchronous uploaded file.
      * @param request the request
      * @return
      */
     public String doRemoveAsynchronousUploadedFile( HttpServletRequest request )
     {
         // get the request parameters
         String strFormName = request.getParameter( PARAMETER_FORM_NAME );
         String strSubFormName = request.getParameter( PARAMETER_SUBFORM_NAME );
         String strFieldName = request.getParameter( PARAMETER_FIELD_NAME );
         String strFieldIndex = request.getParameter( PARAMETER_FIELD_INDEX );
 
         if ( StringUtils.isBlank( strFormName ) || StringUtils.isBlank( strFieldName ) ||
                 StringUtils.isBlank( strFieldIndex ) )
         {
             return buildJsonErrorRemovingFile( request ).toString(  );
         }
 
         // find the subform
         Form form = FormsRegistrationService.getForm( strFormName );
 
         if ( form == null )
         {
             return buildJsonErrorRemovingFile( request ).toString(  );
         }
 
         SubForm subForm = null;
 
         if ( StringUtils.isNotBlank( strSubFormName ) )
         {
             subForm = form.getSubForm( strSubFormName );
         }
 
         if ( subForm == null )
         {
             // if upload is in first subform, no subform parameter available
             subForm = form.getFirstSubForm(  );
         }
 
         // parse json
         JSON jsonFieldIndexes = JSONSerializer.toJSON( strFieldIndex );
 
         if ( !jsonFieldIndexes.isArray(  ) )
         {
             return buildJsonErrorRemovingFile( request ).toString(  );
         }
 
         JSONArray jsonArrayFieldIndexers = (JSONArray) jsonFieldIndexes;
 
         int[] tabFieldIndex = new int[jsonArrayFieldIndexers.size(  )];
 
         for ( int nIndex = 0; nIndex < jsonArrayFieldIndexers.size(  ); nIndex++ )
         {
             try
             {
                 tabFieldIndex[nIndex] = Integer.parseInt( jsonArrayFieldIndexers.getString( nIndex ) );
             }
             catch ( NumberFormatException nfe )
             {
                 return buildJsonErrorRemovingFile( request ).toString(  );
             }
         }
 
         // merge asynchronous uploaded file with already uploaded files before deleting
         subForm.mergeAsynchronousUploadedFiles( request, strFieldName );
 
         // inverse order (removing using index - remove greater first to keep order)
         Arrays.sort( tabFieldIndex );
         ArrayUtils.reverse( tabFieldIndex );
 
         JSONObject json = new JSONObject(  );
 
         for ( int nFieldIndex : tabFieldIndex )
         {
             subForm.removeUploadedFileItem( request, strFieldName, nFieldIndex );
         }
 
         // add field name
         json.element( JSONUtils.JSON_KEY_FIELD, strFieldName );
         // operation successful
         json.element( JSONUtils.JSON_KEY_SUCCESS, JSONUtils.JSON_KEY_SUCCESS );
         json.accumulateAll( JSONUtils.getUploadedFileJSON( subForm.getFileItems( request, strFieldName ) ) );
 
         return json.toString(  );
     }
 
     /**
      * Builds a json object with the error message.
      * @param request the request
      * @return the json object.
      */
     private JSONObject buildJsonErrorRemovingFile( HttpServletRequest request )
     {
         JSONObject json = new JSONObject(  );
 
         json.element( JSONUtils.JSON_KEY_ERROR,
             I18nService.getLocalizedString( PROPERTY_MESSAGE_ERROR_REMOVING_FILE, request.getLocale(  ) ) );
 
         return json;
     }
 
     /**
      * Perform an action on a given subform
      * @param request the http request - gives the form, subform and action name
      * @return the name of the subform to display after having performed the requested action
      */
     public String doAction( HttpServletRequest request )
     {
         // get the request parameters
         String strFormName = request.getParameter( PARAMETER_FORM_NAME );
         String strSubFormName = request.getParameter( PARAMETER_SUBFORM_NAME );
         String strActionName = request.getParameter( PARAMETER_ACTION_NAME );
 
         // default next subform (in case of error) is current subform
         String strNextSubForm = strSubFormName;
 
         // get the form from its name
         Form form = FormsRegistrationService.getForm( strFormName );
 
         // If session is lost
         if ( !request.isRequestedSessionIdValid(  ) )
         {
             form.addErrorMessage( request, AppPropertiesService.getProperty( PROPERTY_MESSAGE_SESSION_LOST ) );
 
             return strSubFormName;
         }
 
         // Special case for upload fields : if no action is specified, a submit
         // button associated with an upload might have been pressed :
         if ( strActionName == null )
         {
             String strUploadAction = getUploadAction( request );
 
             if ( strUploadAction != null )
             {
                 return form.getSubForm( strSubFormName ).doUploadAction( request, strUploadAction );
             }
         }
 
         SubForm subForm = null;
 
         if ( form != null ) // if we have a form corresponding to the name
         {
             // get the subform from its name
             subForm = form.getSubForm( strSubFormName );
 
             if ( subForm != null ) // if we have a subform corresponding to the name
             {
                 if ( subForm.getIsSubFormAllowed( request ) )
                 {
                     // perform the action
                     strNextSubForm = subForm.doAction( strActionName, request );
                     // save draft
                     form.saveDraft( request );
                 }
             }
         }
 
         return strNextSubForm;
     }
 
     /**
      * Get the error message from its template
      * @return the html code for an error
      */
     private String getAccessErrorMessage(  )
     {
         HtmlTemplate templateNotFound = AppTemplateService.getTemplate( TEMPLATE_ACCESS_ERROR );
 
         return templateNotFound.getHtml(  );
     }
 
     /**
      * Checks the request parameters to see if an upload submit has been
      * called.
      *
      * @param request the HTTP request
      * @return the name of the upload action, if any. Null otherwise.
      */
     private static String getUploadAction( HttpServletRequest request )
     {
         Enumeration enumParamNames = request.getParameterNames(  );
 
         while ( enumParamNames.hasMoreElements(  ) )
         {
             String paramName = (String) enumParamNames.nextElement(  );
 
             if ( paramName.startsWith( SharedConstants.UPLOAD_SUBMIT_PREFIX ) ||
                     paramName.startsWith( SharedConstants.UPLOAD_DELETE_PREFIX ) )
             {
                 return paramName;
             }
         }
 
         return null;
     }
 
     /**
      * Get the subform corresponding to the request
      * @param request The HTTP request
      * @param form The form
      * @param strSubFormName The subform name
      * @return The subform
      */
     private SubForm getSubForm( HttpServletRequest request, Form form, String strSubFormName )
     {
         SubForm subForm = null;
 
         if ( ( strSubFormName == null ) || ( strSubFormName.trim(  ).equals( "" ) ) )
         {
             // if no subform name was stated, choose the first subform
             subForm = form.getFirstSubForm(  );
             form.flushSession( request );
         }
         else
         {
             // else retrieve the subform from its name
             subForm = form.getSubForm( strSubFormName );
         }
 
         return subForm;
     }
 }