/*
    * Copyright 2008-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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.
   */
  package de.smartics.maven.issues.repository;
  
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeSet;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.maven.reporting.MavenReportException;
  import org.codehaus.plexus.util.StringUtils;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.core.runtime.IStatus;
  import org.eclipse.core.runtime.NullProgressMonitor;
  import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
  import org.eclipse.mylyn.commons.net.AuthenticationType;
  import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
  import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
  import org.eclipse.mylyn.tasks.core.TaskRepository;
  import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
  import org.eclipse.mylyn.tasks.core.data.TaskData;
  import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
  import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
  
  import de.smartics.maven.issues.IssueManagementConfig;
  import de.smartics.maven.issues.QueryData;
  import de.smartics.maven.issues.RepositoryFacade;
  import de.smartics.maven.issues.ResourceLocator;
  import de.smartics.maven.issues.cache.TaskDataCache;
  
  /**
   * Base implementation of the {@link RepositoryFacade} interface.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public abstract class AbstractRepositoryFacade implements RepositoryFacade
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private final Log log = LogFactory.getLog(AbstractRepositoryFacade.class);
  
    /**
     * The configuration for the issue management connection.
     */
    protected final IssueManagementConfig config;
  
    /**
     * The connector to use to connect to the remote issue management system.
     */
    protected final AbstractRepositoryConnector connector;
  
    /**
     * The reference to the repository.
     */
    protected TaskRepository repository;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param config the configuration for the issue management connection.
     * @param connector the connector to use to connect to the remote issue
     *          management system.
     */
    protected AbstractRepositoryFacade(final IssueManagementConfig config,
        final AbstractRepositoryConnector connector)
    {
      this.config = config;
      this.connector = connector;
      this.repository = createRepository();
   }
 
   // ****************************** Inner Classes *****************************
 
   /**
    * A simple collector that accepts every task data and adds them to the task
    * list.
    */
   private static final class SimpleTaskDataCollector extends TaskDataCollector
   {
     /**
      * The list of accepted tasks.
      */
     private final List<TaskData> tasks = new ArrayList<TaskData>();
 
     /**
      * Returns the list of accepted tasks.
      *
      * @return the list of accepted tasks.
      */
     public List<TaskData> getTasks()
     {
       return tasks;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * No filtering: Accepts every task.
      * </p>
      *
      * @see org.eclipse.mylyn.tasks.core.data.TaskDataCollector#accept(org.eclipse.mylyn.tasks.core.data.TaskData)
      */
     @Override
     public void accept(final TaskData taskData)
     {
       tasks.add(taskData);
     }
 
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   /**
    * Creates and configures the access to the issues management repository.
    *
    * @return the configured issue management repository.
    */
   private TaskRepository createRepository()
   {
     final TaskRepository newRepository =
         new TaskRepository(config.getIssueManagementId(),
             config.getConnectionUrl());
     newRepository.setProperty(TaskRepository.PROXY_USEDEFAULT, "false");
 
     final String repositoryVersion = config.getRepositoryVersion();
     if (StringUtils.isNotBlank(repositoryVersion))
     {
       newRepository.setVersion(repositoryVersion);
     }
 
     setAuthenicationInformation(newRepository);
     return newRepository;
   }
 
   /**
    * Sets the authentication information for the given repository.
    *
    * @param repository the repository the authenication information is provided
    *          for.
    */
   private void setAuthenicationInformation(final TaskRepository repository)
   {
     final String webUser = config.getWebUser();
     final String webPassword = config.getWebPassword();
 
     if (StringUtils.isNotBlank(webUser) && StringUtils.isNotBlank(webPassword))
     {
       if (log.isTraceEnabled())
       {
         log.trace("Setting web credentials '" + webUser + "' with password '"
                   + StringUtils.repeat("*", webPassword.length()) + "'.");
       }
       final AuthenticationCredentials credentials =
           new AuthenticationCredentials(webUser, webPassword);
       repository.setCredentials(AuthenticationType.HTTP, credentials, false);
     }
 
     final String issueManagementUser = config.getIssueManagementUser();
     final String issueManagementPassword = config.getIssueManagementPassword();
     if (StringUtils.isNotBlank(issueManagementUser)
         && StringUtils.isNotBlank(issueManagementPassword))
     {
       if (log.isTraceEnabled())
       {
         log.trace("Setting repository credentials '" + issueManagementUser
                   + "' with password '"
                   + StringUtils.repeat("*", issueManagementPassword.length())
                   + "'.");
       }
       final AuthenticationCredentials credentials =
           new AuthenticationCredentials(issueManagementUser,
               issueManagementPassword);
 
       repository.setCredentials(AuthenticationType.REPOSITORY, credentials,
           false);
     }
   }
 
   /**
    * Simple method to sleep a given period of time before a connection retry.
    * The timeout in milliseconds is defined in {@link #config}.
    */
   private void sleep()
   {
     try
     {
       Thread.sleep(config.getTimeout());
     }
     catch (final InterruptedException e)
     {
       // just continue;
     }
   }
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   public AbstractRepositoryConnector getConnector()
   {
     return connector;
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.maven.issues.RepositoryFacade#queryTasks(QueryData)
    */
   public List<TaskData> queryTasks(final QueryData queryData)
     throws MavenReportException
   {
     final SimpleTaskDataCollector collector = new SimpleTaskDataCollector();
     runQuery(queryData, collector);
     return fetchTaskData(collector);
   }
 
   /**
    * Runs the query for matching tasks. The result is contained in the hit
    * collector.
    *
    * @param queryData the information to construct a query against the remote
    *          issue management system.
    * @param collector the collector to run the query and contain the hits.
    * @throws MavenReportException if a problem is encountered while fetching the
    *           tasks from the remote repository.
    */
   private void runQuery(final QueryData queryData,
       final SimpleTaskDataCollector collector) throws MavenReportException
   {
     if (log.isDebugEnabled())
     {
       log.debug("Searching for matching bugs...");
     }
 
     final int maxRetries = config.getMaxRetries();
     final boolean ignoreLogoutProblem = config.isIgnoreLogoutProblem();
     final IRepositoryQuery query = constructQuery(queryData);
 
     if (log.isDebugEnabled())
     {
       log.debug("Connecting to " + query.getUrl() + " (max retries "
                 + maxRetries + ")...");
     }
     final IProgressMonitor monitor = new NullProgressMonitor();
     for (int tryNumber = 0; tryNumber <= maxRetries; tryNumber++)
     {
       final IStatus status =
           connector.performQuery(repository, query, collector, createSession(),
               monitor);
 
       if (log.isTraceEnabled())
       {
         log.trace("Query performed with status '" + status + "'.");
       }
 
       if (shouldBreak(status, ignoreLogoutProblem, maxRetries, tryNumber))
       {
         checkException(query, status);
         break;
       }
     }
 
     if (log.isTraceEnabled())
     {
       log.trace("Collected " + collector.getTasks().size() + " issues.");
     }
 
   }
 
   /**
    * Checks if an exception should be thrown.
    *
    * @param query the query that was running.
    * @param status the status returned from running the query.
    * @throws MavenReportException if the status signals that this exception is
    *           required to be raised.
    */
   private void checkException(final IRepositoryQuery query, final IStatus status)
     throws MavenReportException
   {
     if (status.getSeverity() == IStatus.ERROR)
     {
       final MavenReportException e =
           new MavenReportException("Problem connecting to '" + query.getUrl()
                                    + "': " + status.getMessage());
       e.initCause(status.getException());
       throw e;
     }
   }
 
   /**
    * We are called from within a loop making retries on connection problems.
    * This method checks if we should continue with the next loop iteration or
    * not.
    *
    * @param status the status returned by the query from the issue management
    *          system.
    * @param ignoreLogoutProblem <code>true</code> if logout problems should be
    *          ignored in which case we will break in case of a logout problem.
    *          <code>false</code> if logout problems should be treated as any
    *          other problems where we wait a short period and retry, returning
    *          <code>false</code> as to not break.
    * @param maxRetries the number of maximum retries.
    * @param tryNumber the current try.
    * @return <code>true</code> if we should stop iterating, <code>false</code>
    *         if we should give the issue management system another try.
    * @throws MavenReportException if the maximum number of tries is exceeded and
    *           the last error message returned from the issue management system
    *           is to be returned.
    */
   private boolean shouldBreak(final IStatus status,
       final boolean ignoreLogoutProblem, final int maxRetries,
       final int tryNumber) throws MavenReportException
   {
     if (status.getSeverity() == IStatus.ERROR)
     {
       final boolean logoutProblem = isLogoutProblem(status);
       if (!logoutProblem || !ignoreLogoutProblem)
       {
         retry(status, maxRetries, tryNumber);
         return false;
       }
     }
     return true;
   }
 
   /**
    * Checks if the status signals a logout problem. Logout problems may be
    * treated differently depending on the configuration. Subclasses are
    * responsible to check if the status is reporting a logout problem or not.
    *
    * @param status the status returned from the issue management system.
    * @return <code>true</code> if this is a logout problem, <code>false</code>
    *         otherwise. If unsure, subclasses should return <code>false</code>.
    */
   protected abstract boolean isLogoutProblem(IStatus status);
 
   /**
    * Retry if <code>maxRetries</code> is not exceeded after a short break
    * (sleep).
    *
    * @param status the status returned by the query from the issue management
    *          system.
    * @param maxRetries the number of maximum retries.
    * @param tryNumber the current try.
    * @throws MavenReportException if the maximum number of tries is exceeded.
    */
   private void retry(final IStatus status, final int maxRetries,
       final int tryNumber) throws MavenReportException
   {
     final String statusMessage = status.getMessage();
     if (tryNumber == maxRetries)
     {
       throw new MavenReportException(statusMessage,
           (Exception) status.getException());
     }
     else
     {
       if (log.isWarnEnabled())
       {
         log.warn("Connection (retry # " + tryNumber + "): " + statusMessage);
       }
       sleep();
     }
   }
 
   /**
    * Returns a session.
    *
    * @return <code>null</code> since sessions are not necessary to run the
    *         query, but may be relevant to subclasses.
    */
   protected ISynchronizationSession createSession()
   {
     return null;
   }
 
   /**
    * Upon the hits provided by the collector we fetch additional information we
    * are interested in for each task.
    *
    * @param hitCollector the collector with hits.
    * @return the task information to render in the report.
    * @throws MavenReportException if a problem is encountered while fetching the
    *           tasks from the remote repository.
    */
   private List<TaskData> fetchTaskData(
       final SimpleTaskDataCollector hitCollector) throws MavenReportException
   {
     final TaskDataCache taskDataCache =
         ResourceLocator.getInstance().getTaskDataCache();
 
     final boolean logColumns = config.isLogColumns();
     final Set<String> columnIds = logColumns ? new HashSet<String>() : null;
     final int maxEntries = config.getMaxEntries();
     final int maxRetries = config.getMaxRetries();
     final List<TaskData> issues = new ArrayList<TaskData>(128);
     try
     {
       int taskCounter = 0;
       for (TaskData minimallyFilledTask : hitCollector.getTasks())
       {
         if (isQuit(maxEntries, taskCounter))
         {
           logQuitting(maxEntries);
           break;
         }
 
         final String taskId = minimallyFilledTask.getTaskId();
         logIssueId(taskId);
 
         final TaskData completeTaskData =
             fetchTaskData(taskDataCache, minimallyFilledTask, maxRetries);
         if (completeTaskData != null)
         {
           addLogColumns(columnIds, completeTaskData);
           issues.add(completeTaskData);
           taskCounter++;
         }
       }
     }
     catch (CoreException e)
     {
       throw new MavenReportException(e.getMessage(), e);
     }
 
     if (logColumns)
     {
       log.info("Attribute IDs: " + new TreeSet<String>(columnIds));
     }
 
     return issues;
   }
 
   /**
    * Logs the issue ID at trace level.
    *
    * @param taskId the task ID to log.
    */
   private void logIssueId(final String taskId)
   {
     if (log.isTraceEnabled())
     {
       log.trace("Retrieving issue: " + taskId);
     }
   }
 
   /**
    * Logs that the query is quitting.
    *
    * @param maxEntries the max entries that have been fetched.
    */
   private void logQuitting(final int maxEntries)
   {
     if (log.isDebugEnabled())
     {
       log.debug("Quitting fetching tasks after task " + maxEntries + '.');
     }
   }
 
   /**
    * Adds the task attribute IDs (used to log columns hence the name of the
    * method) to the given set.
    *
    * @param columnIds the set of IDs to add the new ones to. If value is
    *          <code>null</code> nothing is logged.
    * @param taskData the task whose attributes are to be logged.
    */
   private void addLogColumns(final Set<String> columnIds,
       final TaskData taskData)
   {
     if (columnIds != null)
     {
       final TaskAttribute root = taskData.getRoot();
       final Map<String, TaskAttribute> attributes = root.getAttributes();
       final Set<String> attributeIds = attributes.keySet();
       columnIds.addAll(attributeIds);
     }
   }
 
   /**
    * Checks if max entries have been read and reading should quit.
    *
    * @param maxEntries the maximum number of issues to be read.
    * @param taskCounter the current number of issues already read.
    * @return <code>true</code> if reading should quit, false if reading should
    *         continue.
    */
   private static boolean isQuit(final int maxEntries, final int taskCounter)
   {
     return maxEntries != -1 && taskCounter >= maxEntries;
   }
 
   /**
    * Fetches the completely filled task for the minimally filled task.
    *
    * @param taskDataCache the cache to retrieve task information from.
    * @param minimallyFilledTask the task for which the complete information is
    *          requested.
    * @param maxRetries the maximum retries to launch on connection problems
    *          before giving up.
    * @return the completely filled task.
    * @throws CoreException if the task cannot be fetched.
    */
   private TaskData fetchTaskData(final TaskDataCache taskDataCache,
       final TaskData minimallyFilledTask, final int maxRetries)
     throws CoreException
   {
     for (int tryNumber = 0; tryNumber <= maxRetries; tryNumber++)
     {
       try
       {
         final TaskData completeTaskData =
             readAndCacheTaskData(taskDataCache, minimallyFilledTask);
         return completeTaskData;
       }
       catch (final CoreException e)
       {
         if (tryNumber == maxRetries)
         {
           throw e;
         }
         else
         {
           if (log.isWarnEnabled())
           {
             log.warn("Connection (retry # " + tryNumber + "): "
                      + e.getMessage());
           }
           sleep();
         }
       }
     }
     if (log.isWarnEnabled())
     {
       log.warn("No information for task " + minimallyFilledTask.getTaskId()
                + "' can be retrieved. Omitting this bug from the report.");
     }
     return null;
   }
 
   /**
    * Fetches the bug from the cache and, on a cache-miss, requests the bug
    * information from the remote issue management system.
    *
    * @param taskDataCache the cache to fetch bugs from and store new bugs in.
    * @param task the task to fetch additional task data.
    * @return the task data for the given task.
    * @throws CoreException if the task cannot be fetched.
    */
   private TaskData readAndCacheTaskData(final TaskDataCache taskDataCache,
       final TaskData task) throws CoreException
   {
     final String id = task.getTaskId();
     TaskData taskData = taskDataCache.getTask(id);
     if (taskData == null)
     {
       taskData =
           connector.getTaskData(repository, id, new NullProgressMonitor());
       taskDataCache.addTask(taskData);
       if (log.isTraceEnabled())
       {
         log.trace("  Cache miss for bug " + id + '.');
       }
     }
     return taskData;
   }
 
   /**
    * Constructs the query upon the <code>queryData</code>. Since the query is
    * dependent on the issue management system in use, this method is to be
    * implemented by subclasses.
    *
    * @param queryData the issue management independent representation of the
    *          query.
    * @return the query to execute to fetch the specified task data.
    * @throws MavenReportException if the query data is invalid to create a issue
    *           management specific query.
    */
   protected abstract IRepositoryQuery constructQuery(QueryData queryData)
     throws MavenReportException;
 
   // --- object basics --------------------------------------------------------
 
 }