package org.apache.archiva.metadata.repository.stats;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import org.apache.archiva.metadata.repository.MetadataRepository;
  import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  import org.apache.archiva.metadata.repository.RepositorySession;
  import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  import org.apache.archiva.metadata.repository.stats.model.DefaultRepositoryStatistics;
  import org.apache.archiva.metadata.repository.stats.model.RepositoryStatistics;
  import org.apache.archiva.metadata.repository.stats.model.RepositoryStatisticsManager;
  import org.apache.archiva.metadata.repository.stats.model.RepositoryStatisticsProvider;
  import org.apache.archiva.metadata.repository.stats.model.RepositoryWalkingStatisticsProvider;
  import org.apache.commons.lang3.time.StopWatch;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.stereotype.Service;
  
  import javax.inject.Inject;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Date;
  import java.util.List;
  import java.util.TimeZone;
  
  /**
   *
   */
  @Service("repositoryStatisticsManager#default")
  public class DefaultRepositoryStatisticsManager
      implements RepositoryStatisticsManager
  {
      private static final Logger log = LoggerFactory.getLogger( DefaultRepositoryStatisticsManager.class );
  
      private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
  
      private RepositoryWalkingStatisticsProvideryWalkingStatisticsProvider.html#RepositoryWalkingStatisticsProvider">RepositoryWalkingStatisticsProvider walkingProvider = new RepositoryWalkingStatisticsProvider();
  
  
  
      @Inject
      RepositorySessionFactory repositorySessionFactory;
  
      @Override
      public boolean hasStatistics( String repositoryId )
          throws MetadataRepositoryException
      {
          try(RepositorySession session = repositorySessionFactory.createSession()) {
              final MetadataRepository metadataRepository = session.getRepository( );
              return metadataRepository.hasMetadataFacet(session, repositoryId, DefaultRepositoryStatistics.FACET_ID);
          }
      }
  
      @Override
      public RepositoryStatistics getLastStatistics( String repositoryId )
          throws MetadataRepositoryException
      {
          StopWatch stopWatch = new StopWatch();
          stopWatch.start();
          try(RepositorySession session = repositorySessionFactory.createSession()) {
              final MetadataRepository metadataRepository = session.getRepository( );
  
              // TODO: consider a more efficient implementation that directly gets the last one from the content repository
              List<String> scans = metadataRepository.getMetadataFacets(session, repositoryId, DefaultRepositoryStatistics.FACET_ID);
              if (scans == null) {
                  return null;
              }
              Collections.sort(scans);
              if (!scans.isEmpty()) {
                  String name = scans.get(scans.size() - 1);
                  RepositoryStatistics repositoryStatistics =
                          RepositoryStatistics.class.cast(metadataRepository.getMetadataFacet(session, repositoryId,
                                  RepositoryStatistics.FACET_ID, name));
                  stopWatch.stop();
                  log.debug("time to find last RepositoryStatistics: {} ms", stopWatch.getTime());
                  return repositoryStatistics;
              } else {
                  return null;
              }
          }
     }
 
     @Override
     public void addStatisticsAfterScan( String repositoryId, Date startTime,
                                         Date endTime, long totalFiles, long newFiles )
         throws MetadataRepositoryException
     {
         try(RepositorySession session = repositorySessionFactory.createSession()) {
             final MetadataRepository metadataRepository = session.getRepository( );
 
             DefaultRepositoryStatisticstRepositoryStatistics.html#DefaultRepositoryStatistics">DefaultRepositoryStatistics repositoryStatistics = new DefaultRepositoryStatistics();
             repositoryStatistics.setRepositoryId(repositoryId);
             repositoryStatistics.setScanStartTime(startTime);
             repositoryStatistics.setScanEndTime(endTime);
             repositoryStatistics.setTotalFileCount(totalFiles);
             repositoryStatistics.setNewFileCount(newFiles);
 
             // TODO
             // In the future, instead of being tied to a scan we might want to record information in the fly based on
             // events that are occurring. Even without these totals we could query much of the information on demand based
             // on information from the metadata content repository. In the mean time, we lock information in at scan time.
             // Note that if new types are later discoverable due to a code change or new plugin, historical stats will not
             // be updated and the repository will need to be rescanned.
 
             long startGather = System.currentTimeMillis();
 
             if (metadataRepository instanceof RepositoryStatisticsProvider) {
                 ((RepositoryStatisticsProvider) metadataRepository).populateStatistics(session,
                         metadataRepository, repositoryId, repositoryStatistics);
             } else {
                 walkingProvider.populateStatistics(session, metadataRepository, repositoryId, repositoryStatistics);
             }
 
             log.info("Gathering statistics executed in {} ms", (System.currentTimeMillis() - startGather));
 
             metadataRepository.addMetadataFacet(session, repositoryId, repositoryStatistics);
         }
     }
 
     @Override
     public void deleteStatistics( String repositoryId )
         throws MetadataRepositoryException
     {
         try(RepositorySession session = repositorySessionFactory.createSession()) {
             final MetadataRepository metadataRepository = session.getRepository( );
             metadataRepository.removeMetadataFacets(session, repositoryId, DefaultRepositoryStatistics.FACET_ID);
         }
     }
 
     @Override
     public List<RepositoryStatistics> getStatisticsInRange( String repositoryId,
                                                             Date startTime, Date endTime )
         throws MetadataRepositoryException
     {
         try(RepositorySession session = repositorySessionFactory.createSession()) {
             final MetadataRepository metadataRepository = session.getRepository( );
             List<RepositoryStatistics> results = new ArrayList<>();
             List<String> list = metadataRepository.getMetadataFacets(session, repositoryId, DefaultRepositoryStatistics.FACET_ID);
             Collections.sort(list, Collections.reverseOrder());
             for (String name : list) {
                 try {
                     Date date = createNameFormat().parse(name);
                     if ((startTime == null || !date.before(startTime)) && (endTime == null || !date.after(
                             endTime))) {
                         RepositoryStatistics stats =
                                 (RepositoryStatistics) metadataRepository.getMetadataFacet(session,
                                         repositoryId,
                                         DefaultRepositoryStatistics.FACET_ID, name);
                         results.add(stats);
                     }
                 } catch (ParseException e) {
                     log.error("Invalid scan result found in the metadata repository: {}", e.getMessage());
                     // continue and ignore this one
                 }
             }
             return results;
         }
     }
 
     private static SimpleDateFormat createNameFormat()
     {
         SimpleDateFormat fmt = new SimpleDateFormat( DefaultRepositoryStatistics.SCAN_TIMESTAMP_FORMAT );
         fmt.setTimeZone( UTC_TIME_ZONE );
         return fmt;
     }
 
     public RepositorySessionFactory getRepositorySessionFactory( )
     {
         return repositorySessionFactory;
     }
 
     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
     {
         this.repositorySessionFactory = repositorySessionFactory;
     }
 }