/**
    * Copyright 2005-2008 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.control.action;
  
  import org.figure8.join.control.JoinAction;
  import org.figure8.join.control.form.MailingListForm;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.reporting.Event;
  import org.figure8.join.businessobjects.reporting.MailingList;
  import org.figure8.join.businessobjects.reporting.Subscription;
  import org.figure8.join.businessfacades.reporting.ReportingManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.util.List;
  import java.util.HashMap;
  import java.util.ArrayList;
  import java.util.Iterator;
  /**
   * This is a Struts action for managing Mailing lists and their subscriptions.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   *
   * @struts.action path="/mailingList" name="mailingListForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/mailinglists.jsp"
   * @struts.action-forward name="MailingLists" path="/jsp/mailinglists.jsp"
   * @struts.action-forward name="Subscriptions" path="/jsp/subscriptions.jsp"
   */
  public class MailingListActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger */
     private static final Log log = LogUtil.getLog(MailingListActions.class);
  
     /** Operation code for loading a specified MailingList */
     public static final String LOAD_OP = "load";
     /** Operation code for saving (create or update) a MailingList */
     public static final String SAVE_OP = "save";
     /** Operation code for removing a MailingList (subscriptions are removed as well) */
     public static final String REMOVE_OP = "remove";
     /** Operation code for user subscribing to a MailingList */
     public static final String SUBSCRIBE_OP = "subscribe";
     /** Operation code for getting a user subscriptions to MailingLists */
     public static final String SUBSCRIPTIONS_OP = "subscriptions";
  
     /**
      * The session attribute key used for storing a specified MailingList
      * for later update.
      */
     public static final String MAILING_LIST_KEY = "mailingList";
     /**
      * The request scope attribute under which the retrieved mailing list
      * list is stored.
      */
     public static final String MAILING_LISTS_KEY = "mailingLists";
     /**
      * The request scope attribute under which the retrieved subscriptions
      * list is stored.
      */
     public static final String SUBSCRIPTIONS_KEY = "subscriptions";
     /**
      * The request scope attribute under which is stored the MailingList that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_MAILING_LIST_KEY = "duplicate";
  
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The Reporting manager implementation to use */
     protected ReportingManager reportingManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
    /** Creates a new instance of MailingListActions */
    public MailingListActions(){
    }
 
 
    // Public -------------------------------------------------------------------
 
    /** @param manager The ReportingManager implementation to use */
    public void setReportingManager(ReportingManager manager){
       this.reportingManager = manager;
    }
 
 
    // Implementation of JoinAction ---------------------------------------------
 
    /**
     * @param operation String representing the operation to invoke on Action
     * @param mapping Mapping between forwards name and path for this action
     * @param form The form object containing request parameters
     * @param request The servlet container request wrapper
     * @param response The servlet container response wrapper
     * @return A forward to the next view to render and display
     * @throws Exception such as InfraStructureExceptions ...
     */
    public ActionForward doExecute(String operation, ActionMapping mapping, ActionForm form,
                                   HttpServletRequest request, HttpServletResponse response)
            throws Exception{
 
       // Trace operation to execute.
       log.debug("doExecute() called for '" + operation + "' operation");
 
       if (form instanceof MailingListForm){
          // Get the mailing list form and existing lists.
          MailingListForm mForm = (MailingListForm)form;
 
          // Route to protected method depending on operation.
          if (LOAD_OP.equals(operation)){
             return loadMailingList(mapping, mForm, request, response);
          }
          else if (SAVE_OP.equals(operation)){
             return saveMailingList(mapping, mForm, request, response);
          }
          else if (SUBSCRIBE_OP.equals(operation)){
             return subscribeMailingLists(mapping, mForm, request, response);
          }
          else if (SUBSCRIPTIONS_OP.equals(operation)){
             return getSubscriptions(mapping, mForm, request, response);
          }
          else{
             // Add events if form is requested.
             if ("true".equals(request.getParameter("showForm")))
                request.setAttribute("events", reportingManager.getEvents());
             // Default : empty mailing lists management page.
             request.getSession().removeAttribute(MAILING_LIST_KEY);
             request.setAttribute(MAILING_LISTS_KEY, reportingManager.getMailingLists());
             return mapping.findForward("MailingLists");
          }
       }
       // This should not happen...
       return null;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified mailing list into request attribute for update.
     * @return A forward to the next view to render and display.
     */
    protected ActionForward loadMailingList(ActionMapping mapping, MailingListForm form,
                                            HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Retrieve what we need in form.
       request.setAttribute("events", reportingManager.getEvents());
       request.setAttribute(MAILING_LISTS_KEY, reportingManager.getMailingLists());
 
       // Get the requested mailing list.
       log.debug("Retrieving mailing list '" + form.getName() + "' from reporting manager");
       MailingList list = reportingManager.getMailingList(form.getName());
       // Copy list into the form properties.
       PropertyUtils.copyProperties(form, list);
       form.setEventKey(list.getEvent().getKey());
       form.setResourceId(list.getResourceId());
 
       // Store into session attribute before forwarding.
       HttpSession session = request.getSession();
       session.setAttribute(MAILING_LIST_KEY, list);
       return mapping.findForward("MailingLists");
    }
 
    /**
     * Save a mailing list within datastore (this is a create or update method).
     * @return A forward to the next view to render and display.
     */
    protected ActionForward saveMailingList(ActionMapping mapping, MailingListForm form,
                                            HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Is there a mailing list to update in session ?
       HttpSession session = request.getSession();
       MailingList list = (MailingList)session.getAttribute(MAILING_LIST_KEY);
 
       // Create a new mailing list or populate existing with form.
       if (list == null){
          log.info("Creation of a new MailingList with name: " + form.getName());
          Event event = reportingManager.getEvent(form.getEventKey());
          list = new MailingList(form.getName(), form.getMsgTitleTemplate(), form.getMsgContentTemplate(), event);
          // Specialize event for a resource if specified.
          if (form.getResourceId() != null) list.setResourceId(form.getResourceId());
       }
       else{
          log.info("Update of existing MailingList having name: " + form.getName());
          PropertyUtils.copyProperties(list, form);
       }
       // Save the mailing list before forwarding.
       try {reportingManager.saveMailingList(list);}
       catch (DuplicateEntityException dee){
          // Store exception within request.
          request.setAttribute(DUPLICATE_MAILING_LIST_KEY, dee.getOriginalEntity());
       }
       // Retrieve existing mailing lists before forwarding.
       request.setAttribute(MAILING_LISTS_KEY, reportingManager.getMailingLists());
       return mapping.findForward("MailingLists");
    }
 
    /**
     * Subscribe a user to a set of MailingLists.
     * @return A forward to the next view to render and display.
     */
    protected ActionForward subscribeMailingLists(ActionMapping mapping, MailingListForm form,
                                                  HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Prepare a list of selected mailing lists.
       List lists = new ArrayList();
 
       // Browse available lists to find selected ones.
       Iterator subscribedLists = form.getSubscribedLists().keySet().iterator();
       while (subscribedLists.hasNext()){
          // Get corresponding mailing list domain object.
          String listName = (String)subscribedLists.next();
          MailingList list = reportingManager.getMailingList(listName);
 
          // Add this list to the subscribed lists if selected.
          if (list != null && "on".equals(form.getSubscribedList(listName)))
             lists.add(list);
       }
       // Subscribe user before forwarding.
       reportingManager.susbcribeUser(form.getUserId(), lists);
       return new ActionForward("/action/user?op=load&login=" + form.getUserId());
    }
 
    /**
     * Retrieve subscription for a given list or for a given user.
     * @return A forward to the next view to render and display.
     */
    protected ActionForward getSubscriptions(ActionMapping mapping, MailingListForm form,
                                             HttpServletRequest request, HttpServletResponse response)
            throws Exception{
 
       if (form.getName() != null){
          // Get the subscriptions of a given mailing list.
          MailingList list = reportingManager.getMailingList(form.getName());
          request.setAttribute(MAILING_LIST_KEY, list);
          request.setAttribute(SUBSCRIPTIONS_KEY, list.getSubscriptions());
       }
       else if (form.getUserId() != null){
          log.info("Retrieving subscriptions for user: " + form.getUserId());
          // Get the subscriptions of a given user and fill form.
          List subscriptions = reportingManager.getSubscriptionsForUser(form.getUserId());
          for (int i=0; i<subscriptions.size(); i++){
             Subscription subscription = (Subscription)subscriptions.get(i);
             form.setSubscribedList(subscription.getMailingList().getName(), "on");
          }
          // Get the available mailing lists and organize them using Event.
          HashMap eventMap = new HashMap();
          List lists = reportingManager.getMailingLists();
          for (int i=0; i<lists.size(); i++){
             MailingList list = (MailingList)lists.get(i);
             ArrayList eventLists = (ArrayList)eventMap.get(list.getEvent());
             // Add list within this event mailing lists.
             if (eventLists == null)
                eventLists = new ArrayList();
             eventLists.add(list);
             eventMap.put(list.getEvent(), eventLists);
          }
          request.setAttribute(MAILING_LISTS_KEY, eventMap);
       }
       // Forward to subscriptions screen.
       return mapping.findForward("Subscriptions");
    }
 }