/*
    * 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.style;
  
  import fr.paris.lutece.plugins.formengine.business.style.StyleSheet;
  import fr.paris.lutece.plugins.formengine.service.FormsRegistrationService;
  import fr.paris.lutece.plugins.formengine.web.Form;
  import fr.paris.lutece.plugins.formengine.web.SubForm;
  import fr.paris.lutece.portal.service.admin.AccessDeniedException;
  import fr.paris.lutece.portal.service.html.XmlTransformerService;
  import fr.paris.lutece.portal.service.message.AdminMessage;
  import fr.paris.lutece.portal.service.message.AdminMessageService;
  import fr.paris.lutece.portal.service.template.AppTemplateService;
  import fr.paris.lutece.portal.service.util.AppException;
  import fr.paris.lutece.portal.service.util.AppLogService;
  import fr.paris.lutece.portal.service.util.AppPathService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import fr.paris.lutece.portal.web.admin.PluginAdminPageJspBean;
  import fr.paris.lutece.portal.web.constants.Parameters;
  import fr.paris.lutece.portal.web.upload.MultipartHttpServletRequest;
  import fr.paris.lutece.portal.web.util.LocalizedPaginator;
  import fr.paris.lutece.util.ReferenceList;
  import fr.paris.lutece.util.html.HtmlTemplate;
  import fr.paris.lutece.util.html.Paginator;
  import fr.paris.lutece.util.sort.AttributeComparator;
  import fr.paris.lutece.util.url.UrlItem;
  
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.fileupload.FileItem;
  import org.apache.commons.lang.StringUtils;
  
  import org.xml.sax.InputSource;
  
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  
  import java.lang.reflect.InvocationTargetException;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import javax.xml.parsers.SAXParser;
  import javax.xml.parsers.SAXParserFactory;
  
  
  /**
   * This class provides the user interface to manage StyleSheet features
   */
  public class StyleSheetJspBean extends PluginAdminPageJspBean
  {
      ////////////////////////////////////////////////////////////////////////////
      // Constants
  
      // Right
      public static final String RIGHT_MANAGE_STYLESHEET = "FORMENGINE_STYLESHEET_MANAGEMENT";
 
     // Markers
     private static final String MARK_FORM_ID = "form";
     private static final String MARK_FORM_LIST = "form_list";
     private static final String MARK_STYLESHEET_LIST = "stylesheet_list";
     private static final String MARK_STYLESHEET = "stylesheet";
     private static final String MARK_PAGINATOR = "paginator";
     private static final String MARK_NB_ITEMS_PER_PAGE = "nb_items_per_page";
 
     // Templates files path
     private static final String TEMPLATE_MANAGE_STYLESHEETS = "admin/plugins/formengine/style/manage_stylesheets.html";
     private static final String TEMPLATE_MODIFY_STYLESHEET = "admin/plugins/formengine/style/modify_stylesheet.html";
 
     // Parameter
     private static final String PARAMETER_FORM = "form";
     private static final String PARAMETER_STYLESHEET_ID = "stylesheet_id";
     private static final String PARAMETER_STYLESHEET_SOURCE = "stylesheet_source";
     private static final String PARAMETER_CANCEL = "cancel";
 
     // Properties
     private static final String PROPERTY_FORMENGINE_XSL_DIRECTORY = "formengine.xsl.directory";
     private static final String PROPERTY_STYLESHEETS_PER_PAGE = "formengine.stylesheet.itemsPerPage";
     private static final String PROPERTYMESSAGE_STYLESHEET_NOT_VALID = "portal.style.message.stylesheetNotValid";
     private static final String PROPERTY_MESSAGE_ERROR_WRITE_FILE = "formengine.style.error.writeXSL";
     private static final String CONSTANT_FORM_ELEMENT_XSL_FILE_NAME = "formelements.xsl";
     private static final String CONSTANT_FORM_ELEMENT_XSL_FORM_NAME = "formengine";
     private static final String CONSTANT_NO_FORM_SELECTED = "-1";
     private int _nItemsPerPage;
     private int _nDefaultItemsPerPage;
     private String _strCurrentPageIndex;
     private String _strForm;
 
     /**
      * Key is form Id. Value is : fileName ==> StyleSheet
      */
     private Map<String, Map<String, StyleSheet>> _mapStyleSheet;
 
     /**
      *
      *{@inheritDoc}
      */
     @Override
     public void init( HttpServletRequest request, String strRight )
         throws AccessDeniedException
     {
         super.init( request, strRight );
         initListStyleSheet(  );
     }
 
     /**
      * Inits the stylesheets map
      * @see #_mapStyleSheet
      */
     private void initListStyleSheet(  )
     {
         if ( _mapStyleSheet == null )
         {
             // FORMELEMENT IS FORM PARENT XSL
             _mapStyleSheet = new HashMap<String, Map<String, StyleSheet>>(  );
 
             StyleSheet formengineStyleSheet = new StyleSheet(  );
             formengineStyleSheet.setFile( CONSTANT_FORM_ELEMENT_XSL_FILE_NAME );
             formengineStyleSheet.setForm( CONSTANT_FORM_ELEMENT_XSL_FORM_NAME );
             formengineStyleSheet.setFormId( CONSTANT_FORM_ELEMENT_XSL_FORM_NAME );
             formengineStyleSheet.setPath( AppPathService.getPath( PROPERTY_FORMENGINE_XSL_DIRECTORY ) + File.separator +
                 CONSTANT_FORM_ELEMENT_XSL_FILE_NAME );
             _mapStyleSheet.put( CONSTANT_FORM_ELEMENT_XSL_FORM_NAME,
                 Collections.singletonMap( CONSTANT_FORM_ELEMENT_XSL_FILE_NAME, formengineStyleSheet ) );
 
             // add forms stylesheets    		
             for ( String strFormName : FormsRegistrationService.getForms(  ) )
             {
                 Form form = FormsRegistrationService.getForm( strFormName );
 
                 for ( Entry<String, SubForm> entrySubForm : (Set<Entry<String, SubForm>>) form.getSubForm(  ).entrySet(  ) )
                 {
                     SubForm subForm = entrySubForm.getValue(  );
                     String strXSLDirectory = subForm.getParentForm(  ).getXslDirectoryPath(  ) + File.separator;
 
                     // key = fileName, value = styleSheet
                     Map<String, StyleSheet> mapStyleSheetSubForm = new HashMap<String, StyleSheet>(  );
 
                     // get other xsl (like object_summary.xsl)
                     for ( String strXslFileName : subForm.getXslFilesNames(  ) )
                     {
                         StyleSheet styleSheet = new StyleSheet(  );
                         styleSheet.setForm( subForm.getParentForm(  ).getName(  ) + "-" + subForm.getName(  ) );
                         styleSheet.setPath( strXSLDirectory + strXslFileName );
                         styleSheet.setFile( strXslFileName );
                         mapStyleSheetSubForm.put( styleSheet.getFile(  ), styleSheet );
                         styleSheet.setFormId( FormsRegistrationService.getIdForm( styleSheet.getForm(  ) ) );
                     }
 
                     _mapStyleSheet.put( FormsRegistrationService.getIdForm( subForm.getParentForm(  ).getName(  ) +
                             "-" + subForm.getName(  ) ), mapStyleSheetSubForm );
                 }
             }
         }
     }
 
     /**
      * Displays the stylesheets list
      * @return the html code for displaying the stylesheets list
      * @param request The request
      */
     public String getManageStyleSheet( HttpServletRequest request )
     {
         // Parameters processing
         ReferenceList listForm = FormsRegistrationService.getListForm(  );
         String strForm = request.getParameter( PARAMETER_FORM );
 
         List<StyleSheet> listStyleSheets;
 
         if ( CONSTANT_NO_FORM_SELECTED.equals( strForm ) )
         {
             _strForm = "";
             listStyleSheets = getStyleSheetList(  );
         }
         else
         {
             if ( StringUtils.isNotBlank( strForm ) )
             {
                 _strForm = strForm;
             }
 
             if ( StringUtils.isNotBlank( _strForm ) )
             {
                 listStyleSheets = getStyleSheetList( _strForm );
             }
             else
             {
                 listStyleSheets = getStyleSheetList(  );
             }
         }
 
         String strSortedAttributeName = request.getParameter( Parameters.SORTED_ATTRIBUTE_NAME );
         String strAscSort = null;
 
         if ( strSortedAttributeName != null )
         {
             strAscSort = request.getParameter( Parameters.SORTED_ASC );
 
             boolean bIsAscSort = Boolean.parseBoolean( strAscSort );
 
             Collections.sort( listStyleSheets, new AttributeComparator( strSortedAttributeName, bIsAscSort ) );
         }
 
         _nDefaultItemsPerPage = AppPropertiesService.getPropertyInt( PROPERTY_STYLESHEETS_PER_PAGE, 50 );
         _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
         _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
                 _nDefaultItemsPerPage );
 
         UrlItem urlItem = new UrlItem( getHomeUrl( request ) );
 
         if ( strSortedAttributeName != null )
         {
             urlItem.addParameter( Parameters.SORTED_ATTRIBUTE_NAME, strSortedAttributeName );
         }
 
         if ( strAscSort != null )
         {
             urlItem.addParameter( Parameters.SORTED_ASC, strAscSort );
         }
 
         LocalizedPaginator<StyleSheet> paginator = new LocalizedPaginator<StyleSheet>( listStyleSheets, _nItemsPerPage,
                 urlItem.getUrl(  ), Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale(  ) );
 
         Map<String, Object> model = new HashMap<String, Object>(  );
         model.put( MARK_FORM_ID, ( _strForm == null ) ? "" : _strForm );
         model.put( MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );
         model.put( MARK_PAGINATOR, paginator );
         model.put( MARK_STYLESHEET_LIST, paginator.getPageItems(  ) );
         model.put( MARK_FORM_LIST, listForm );
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_STYLESHEETS, getLocale(  ), model );
 
         return getAdminPage( template.getHtml(  ) );
     }
 
     /**
      * Saves file to disk
      * @param styleSheet the stylesheet
      * @param request the request
      * @return url if an error occurs
      */
     private String saveFileToDisk( StyleSheetWithFileItem styleSheet, HttpServletRequest request )
     {
         // getFileInfo
         File fileXSL = new File( styleSheet.getPath(  ) );
 
         FileOutputStream fos = null;
 
         try
         {
             fos = new FileOutputStream( fileXSL );
 
             fos.write( styleSheet.getFileItem(  ).get(  ) );
         }
         catch ( IOException e )
         {
             AppLogService.error( e.getMessage(  ), e );
 
             return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_ERROR_WRITE_FILE,
                 new String[] { e.getMessage(  ) }, AdminMessage.TYPE_ERROR );
         }
         finally
         {
             // close streams
             if ( fos != null )
             {
                 try
                 {
                     fos.close(  );
                 }
                 catch ( IOException e )
                 {
                     AppLogService.error( e.getMessage(  ), e );
                 }
             }
         }
 
         return null;
     }
 
     /**
      * Reads stylesheet's data
      * @param multipartRequest The request
      * @param stylesheet The style sheet
      * @return An error message URL or null if no error
      */
     private String getData( MultipartHttpServletRequest multipartRequest, StyleSheetWithFileItem stylesheet )
     {
         String strErrorUrl = null;
 
         FileItem fileSource = multipartRequest.getFile( PARAMETER_STYLESHEET_SOURCE );
         byte[] baXslSource = fileSource.get(  );
 
         // Check the XML validity of the XSL stylesheet
         if ( isValid( baXslSource ) != null )
         {
             Object[] args = { isValid( baXslSource ) };
 
             return AdminMessageService.getMessageUrl( multipartRequest, PROPERTYMESSAGE_STYLESHEET_NOT_VALID, args,
                 AdminMessage.TYPE_STOP );
         }
 
         stylesheet.setFileItem( fileSource );
 
         return strErrorUrl;
     }
 
     /**
      * Returns the form to update a stylesheet whose identifer is stored in the http request
      * @param request The http request
      * @return The html code
      */
     public String getModifyStyleSheet( HttpServletRequest request )
     {
         StyleSheet styleSheet = getStyleSheetFromRequest( request );
 
         if ( styleSheet == null )
         {
             throw new IllegalArgumentException( "Stylesheet does not exist" );
         }
 
         Map<String, Object> model = new HashMap<String, Object>(  );
         model.put( MARK_FORM_LIST, FormsRegistrationService.getListForm(  ) );
 
         model.put( MARK_STYLESHEET, styleSheet );
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_STYLESHEET, getLocale(  ), model );
 
         return getAdminPage( template.getHtml(  ) );
     }
 
     /**
      * Gets all stylesheets list
      * @return list
      */
     private List<StyleSheet> getStyleSheetList(  )
     {
         List<StyleSheet> listStyleSheets = new ArrayList<StyleSheet>(  );
 
         for ( Map<String, StyleSheet> mapsStyleSheet : _mapStyleSheet.values(  ) )
         {
             listStyleSheets.addAll( mapsStyleSheet.values(  ) );
         }
 
         return listStyleSheets;
     }
 
     /**
      * Filtered stylesheet list
      * @param strFormId the form id
      * @return list
      */
     private List<StyleSheet> getStyleSheetList( String strFormId )
     {
         List<StyleSheet> listStyleSheets = new ArrayList<StyleSheet>(  );
 
         Map<String, StyleSheet> mapsStyleSheet = _mapStyleSheet.get( strFormId );
 
         if ( mapsStyleSheet != null )
         {
             listStyleSheets.addAll( mapsStyleSheet.values(  ) );
         }
 
         return listStyleSheets;
     }
 
     /**
      * Gets the stylesheet from request
      * @param request the request
      * @return the stylesheet found, <code>null</code> otherwise.
      */
     private StyleSheet getStyleSheetFromRequest( HttpServletRequest request )
     {
         String strFormId = request.getParameter( PARAMETER_FORM );
         String strStyleSheetId = request.getParameter( PARAMETER_STYLESHEET_ID );
 
         Map<String, StyleSheet> mapStyleSheets = _mapStyleSheet.get( strFormId );
 
         if ( mapStyleSheets == null )
         {
             AppLogService.error( "FORMENGINE : form not found for id=" + strFormId );
 
             return null;
         }
 
         return mapStyleSheets.get( strStyleSheetId );
     }
 
     /**
      * Processes the updating form of a stylesheet whose new parameters are stored in the
      * http request
      * @param request The http request
      * @return The Jsp URL of the process result
      */
     public String doModifyStyleSheet( HttpServletRequest request )
     {
         if ( request.getParameter( PARAMETER_CANCEL ) != null )
         {
             return getHomeUrl( request );
         }
 
         // FormsRegistrationService
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
 
         StyleSheet stylesheet = getStyleSheetFromRequest( request );
         StyleSheetWithFileItem styleSheetWithFileItem = null;
 
         try
         {
             styleSheetWithFileItem = new StyleSheetWithFileItem( stylesheet );
         }
         catch ( IllegalAccessException e )
         {
             AppLogService.error( e.getMessage(  ), e );
             throw new AppException( e.getMessage(  ), e );
         }
         catch ( InvocationTargetException e )
         {
             AppLogService.error( e.getMessage(  ), e );
             throw new AppException( e.getMessage(  ), e );
         }
 
         String strErrorUrl = getData( multipartRequest, styleSheetWithFileItem );
 
         if ( strErrorUrl != null )
         {
             return strErrorUrl;
         }
 
         // Update the stylesheet in database
         strErrorUrl = saveFileToDisk( styleSheetWithFileItem, request );
 
         if ( strErrorUrl != null )
         {
             return strErrorUrl;
         }
 
         // clear XSL cache
         XmlTransformerService.clearXslCache(  );
 
         // Displays the management stylesheet page
         return getHomeUrl( request );
     }
 
     /**
      * Downloads the xsl file
      * @param request the request
      * @param response the response
      * @return home url if no file found, <code>null</code> otherwise.
      */
     public String doViewStyleSheet( HttpServletRequest request, HttpServletResponse response )
     {
         StyleSheet styleSheet = getStyleSheetFromRequest( request );
 
         if ( styleSheet == null )
         {
             return getHomeUrl( request );
         }
 
         OutputStream os = null;
         File fileXSL = new File( styleSheet.getPath(  ) );
         FileInputStream fis;
 
         try
         {
             fis = new FileInputStream( fileXSL );
         }
         catch ( FileNotFoundException e1 )
         {
             return getHomeUrl( request );
         }
 
         try
         {
             String strFileName = styleSheet.getFile(  );
             addHeaderResponse( request, response, strFileName );
             response.setContentLength( (int) fileXSL.length(  ) );
 
             os = response.getOutputStream(  );
 
             byte[] bytes = new byte[1024];
 
             while ( fis.read( bytes ) != -1 )
             {
                 os.write( bytes );
             }
         }
         catch ( IOException e )
         {
             AppLogService.error( e );
         }
         finally
         {
             if ( os != null )
             {
                 try
                 {
                     os.close(  );
                 }
                 catch ( IOException e )
                 {
                     AppLogService.error( e );
                 }
             }
 
             try
             {
                 fis.close(  );
             }
             catch ( IOException e )
             {
                 AppLogService.error( e );
             }
         }
 
         return null;
     }
 
     /**
      * write the http header in the response
      * @param request the httpServletRequest
      * @param response the http response
      * @param strFileName the name of the file who must insert in the response
      */
     private static void addHeaderResponse( HttpServletRequest request, HttpServletResponse response, String strFileName )
     {
         response.setHeader( "Content-Disposition", "attachment ;filename=\"" + strFileName + "\"" );
 
         if ( strFileName.endsWith( "xsl" ) )
         {
             response.setContentType( "text/xml" );
         }
         else
         {
             String strMimeType = request.getSession(  ).getServletContext(  ).getMimeType( strFileName );
 
             if ( strMimeType != null )
             {
                 response.setContentType( strMimeType );
             }
             else
             {
                 response.setContentType( "application/octet-stream" );
             }
         }
 
         response.setHeader( "Pragma", "public" );
         response.setHeader( "Expires", "0" );
         response.setHeader( "Cache-Control", "must-revalidate,post-check=0,pre-check=0" );
     }
 
     //////////////////////////////////////////////////////////////////////////////////
     // Private implementation
 
     /**
      *  Use parsing for validate the modify xsl file
      *
      * @param baXslSource The XSL source
      * @return the message exception when the validation is false
      */
     private String isValid( byte[] baXslSource )
     {
         String strError = null;
 
         try
         {
             SAXParserFactory factory = SAXParserFactory.newInstance(  );
             SAXParser analyzer = factory.newSAXParser(  );
             InputSource is = new InputSource( new ByteArrayInputStream( baXslSource ) );
             analyzer.getXMLReader(  ).parse( is );
         }
         catch ( Exception e )
         {
             strError = e.getMessage(  );
         }
 
         return strError;
     }
 
     /**
      * Style sheet with an attribute fileItem
      * @see StyleSheet
      */
     private static class StyleSheetWithFileItem extends StyleSheet
     {
         private FileItem _fileItem;
 
         /**
                  * Empty constructor
                  */
         public StyleSheetWithFileItem(  )
         {
             // nothing
         }
 
         /**
          * Copies {@link StyleSheet} infos
          * @param styleSheet the stylesheet to copy
          * @throws IllegalAccessException if copy does not work
          * @throws InvocationTargetException if copy does not work
          */
         public StyleSheetWithFileItem( StyleSheet styleSheet )
             throws IllegalAccessException, InvocationTargetException
         {
             BeanUtils.copyProperties( this, styleSheet );
         }
 
         /**
          * "Getter method" for {@link #_fileItem}
          * @return value of {@link #_fileItem}
          */
         public FileItem getFileItem(  )
         {
             return _fileItem;
         }
 
         /**
          * "Setter method" for {@link #_fileItem}
          * @param item new value of {@link #_fileItem}
          */
         public void setFileItem( FileItem item )
         {
             _fileItem = item;
         }
     }
 }