/*
 *  Copyright 2013 Anyware Services
 *
 *  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 org.ametys.web.cache.monitoring.process.statistics;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.joda.time.Duration;
import org.joda.time.format.PeriodFormat;

import org.ametys.core.datasource.AbstractMyBatisDAO;
import org.ametys.web.cache.monitoring.Constants;
import org.ametys.web.cache.monitoring.process.statistics.impl.FrontFromHTTPServerResourceStatisticsFactory;
import org.ametys.web.cache.monitoring.process.statistics.impl.FrontOnlyResourceStatisticsFactory;
import org.ametys.web.cache.monitoring.process.statistics.impl.HTTPServerOnlyResourceStatisticsFactory;
import org.ametys.web.cache.monitoring.process.statistics.impl.PageElementResourceStatisticsFactory;
import org.ametys.web.cache.monitoring.process.statistics.impl.PageResourceStatisticsFactory;

/**
 * The cache monitoring updater. It updates the statistics in the monitoring database, given the new request entries.
 */
public class ResourceStatisticsComponent extends AbstractMyBatisDAO
{
    /** Avalon ROLE. */
    public static final String ROLE = ResourceStatisticsComponent.class.getName();
    
    /**
     * Update the cache statistics tables.
     */
    public void updateStatistics()
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Updating cache stats tables...");
        }
        
        long start = System.currentTimeMillis();
        int totalUpdated = 0;
        
        totalUpdated += _update("page", PageResourceStatisticsFactory.getInstance());
        totalUpdated += _update("pageElements", PageElementResourceStatisticsFactory.getInstance());
        totalUpdated += _update("frontOnly", FrontOnlyResourceStatisticsFactory.getInstance());
        totalUpdated += _update("httpServerOnly", HTTPServerOnlyResourceStatisticsFactory.getInstance());
        totalUpdated += _update("frontFromHTTPServer", FrontFromHTTPServerResourceStatisticsFactory.getInstance());
        
        if (getLogger().isDebugEnabled())
        {
            String durationStr = PeriodFormat.getDefault().print(new Duration(System.currentTimeMillis() - start).toPeriod());
            getLogger().debug(String.format("\tTotal count of new request log that have been processed : %s", totalUpdated));
            getLogger().debug(String.format("Update of the cache stats tables took %s", durationStr));
        }
    }
    
    private int _update(String logName, ResourceStatisticsFactory factory)
    {
        int processed = 0;
        
        try (SqlSession sqlSession = getSession())
        {
            // Retrieves resources to process + update cache stats
            List<ResourceStatistics> resourceStatisticsList = factory.getResourceAccessToProcess(sqlSession);
            int hits = _updateCacheStats(sqlSession, resourceStatisticsList);
            
            // Mark handled resource access as processed
            if (resourceStatisticsList.size() > 0)
            {
                processed = factory.markResourcesAsProcessed(sqlSession);
            }
            
            // Commit the transaction.
            sqlSession.commit();
            
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug(String.format("It appears to be %s new hits for the ResourceStatistics '%s'. Also, %s access logs have been marked has processed.", hits, logName, processed));
            }
        }
        catch (Exception e)
        {
            getLogger().error("Exception during update cache stats", e);
        }
        
        return processed;
    }
    
    private int _updateCacheStats(SqlSession sqlSession, List<ResourceStatistics> resourceStatisticsList)
    {
        int hits = 0;
        
        for (ResourceStatistics resourceStatistics : resourceStatisticsList)
        {
            if (resourceStatistics.statExists(sqlSession))
            {
                resourceStatistics.updateStat(sqlSession);
            }
            else
            {
                resourceStatistics.createStat(sqlSession);
            }
            
            hits += resourceStatistics.getHits();
        }
        
        return hits;
    }
    
    /**
     * Purge the processed raw request entries.
     */
    public void purgeRawData()
    {
        long start = 0;
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Purging raw monitoring data...");
            start = System.currentTimeMillis();
        }
        
        int totalPurged = 0;
        try (SqlSession sqlSession = getSession())
        {
            totalPurged += PageResourceStatisticsFactory.getInstance().purgeRawData(sqlSession);
            totalPurged += PageElementResourceStatisticsFactory.getInstance().purgeRawData(sqlSession);
            totalPurged += FrontOnlyResourceStatisticsFactory.getInstance().purgeRawData(sqlSession);
            totalPurged += HTTPServerOnlyResourceStatisticsFactory.getInstance().purgeRawData(sqlSession);
            totalPurged += FrontFromHTTPServerResourceStatisticsFactory.getInstance().purgeRawData(sqlSession);
            
            // Commit the transaction.
            sqlSession.commit();
        }
        catch (Exception e)
        {
            getLogger().error("An error occured while purging raw monitoring data", e);
        }

        if (getLogger().isDebugEnabled())
        {
            String durationStr = PeriodFormat.getDefault().print(new Duration(System.currentTimeMillis() - start).toPeriod());
            getLogger().debug(String.format("%s row purged from the database in %s", totalPurged, durationStr));
        }
    }
    
    /**
     * Get the raw data for the page elements cache statistics.
     * @return A list a map, each map representing a page stat entry
     */
    public List<Map<String, Object>> getPageElementCacheStats()
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "CacheMonitoringStatistics.getPageElementCacheStats";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tableNamePage", Constants.SQL_TABLE_NAME_PAGE_STATISTICS);
            params.put("tableNamePageElements", Constants.SQL_TABLE_NAME_PAGE_ELEMENTS_STATISTICS);
            
            return sqlSession.selectList(stmtId, params);
        }
    }
    
    /**
     * Get the raw data for the server cache statistics.
     * @param siteName The name of the site for which data will be extracted
     * @return A list a map, each map representing a raw stat entry
     */
    public List<Map<String, Object>> getServerCacheStats(String siteName)
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "CacheMonitoringStatistics.getServerCacheStats";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tableNameHttpFront", Constants.SQL_TABLE_NAME_HTTPSERVER_AND_FRONT_STATISTICS);
            params.put("tableNamePage", Constants.SQL_TABLE_NAME_PAGE_STATISTICS);
            
            params.put("siteName", siteName);
            
            return sqlSession.selectList(stmtId, params);
        }
    }
}