/*
    * Copyright (c) 2002-2022, City of 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.workflow.modules.actionsbatch.web;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.validation.ConstraintViolation;
  
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.lang3.StringUtils;
  
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.node.ArrayNode;
  import com.fasterxml.jackson.databind.node.ObjectNode;
  
  import fr.paris.lutece.api.user.User;
  import fr.paris.lutece.plugins.workflow.modules.actionsbatch.task.ActionsBatchTaskConfig;
  import fr.paris.lutece.plugins.workflow.web.task.NoFormTaskComponent;
  import fr.paris.lutece.plugins.workflowcore.business.action.Action;
  import fr.paris.lutece.plugins.workflowcore.business.action.ActionFilter;
  import fr.paris.lutece.plugins.workflowcore.business.config.ITaskConfig;
  import fr.paris.lutece.plugins.workflowcore.business.state.State;
  import fr.paris.lutece.plugins.workflowcore.service.action.ActionService;
  import fr.paris.lutece.plugins.workflowcore.service.action.IActionService;
  import fr.paris.lutece.plugins.workflowcore.service.task.ITask;
  import fr.paris.lutece.portal.service.admin.AdminUserService;
  import fr.paris.lutece.portal.service.message.AdminMessage;
  import fr.paris.lutece.portal.service.message.AdminMessageService;
  import fr.paris.lutece.portal.service.spring.SpringContextService;
  import fr.paris.lutece.portal.service.template.AppTemplateService;
  import fr.paris.lutece.portal.service.util.AppException;
  import fr.paris.lutece.portal.service.workflow.WorkflowService;
  import fr.paris.lutece.portal.web.constants.Messages;
  import fr.paris.lutece.util.ReferenceItem;
  import fr.paris.lutece.util.ReferenceList;
  import fr.paris.lutece.util.beanvalidation.BeanValidationUtil;
  import fr.paris.lutece.util.html.HtmlTemplate;
  
  /**
   * ActionsBatchTaskComponent Class
   * 
   * @author MDP,ACN
   *
   */
  public class ActionsBatchTaskComponent extends NoFormTaskComponent
  {
      // MARKERS
      private static final String MARK_WORKFLOWS = "workflow_list";
      private static final String MARK_STATUS = "status_list";
      private static final String MARK_ACTION = "action_list";
      private static final String MARK_RESOURCE_TYPE = "resource_type";
  
      // PARAMETERS
      private static final String PARAM_STATUS = "state";
      private static final String PARAM_ACTION = "action";
      private static final String PARAM_WORKFLOW = "workflow";
      private static final String PARAM_RESOURCE_TYPE = "resource_type";
  
      // TEMPLATES
      private static final String TEMPLATE_TASK_DEMANDE_MASS_ACTION_CONFIG = "admin/plugins/workflow/modules/actionsbatch/actionsbatch_task_config.html";
      private static final String MARK_WORKFLOW_ACTIONS = "json_workflow_actions";
     private static final String MARK_WORKFLOW_ID = "workflow_id";
     private static final String MARK_STATE_ID = "state_id";
     private static final String MARK_ACTION_ID = "action_id";
 
     @Override
     public String getDisplayConfigForm( HttpServletRequest request, Locale locale, ITask task )
     {
         User user = AdminUserService.getAdminUser( request );
         if ( user == null )
         {
             throw new AppException( "Access Denied" );
         }
 
         // service
         IActionService _actionService = SpringContextService.getBean( ActionService.BEAN_SERVICE );
 
         // model
         final Map<String, Object> model = new HashMap<>( );
 
         // get config
         final ActionsBatchTaskConfig config = findTaskConfig( task.getId( ) );
 
         // get enabled workflow list
         final ReferenceList workflowsRefList = WorkflowService.getInstance( ).getWorkflowsEnabled( user, locale );
 
         // remove first blank item
         workflowsRefList.remove( 0 );
 
         // get all available states and actions
         Map<String, Collection<State>> mapStates = new HashMap<>( );
         Map<String, List<Action>> mapActions = new HashMap<>( );
 
         for ( ReferenceItem workflowItem : workflowsRefList )
         {
             // STATES
             Collection<State> workflowStates = WorkflowService.getInstance( ).getAllStateByWorkflow( Integer.valueOf( workflowItem.getCode( ) ), user );
 
             // put in global map
             mapStates.put( workflowItem.getCode( ), workflowStates );
 
             // ACTIONS
             for ( State state : workflowStates )
             {
 
                 // get actions
                 final ActionFilter filter = new ActionFilter( );
                 filter.setIdStateBefore( state.getId( ) );
                 final List<Action> stateActions = _actionService.getListActionByFilter( filter );
 
                 // put in map
                 mapActions.put( String.valueOf( state.getId( ) ), stateActions );
             }
         }
 
         model.put( MARK_WORKFLOW_ACTIONS, getJsonActions( workflowsRefList, mapStates, mapActions ) );
 
         model.put( MARK_WORKFLOW_ID, config.getIdWorkflow( ) );
         model.put( MARK_STATE_ID, config.getIdState( ) );
         model.put( MARK_ACTION_ID, config.getIdAction( ) );
         model.put( MARK_RESOURCE_TYPE, config.getResourceType( ) );
 
         final HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_TASK_DEMANDE_MASS_ACTION_CONFIG, locale, model );
         return template.getHtml( );
     }
 
     @Override
     public String validateConfig( ITaskConfig config, HttpServletRequest request )
     {
         String workflow = request.getParameter( PARAM_WORKFLOW );
         String status = request.getParameter( PARAM_STATUS );
         String action = request.getParameter( PARAM_ACTION );
         String resourceType = request.getParameter( PARAM_RESOURCE_TYPE );
 
         if ( StringUtils.isBlank( workflow ) || StringUtils.isBlank( status ) || StringUtils.isBlank( action ) || StringUtils.isBlank( resourceType ) )
         {
             return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
         }
         else
             if ( config instanceof ActionsBatchTaskConfig )
             {
                 final ActionsBatchTaskConfig/../fr/paris/lutece/plugins/workflow/modules/actionsbatch/task/ActionsBatchTaskConfig.html#ActionsBatchTaskConfig">ActionsBatchTaskConfig taskConfig = (ActionsBatchTaskConfig) config;
                 taskConfig.setIdWorkflow( Integer.parseInt( workflow ) );
                 taskConfig.setIdState( Integer.parseInt( status ) );
                 taskConfig.setIdAction( Integer.parseInt( action ) );
                 taskConfig.setResourceType( resourceType );
 
                 // Check mandatory fields
                 Set<ConstraintViolation<ITaskConfig>> constraintViolations = BeanValidationUtil.validate( taskConfig );
 
                 if ( CollectionUtils.isNotEmpty( constraintViolations ) )
                 {
                     return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
                 }
             }
 
         return StringUtils.EMPTY;
     }
 
     /**
      * get config
      * 
      * @param id
      *            id Config
      * @return ActionsBatchTaskConfig
      */
     private ActionsBatchTaskConfig findTaskConfig( int id )
     {
         final ActionsBatchTaskConfig config = this.getTaskConfigService( ).findByPrimaryKey( id );
         return config == null ? new ActionsBatchTaskConfig( ) : config;
     }
 
     @Override
     public String getDisplayTaskInformation( int pNIdHistory, HttpServletRequest pRequest, Locale pLocale, ITask pTask )
     {
         return null;
     }
 
     /**
      * generate Json for cascade selects in template
      * 
      * example : {"workflows":[{"id":1, "name":"dotation", "states":[{"id":12, "name":"statut11", "actions":[{"id":111, "name": "action111"}, ...
      * 
      * @param workflowsRefList
      * @param mapStates
      * @param mapActions
      * @return json
      */
     private String getJsonActions( ReferenceList workflowsRefList, Map<String, Collection<State>> mapStates, Map<String, List<Action>> mapActions )
     {
         ObjectMapper mapper = new ObjectMapper( );
         ObjectNode root = mapper.createObjectNode( );
 
         ArrayNode jsonWfList = mapper.createArrayNode( );
         for ( ReferenceItem workflowItem : workflowsRefList )
         {
             ObjectNode jsonWf = mapper.createObjectNode( );
             jsonWf.put( "id", workflowItem.getCode( ) );
             jsonWf.put( "name", workflowItem.getName( ) );
 
             ArrayNode jsonStatesList = mapper.createArrayNode( );
             for ( State state : mapStates.get( workflowItem.getCode( ) ) )
             {
                 ObjectNode jsonState = mapper.createObjectNode( );
                 jsonState.put( "id", state.getId( ) );
                 jsonState.put( "name", state.getName( ) );
 
                 ArrayNode jsonActionsList = mapper.createArrayNode( );
                 for ( Action action : mapActions.get( String.valueOf( state.getId( ) ) ) )
                 {
                     ObjectNode jsonAction = mapper.createObjectNode( );
                     jsonAction.put( "id", action.getId( ) );
                     jsonAction.put( "name", action.getName( ) );
 
                     jsonActionsList.add( jsonAction );
                 }
 
                 jsonState.set( "actions", jsonActionsList );
                 jsonStatesList.add( jsonState );
             }
 
             jsonWf.set( "states", jsonStatesList );
             jsonWfList.add( jsonWf );
         }
 
         root.set( "workflows", jsonWfList );
 
         return root.toPrettyString( );
     }
 }