/*
 *  Copyright 2011 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.cms.workflow.purge;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Timer;
import java.util.TimerTask;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.LogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang.StringUtils;

import org.ametys.runtime.config.Config;

/**
 * Purge contents scheduler: launches a cron which purges contents at a given periodicity.
 */
public class PurgeContentsScheduler extends TimerTask implements Initializable, LogEnabled, Serviceable, Disposable, Contextualizable, Configurable
{
    
    /** The default period, in days. */
    private static final long _DEFAULT_PERIOD = 7;
    
    /** The service manager. */
    protected ServiceManager _manager;
    
    /** The component configuration. */
    protected Configuration _configuration;
    
    /** The avalon context. */
    protected Context _context;
    
    /** The logger. */
    protected Logger _logger;
    
    /** The timer. */
    protected Timer _timer;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _configuration = configuration;
    }
    
    @Override
    public void enableLogging(Logger logger)
    {
        _logger = logger;
    }
    
    @Override
    public void initialize() throws Exception
    {
        if (_logger.isDebugEnabled())
        {
            _logger.debug("Initializing the alert scheduler...");
        }
        
        Boolean enabled = Config.getInstance().getValue("purge.scheduler.enabled");
        
        if (enabled != null && enabled)
        {
            Long periodDays = Config.getInstance().getValue("purge.scheduler.period");
            if (periodDays == null)
            {
                periodDays = _DEFAULT_PERIOD;
            }
            String hourStr = Config.getInstance().getValue("purge.scheduler.hour");
            
            // Schedule a timer to run at the given hour, each defined period.
            int hour = 0;
            int minute = 0;
            if (StringUtils.isNotEmpty(hourStr) && hourStr.indexOf(':') > 0)
            {
                String[] hourArray = StringUtils.split(hourStr, ':');
                hour = Integer.parseInt(hourArray[0]);
                minute = Integer.parseInt(hourArray[1]);
            }
            
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.set(Calendar.AM_PM, hour < 12 ? Calendar.AM : Calendar.PM);
            calendar.set(Calendar.HOUR, hour % 12);
            calendar.set(Calendar.MINUTE, minute);
            calendar.set(Calendar.SECOND, 0);
            calendar.set(Calendar.MILLISECOND, 0);
            
//            calendar.add(Calendar.MINUTE, 1);
            
            // Each day.
            long period = periodDays * 24 * 3600 * 1000;
            Date firstTime = calendar.getTime();
    
            Date now = new Date();
    
            // If the given time today is past, schedule for tomorrow.
            if (firstTime.compareTo(now) < 0)
            {
                calendar.add(Calendar.DAY_OF_MONTH, 1);
                firstTime = calendar.getTime();
            }
            
            if (_logger.isInfoEnabled())
            {
                _logger.info("Purge contents scheduler: the purge engine will run every " + periodDays + " days, starting " + firstTime.toString());
            }
            
            _timer = new Timer("PurgeContents", true);
            _timer.schedule(this, firstTime, period);
        }
    }
    
    @Override
    public void run()
    {
        PurgeContentsEngine purgeContentsEngine = new PurgeContentsEngine();
        
        try
        {
            // Initialize and configure the engine.
            purgeContentsEngine.initialize(_manager, _context);
            purgeContentsEngine.configure(_configuration);
        }
        catch (Exception e)
        {
            throw new RuntimeException("Unable to initialize the alerts engine", e);
        }
        
        // The thread will be started as daemon, as the scheduler is marked daemon itself.
        new Thread(purgeContentsEngine, "PurgeContentsEngine").start();
    }
    
    @Override
    public void dispose()
    {
        _context = null;
        _logger = null;
        _manager = null;
        _configuration = null;
        
        cancel();
        if (_timer != null)
        {
            _timer.cancel();
            _timer = null;
        }
    }
    
}