/**
    * This file is part of the equanda project.
    *
    * The contents of this file are subject to the Mozilla Public License Version 1.1 (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.mozilla.org/MPL/
    *
    * Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
    * ANY KIND, either express or implied. See the License for the specific language governing rights and
   * limitations under the License.
   *
   * Alternatively, the contents of this file may be used under the terms of
   * either the GNU General Public License Version 2 or later (the "GPL"), or
   * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the MPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the MPL, the GPL or the LGPL.
   */
  
  package org.equanda.tapestry5.components;
  
  import org.apache.tapestry5.*;
  import org.apache.tapestry5.annotations.*;
  import org.apache.tapestry5.corelib.components.Delegate;
  import org.apache.tapestry5.corelib.components.Loop;
  import org.apache.tapestry5.ioc.annotations.Inject;
  import org.apache.tapestry5.services.ComponentDefaultProvider;
  import org.apache.tapestry5.services.Environment;
  import org.apache.tapestry5.services.FormSupport;
  import org.apache.tapestry5.services.Request;
  import org.chenillekit.tapestry.core.components.Hidden;
  import org.equanda.tapestry5.base.ObjectCreatorDelegate;
  import org.equanda.tapestry5.base.PagerConfig;
  import org.slf4j.Logger;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  /**
   * Paged Loop component with Java Script Pager
   *
   * @author <a href="mailto:vladimir.tkachenko@gmail.com">Vladimir Tkachenko</a>
   */
  public class JSPagedLoop
      implements ClientElement
  {
      @Environmental
      private RenderSupport renderSupport;
  
      @Inject
      private Environment environment;
  
      @Inject
      private Logger log;
  
      @Inject
      private ComponentResources resources;
  
      @Environmental
      private FormSupport formSupport;
  
      @Inject
      private Request request;
  
      @Inject
      private ComponentDefaultProvider componentDefaultProvider;
  
      @Parameter( value = "prop:componentResources.id", defaultPrefix = BindingConstants.LITERAL )
      private String clientId;
  
      /**
       * The element to render. If not null, then the loop will render the indicated element around its body (on each pass
       * through the loop). The default is derived from the component template.
       */
      @Parameter( value = "prop:componentResources.elementName", defaultPrefix = BindingConstants.LITERAL )
      private String elementName;
  
      /** Defines the collection of values for the loop to iterate over. */
      @Parameter( required = true, principal = true )
      private Collection<Object> source;
  
      @Persist
      private List<Object> addedRowsList;
  
      @Persist
      private List<Object> pagedSource;
  
      /**
       * The number of rows of data displayed on each page. If there are more rows than will fit, the Grid will divide up
       * the rows into "pages" and (normally) provide a pager to allow the user to navigate within the overall result set.
       */
      @Parameter( "25" )
      private int rowsPerPage;
 
     @Persist
     private int currentPage;
 
     private int addedRowCount;
 
     /** The current value, set before the component renders its body. */
     @Parameter
     private Object value;
 
     @Parameter( defaultPrefix = BindingConstants.PROP )
     private ObjectCreatorDelegate objectCreatorDelegate;
 
     /** The index into the source items. */
     @Parameter
     private int index;
 
     @Parameter
     private int additionalRowCount;
 
     /**
      * Optional primary key converter; if provided and inside a form and not volatile, then each iterated value is
      * converted and stored into the form.
      */
     @Parameter
     private PrimaryKeyEncoder<?, ?> encoder;
 
     @SuppressWarnings( "unused" )
     @Component( parameters = { "source=pagedSource", "elementName=prop:elementName", "value=inherit:value",
                                "volatile=true", "encoder=inherit:encoder", "index=index" } )
     private Loop loop;
 
     @Component( parameters = { "source=pagedSource", "rowsPerPage=rowsPerPage", "currentPage=currentPage" } )
     private JSPager internalPager;
 
     @Component( id = "CurrentPageHidden", parameters = { "value=currentPage", "translate=translate:integer" } )
     private Hidden currentPageHidden;
 
     @Component( id = "AddedRowsHidden", parameters = { "value=addedRowCount", "translate=translate:integer" } )
     private Hidden addedRowHidden;
 
     @SuppressWarnings( "unused" )
     @Component( parameters = "to=pagerBottom" )
     private Delegate pagerBottom;
 
     /**
      * A Block to render instead of the table (and pager, etc.) when the source is empty. The default is simply the text
      * "There is no data to display". This parameter is used to customize that message, possibly including components to
      * allow the user to create new objects.
      */
     @Parameter( value = "block:empty" )
     private Block empty;
 
     @Parameter( value = "block:bottomBlock" )
     private Block bottomBlock;
 
     @Parameter( value = "message:add.title.label", defaultPrefix = BindingConstants.LITERAL )
     private String addRowLinkTitle;
 
     private String assignedClientId;
 
     private String addedRowCountHiddenName;
 
     static class FormSubmitAction
         implements ComponentAction<JSPagedLoop>
     {
 
         private static final long serialVersionUID = 456056528334001727L;
 
         public void execute( JSPagedLoop component )
         {
             component.processFormAction();
         }
     }
 
     static class SetupAction
         implements ComponentAction<JSPagedLoop>
     {
 
         private static final long serialVersionUID = 6727709013577574475L;
         private final String addedRowCountHiddenName;
 
         public SetupAction( String controlName )
         {
             addedRowCountHiddenName = controlName;
         }
 
         public void execute( JSPagedLoop component )
         {
             component.setupAddedRowCountHiddenName( addedRowCountHiddenName );
         }
     }
 
     private static final FormSubmitAction FORM_SUBMIT_ACTION = new FormSubmitAction();
 
     private void setupAddedRowCountHiddenName( String name )
     {
         addedRowCountHiddenName = name;
     }
 
     Binding defaultSource()
     {
         return componentDefaultProvider.defaultBinding( "source", resources );
     }
 
     void setSource( Collection<Object> source )
     {
         this.source = source;
     }
 
     public String getAddRowLinkTitle()
     {
         return addRowLinkTitle;
     }
 
     public int getIndex()
     {
         return index;
     }
 
     public void setIndex( int index )
     {
         this.index = index;
     }
 
     public String getElementName()
     {
         return elementName;
     }
 
     public Block getBottomBlock()
     {
         return bottomBlock;
     }
 
     public Object getPagerBottom()
     {
         return internalPager;
     }
 
     public List<Object> getPagedSource()
     {
         return pagedSource;
     }
 
     public int getRowsPerPage()
     {
         return rowsPerPage;
     }
 
     public void setRowsPerPage( int rowsPerPage )
     {
         this.rowsPerPage = rowsPerPage;
     }
 
     public int getCurrentPage()
     {
         return currentPage;
     }
 
     public void setCurrentPage( int currentPage )
     {
         this.currentPage = currentPage;
     }
 
     public int getAddedRowCount()
     {
         return addedRowCount;
     }
 
     public void setAddedRowCount( int addedRowCount )
     {
         this.addedRowCount = addedRowCount;
     }
 
     public int getAdditionalRowCount()
     {
         return additionalRowCount;
     }
 
     public void setAdditionalRowCount( int additionalRowCount )
     {
         this.additionalRowCount = additionalRowCount;
     }
 
     public String getCurrentRowId()
     {
         String newId = renderSupport.allocateClientId( assignedClientId );
         return String.format( "%s_row_%s", assignedClientId, newId.toLowerCase() );
     }
 
     public String getCurrentPageFieldName()
     {
         return currentPageHidden.getClientId();
     }
 
     public String getAddedRowFieldName()
     {
         return addedRowHidden.getClientId();
     }
     
     private PagerConfig config;
 
     public PagerConfig getConfig()
     {
         return config;
     }
     
     public void setConfig( PagerConfig config )
     {
         this.config = config;
     }
 
     public String getDisplayStyle()
     {
         if ( getConfig() == null )
         {
             setConfig( internalPager.getConfig() );
         }
         PagerConfig config = getConfig();
         int availableRows = config.getRowCount() - config.getAdditionalRowCount() + config.getAddedRowCount();
 
         config.setMaxPages( ( ( availableRows - 1 ) / config.getRowsPerPage() ) + 1 );
 
         if ( config.getMaxPages() > 0 && config.getCurrentPage() > config.getMaxPages() )
         {
             config.setCurrentPage( config.getMaxPages() );
         }
 
         int startIndex = config.getRowsPerPage() * ( config.getCurrentPage() - 1 );
         int endIndex = startIndex + config.getRowsPerPage() - 1;
 
         if ( index >= startIndex && index <= endIndex
             && index < config.getRowCount() - config.getAdditionalRowCount() + config.getAddedRowCount() )
         {
             return "";
         }
         else
         {
             return "display:none;";
         }
     }
 
     @SetupRender
     Object setupRender()
     {
         currentPage = 1;
         assignedClientId = renderSupport.allocateClientId( clientId );
 
         if ( objectCreatorDelegate != null )
         {
             if ( null == addedRowsList ) addedRowsList = new ArrayList<Object>();
             for ( int i = 0; i < additionalRowCount ; i++ )
             {
                 Object object = objectCreatorDelegate.createObject();
                 addedRowsList.add( object );
             }
         }
 
         pagedSource = new ArrayList<Object>();
         if ( source != null ) pagedSource.addAll( source );
         if ( null != addedRowsList ) pagedSource.addAll( addedRowsList );
 
         // If there's no rows, display the empty block placeholder.
         if ( pagedSource.size() == 0 )
         {
             return empty;
         }
 
         return null;
     }
 
     Object beginRender()
     {
         environment.push( JSPagedLoop.class, this );
 
         // Skip rendering of component (template, body, etc.) when there's nothing to display.
         // The empty placeholder will already have rendered.
         return pagedSource.size() != 0;
 
     }
 
     void afterRender()
     {
         formSupport.storeAndExecute( this, new SetupAction( addedRowHidden.getControlName() ) );
         formSupport.store( this, FORM_SUBMIT_ACTION );
     }
 
     void cleanupRender()
     {
         environment.pop( JSPagedLoop.class );
     }
 
     void onActionFromAdd()
     {/*nothing*/}
 
     private void processFormAction()
     {
         int count = 0;
         String sCount = null;
         try
         {
             if ( addedRowCountHiddenName != null )
             {
                 sCount = request.getParameter( addedRowCountHiddenName );
                 if ( sCount != null && sCount.trim().length() > 0 )
                 {
                     count = Integer.parseInt( sCount.trim() );
                 }
             }
         }
         catch ( Exception e )
         {
             log.error( "Unable to parse AddedRowCount parameter: " + sCount );
         }
 
         if ( objectCreatorDelegate != null )
         {
             for ( int i = 0; i < count && i < addedRowsList.size() ; i++ )
             {
                 objectCreatorDelegate.addNewObject( addedRowsList.get( i ) );
             }
             addedRowsList.clear();
         }
         addedRowCount = count;
     }
 
     /**
      * Returns a unique id for the element. This value will be unique for any given rendering of a page. This value is
      * intended for use as the id attribute of the client-side element, and will be used with any DHTML/Ajax related
      * JavaScript.
      */
     public String getClientId()
     {
         return assignedClientId;
     }
 
     public String getFixedClientId()
     {
         return assignedClientId != null ? assignedClientId.toLowerCase() : "";
     }
 }