/*
    * 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.digglike.business;
  
  import fr.paris.lutece.plugins.digglike.service.CommentSubmitService;
  import fr.paris.lutece.plugins.digglike.service.search.DigglikeIndexer;
  import fr.paris.lutece.plugins.digglike.utils.DiggIndexerUtils;
  import fr.paris.lutece.portal.business.indexeraction.IndexerAction;
  import fr.paris.lutece.portal.service.plugin.Plugin;
  import fr.paris.lutece.portal.service.search.IndexationService;
  import fr.paris.lutece.portal.service.spring.SpringContextService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  
  import java.util.ArrayList;
  import java.util.List;
  
  
  /**
   *class FormSubmitHome
   */
  public final class DiggSubmitHome
  {
      // Static variable pointed at the DAO instance
      private static IDiggSubmitDAO _dao = SpringContextService.getBean( "digglike.diggSubmitDAO" );
  
      /**
       * Private constructor - this class need not be instantiated
       */
      private DiggSubmitHome(  )
      {
      }
  
      /**
       * Creation of an instance of diggSubmit
       *
       * @param diggSubmit The instance of the diggSubmit which contains the informations to store
       * @param plugin the Plugin
       * @return the id of the new digg submit
       *
       */
      public static int create( DiggSubmit diggSubmit, Plugin plugin )
      {
          return _dao.insert( diggSubmit, plugin );
      }
  
      /**
       * Update of the diggSubmit which is specified in parameter
       *
       * @param diggSubmit The instance of the diggSubmit which contains the informations to update
       * @param plugin the Plugin
       *
       */
      public static void update( DiggSubmit diggSubmit, Plugin plugin )
      {
          update( diggSubmit, true, plugin );
      }
  
      /**
       * Update of the diggSubmit which is specified in parameter
       * @param diggSubmit The digg submit
       * @param bUpdateIndex The update index
       * @param plugin The plugin
       */
      public static void update( DiggSubmit diggSubmit, boolean bUpdateIndex, Plugin plugin )
      {
          if ( bUpdateIndex )
          {
              DiggSubmit diggSubmitStored = findByPrimaryKey( diggSubmit.getIdDiggSubmit(  ), plugin );
 
             //if state has changed
             if ( diggSubmit.getDiggSubmitState(  ).getIdDiggSubmitState(  ) != diggSubmitStored.getDiggSubmitState(  )
                                                                                                    .getIdDiggSubmitState(  ) )
             {
                 String strIdDiggSubmit = Integer.toString( diggSubmit.getIdDiggSubmit(  ) );
 
                 if ( diggSubmit.getDiggSubmitState(  ).getIdDiggSubmitState(  ) == DiggSubmit.STATE_PUBLISH )
                 {
                     DiggIndexerUtils.addIndexerAction( strIdDiggSubmit, IndexerAction.TASK_CREATE );
                 }
                 else
                 {
                     DiggIndexerUtils.addIndexerAction( strIdDiggSubmit, IndexerAction.TASK_DELETE );
                 }
             }
 
             IndexationService.addIndexerAction( Integer.toString( diggSubmit.getIdDiggSubmit(  ) ),
                 AppPropertiesService.getProperty( DigglikeIndexer.PROPERTY_INDEXER_NAME ), IndexerAction.TASK_MODIFY );
         }
 
         _dao.store( diggSubmit, plugin );
     }
 
     /**
      * Remove the DiggSubmit whose identifier is specified in parameter
      *
      * @param nIdDiggSubmit The diggSubmitId
      * @param plugin the Plugin
      */
     public static void remove( int nIdDiggSubmit, Plugin plugin )
     {
         SubmitFilter filter = new SubmitFilter(  );
         filter.setIdDiggSubmit( nIdDiggSubmit );
 
         List<Response> listResponses = ResponseHome.getResponseList( filter, plugin );
 
         for ( Response response : listResponses )
         {
             if ( response.getIdImageResource(  ) != null )
             {
                 ImageResourceHome.remove( response.getIdImageResource(  ), plugin );
             }
 
             ResponseHome.remove( response.getIdResponse(  ), plugin );
         }
 
         List<CommentSubmit> listComments = CommentSubmitService.getService(  ).getCommentSubmitList( filter, plugin );
 
         for ( CommentSubmit comment : listComments )
         {
             CommentSubmitService.getService(  ).remove( comment.getIdCommentSubmit(  ), plugin );
         }
 
         //remove all reported associated to the digg submit
         ReportedMessageHome.removeByDiggSubmit( nIdDiggSubmit, plugin );
 
         DiggSubmit diggSubmit = DiggSubmitHome.findByPrimaryKey( nIdDiggSubmit, plugin );
 
         if ( diggSubmit.getDiggSubmitState(  ).getIdDiggSubmitState(  ) == DiggSubmit.STATE_PUBLISH )
         {
             String strIdDiggSubmit = Integer.toString( nIdDiggSubmit );
             IndexationService.addIndexerAction( strIdDiggSubmit + "_" + DigglikeIndexer.SHORT_NAME,
                 AppPropertiesService.getProperty( DigglikeIndexer.PROPERTY_INDEXER_NAME ), IndexerAction.TASK_DELETE );
 
             DiggIndexerUtils.addIndexerAction( strIdDiggSubmit, IndexerAction.TASK_DELETE );
         }
 
         _dao.delete( nIdDiggSubmit, plugin );
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // Finders
 
     /**
      * Returns an instance of a DiggSubmit whose identifier is specified in parameter
      *
      * @param nKey The diggSubmit primary key
      * @param bLoadCommentList true if the comment list must be get
      * @param plugin the Plugin
      * @return an instance of DiggSubmit
      */
     public static DiggSubmit findByPrimaryKey( int nKey, Plugin plugin )
     {
         DiggSubmit diggSubmit = _dao.load( nKey, plugin );
 
         if ( diggSubmit != null )
         {
             if ( diggSubmit.getDiggSubmitType(  ) != null )
             {
                 diggSubmit.setDiggSubmitType( DiggSubmitTypeHome.findByPrimaryKey( 
                         diggSubmit.getDiggSubmitType(  ).getIdType(  ), plugin ) );
             }
 
             if ( diggSubmit.getCategory(  ) != null )
             {
                 diggSubmit.setCategory( CategoryHome.findByPrimaryKey( diggSubmit.getCategory(  ).getIdCategory(  ),
                         plugin ) );
             }
         }
 
         return diggSubmit;
     }
 
     /**
      * Load the data of all the diggSubmit who verify the filter and returns them in a  list
      * @param filter the filter
      * @param plugin the plugin
      * @return  the list of diggSubmit
      */
     public static List<DiggSubmit> getDiggSubmitList( SubmitFilter filter, Plugin plugin )
     {
         List<DiggSubmit> listDiggSubmit = _dao.selectListByFilter( filter, plugin );
 
         if ( listDiggSubmit != null )
         {
             SubmitFilter submmitFilterComment = new SubmitFilter(  );
 
             for ( DiggSubmit diggSubmit : listDiggSubmit )
             {
                 submmitFilterComment.setIdDiggSubmit( diggSubmit.getIdDiggSubmit(  ) );
                 submmitFilterComment.setIdCommentSubmitState( CommentSubmit.STATE_ENABLE );
                 diggSubmit.setComments( CommentSubmitService.getService(  )
                                                             .getCommentSubmitList( submmitFilterComment, plugin ) );
 
                 if ( diggSubmit.getDiggSubmitType(  ) != null )
                 {
                     diggSubmit.setDiggSubmitType( DiggSubmitTypeHome.findByPrimaryKey( 
                             diggSubmit.getDiggSubmitType(  ).getIdType(  ), plugin ) );
                 }
 
                 if ( diggSubmit.getCategory(  ) != null )
                 {
                     diggSubmit.setCategory( CategoryHome.findByPrimaryKey( 
                             diggSubmit.getCategory(  ).getIdCategory(  ), plugin ) );
                 }
             }
         }
 
         return listDiggSubmit;
     }
 
     /**
      * Load the id of all the diggSubmit who verify the filter and returns them in a  list
      * @param filter the filter
      * @param plugin the plugin
      * @return  the list of diggSubmit id
      */
     public static List<Integer> getDiggSubmitListId( SubmitFilter filter, Plugin plugin )
     {
         return _dao.selectIdListByFilter( filter, plugin );
     }
 
     /**
      * Load the data of all the diggSubmit who verify the filter and returns them in a  list
      * @param filter the filter
      * @param plugin the plugin
      * @param nNumberMaxDiggSubmit Max Number of Diggsubmit return
      * @return  the list of diggSubmit
      */
     public static List<DiggSubmit> getDiggSubmitList( SubmitFilter filter, Plugin plugin, int nNumberMaxDiggSubmit )
     {
         List<Integer> diggSubmitListId = getDiggSubmitListId( filter, plugin );
         List<DiggSubmit> diggSubmitList = new ArrayList<DiggSubmit>(  );
         DiggSubmit diggSubmit = null;
         Object[] diggSubmitArrayId = diggSubmitListId.toArray(  );
 
         for ( int cpt = 0; cpt < diggSubmitArrayId.length; cpt++ )
         {
             if ( cpt < nNumberMaxDiggSubmit )
             {
                 diggSubmit = findByPrimaryKey( (Integer) diggSubmitArrayId[cpt], plugin );
 
                 if ( diggSubmit != null )
                 {
                     diggSubmitList.add( diggSubmit );
                 }
             }
             else
             {
                 break;
             }
         }
 
         return diggSubmitList;
     }
 
     /**
      * Load the number of all the diggSubmit who verify the filter
      * @param filter the filter
      * @param plugin the plugin
      * @return  the list of diggSubmit
      */
     public static int getCountDiggSubmit( SubmitFilter filter, Plugin plugin )
     {
         return _dao.selectCountByFilter( filter, plugin );
     }
 
     /**
      * Update the number order of diggSubmit
      * @param nIdDiggSubmit the id of the diggSubmit
      * @param nNewOrder the new number of order
      * @param plugin The Plugin object
      */
     public static void updateDiggSubmitOrder( int nNewOrder, int nIdDiggSubmit, Plugin plugin )
     {
         _dao.storeDiggSubmitOrder( nNewOrder, nIdDiggSubmit, plugin );
     }
 
     /**
      * Search the max order number of contacts for one list
      * @param nIdDigg the Id of the Digg
      * @return int the max order
      * @param plugin The Plugin object
      */
     public static int getMaxOrderList( int nIdDigg, boolean bListPinned, Plugin plugin )
     {
         return _dao.maxOrderDiggSubmit( nIdDigg, bListPinned, plugin );
     }
 }