/*
   Copyright 2010 James Pether Sörling Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. 
   	$Id
   */
   package com.hack23.cia.web.controller.common;
   
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
   import org.springframework.transaction.annotation.Propagation;
  import org.springframework.transaction.annotation.Transactional;
  
  import com.hack23.cia.service.api.application.ApplicationManager;
  import com.hack23.cia.service.api.common.AbstractServiceRequest;
  import com.hack23.cia.service.api.common.AbstractServiceResponse;
  import com.hack23.cia.service.api.common.ApplicationErrorRequest;
  import com.hack23.cia.service.api.common.ErrorResponse;
  import com.hack23.cia.service.api.common.ServiceRequest;
  import com.hack23.cia.service.api.common.ServiceResponse;
  import com.hack23.cia.service.api.common.ServiceResponse.ServiceResult;
  import com.hack23.cia.web.action.common.AbstractAction;
  import com.hack23.cia.web.action.common.ControllerAction;
  import com.hack23.cia.web.common.UserState;
  import com.hack23.cia.web.viewfactory.api.common.ErrorMessageModelAndView;
  import com.hack23.cia.web.viewfactory.api.common.ModelAndView;
  import com.hack23.cia.web.viewfactory.api.common.ViewFactoryService;
  import com.hack23.cia.web.viewfactory.api.common.ErrorMessageModelAndView.ErrorViewSpecification;
  
  /***
   * The Class AbstractGenericHandler.
   *
   * @param <ACTION> the generic type
   * @param <REQUEST> the generic type
   * @param <RESPONSE> the generic type
   */
  @Transactional(propagation = Propagation.REQUIRED)
  public abstract class AbstractGenericHandler<ACTION extends AbstractAction, REQUEST extends AbstractServiceRequest, RESPONSE extends AbstractServiceResponse>
          implements ActionHandler {
  
      /*** The Constant LOGGER. */
      private static final Log LOGGER = LogFactory
              .getLog(AbstractGenericHandler.class);
  
      /*** The application manager. */
      private final ApplicationManager applicationManager;
  
      /*** The user state service. */
      private UserStateService userStateService = new UserStateService() {
  
          @Override
          public Long getUserSessionId() {
          		return UserState.getId().get();
          }
  
          @Override
          public void setUserSessionId(final Long userSessionId) {
          		UserState.getId().set(userSessionId);
          }
      };
  
      /*** The view factory service. */
      private ViewFactoryService viewFactoryService;
  
      /***
       * Instantiates a new abstract generic handler.
       *
       * @param viewFactoryService the view factory service
       * @param applicationManager the application manager
       */
      public AbstractGenericHandler(final ViewFactoryService viewFactoryService,
              final ApplicationManager applicationManager) {
          super();
          this.viewFactoryService = viewFactoryService;
          this.applicationManager = applicationManager;
      }
  
      /***
       * Creates the service request.
       *
       * @param action the action
       * @return the rEQUEST
       */
      public abstract REQUEST createServiceRequest(final ACTION action);
  
      /***
       * Gets the application manager.
       *
       * @return the application manager
       */
      public final ApplicationManager getApplicationManager() {
          return applicationManager;
      }
  
      /***
       * Gets the user state service.
       *
       * @return the user state service
       */
      public final UserStateService getUserStateService() {
          return this.userStateService;
     }
 
     /***
      * Gets the view factory service.
      *
      * @return the view factory service
      */
     public final ViewFactoryService getViewFactoryService() {
         return viewFactoryService;
     }
 
     /***
      * Handle error response.
      *
      * @param action the action
      * @param errorResponse the error response
      * @return the model and view
      */
     protected final ModelAndView handleErrorResponse(
             final ControllerAction action, final ErrorResponse errorResponse) {
         ModelAndView modelAndView;
         modelAndView = new ErrorMessageModelAndView(errorResponse
                 .getUserSessionDTO(), action,
                 ErrorViewSpecification.ErrorMessageView, errorResponse
                         .getErrorMessage());
         return modelAndView;
     }
 
     /***
      * Handle success response.
      *
      * @param action the action
      * @param response the response
      * @return the model and view
      */
     public abstract ModelAndView handleSuccessResponse(final ACTION action,
             final RESPONSE response);
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * com.hack23.cia.web.controller.ActionHandler#processAction(com.hack23.
      * cia.web.action.ControllerAction)
      */
     @Override
 	@SuppressWarnings("unchecked")
     public final void processAction(final ControllerAction action) {
         LOGGER.info("processAction : " + action.getActionCategory() + " :"
                 + action.getClass().getSimpleName());
                 
         ModelAndView modelAndView = null;
 
         final ServiceRequest serviceRequest = createServiceRequest((ACTION) action);
         ServiceResponse serviceResponse = getApplicationManager().service(
                 serviceRequest);
         
         if (serviceResponse == null) {
             final ApplicationErrorRequest applicationErrorRequest = new ApplicationErrorRequest(userStateService.getUserSessionId(),new StackTraceElement[0], "Missing service response: " + serviceRequest.getClass().getSimpleName());
             serviceResponse = getApplicationManager().service(applicationErrorRequest);            
         }        
         
         getUserStateService().setUserSessionId(
                 serviceResponse.getUserSessionDTO().getUserSession().getId());
 
         if (serviceResponse.getResult().equals(ServiceResult.SUCCESS)) {
             modelAndView = handleSuccessResponse((ACTION) action,
                     (RESPONSE) serviceResponse);
         } else {
             modelAndView = handleErrorResponse(action,
                     (ErrorResponse) serviceResponse);
         }
 
         processModelAndView(modelAndView);
     }
 
     /***
      * Process model and view.
      *
      * @param modelAndView the model and view
      */
     protected final void processModelAndView(final ModelAndView modelAndView) {
     		viewFactoryService.processView(modelAndView);    			
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * com.hack23.cia.web.controller.common.ActionHandler#setUserStateService
      * (com.hack23.cia.web.controller.common.UserStateService)
      */
     @Override
 	public final void setUserStateService(
             final UserStateService userStateService) {
         this.userStateService = userStateService;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * com.hack23.cia.web.controller.common.ActionHandler#setViewFactoryService
      * (com.hack23.cia.web.viewfactory.api.common.ViewFactoryService)
      */
     @Override
 	public final void setViewFactoryService(
             final ViewFactoryService viewFactoryService) {
         this.viewFactoryService = viewFactoryService;
     }
 
 }