/*
 *  Copyright 2012 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.plugins.calendar.events;

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.joda.time.DateTime;
import org.joda.time.Interval;
import org.joda.time.format.ISODateTimeFormat;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.repository.Content;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.parameter.ParameterHelper.ParameterType;

/**
 * Helper class that provides a method to check if a date is between two others.
 */
public final class EventHelper implements LogEnabled, Serviceable
{    
    /** The Ametys object resolver */
    protected static AmetysObjectResolver _resolver;
    /** The extension point for content types */
    protected static ContentTypeExtensionPoint _contentTypeEP;
    
    private static Logger _logger;

    @Override
    public void enableLogging(Logger logger)
    {
        _logger = logger;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
    }
    
    /**
     * Tests if the given date is either:
     * - equal to the first, if there is no end date.
     * - between the two dates, if there is a start and end date.
     * @param dateStr the date to test.
     * @param startStr start of the interval.
     * @param endStr end of the interval.
     * @return true if the date is either equal to the start date or between the start and end date.
     */
    public static boolean isBetween(String dateStr, String startStr, String endStr)
    {
        boolean between = false;
        
        DateTime date = ISODateTimeFormat.date().parseDateTime(dateStr);
        DateTime start = ISODateTimeFormat.date().parseDateTime(startStr);
        
        if (StringUtils.isBlank(endStr))
        {
            between = date.equals(start);
        }
        else
        {
            DateTime end = ISODateTimeFormat.date().parseDateTime(endStr);
            between = (date.isAfter(start) || date.equals(start)) && (date.isBefore(end) || date.equals(end));
        }
        
        return between;
    }
    
    /**
     * Tests if the given event occurs in the given month.
     * @param monthStartStr The month first day, cannot be null or blank.
     * @param eventStartStr The event start date, can be null or blank only if the end date is set.
     * @param eventEndStr The event end date, can be null or blank only if the end date is set.
     * @return true if the event occurs in the given month.
     */
    public static boolean inMonth(String monthStartStr, String eventStartStr, String eventEndStr)
    {
        boolean overlaps = false;
        
        DateTime monthStart = new DateTime(ParameterHelper.castValue(monthStartStr, ParameterType.DATE));
        DateTime monthEnd = monthStart.withDayOfMonth(1).withMillisOfDay(0).plusMonths(1);
        Interval month = new Interval(monthStart, monthEnd);
        
        if (StringUtils.isNotBlank(eventStartStr) && StringUtils.isNotBlank(eventEndStr))
        {
            DateTime eventStart = new DateTime(ParameterHelper.castValue(eventStartStr, ParameterType.DATE));
            DateTime eventEnd = new DateTime(ParameterHelper.castValue(eventEndStr, ParameterType.DATE));
            
            // check that start is before end to avoid an unwanted exception
            try
            {
                // If eventStart equals to eventEnd and equals to monthStart, month#overlaps(Interval) will return false. In our case, we want to consider it actually does.
                overlaps = eventStartStr.equals(eventEndStr) ? month.contains(eventStart) 
                                                             : month.overlaps(new Interval(eventStart, eventEnd));
            }
            catch (IllegalArgumentException e)
            {
                // The end is before the start
                overlaps = false;
                _logger.error(String.format("Invalid dates of event: the end date (%s) must be greater or equal to the start date (%s). The event will be ignored in calendar view.", eventEndStr, eventStartStr), e);
            }
        }
        else if (StringUtils.isNotBlank(eventStartStr))
        {
            DateTime date = new DateTime(ParameterHelper.castValue(eventStartStr, ParameterType.DATE));
            overlaps = month.contains(date);
        }
        else if (StringUtils.isNotBlank(eventEndStr))
        {
            DateTime date = new DateTime(ParameterHelper.castValue(eventEndStr, ParameterType.DATE));
            overlaps = month.contains(date);
        }
        
        return overlaps;
    }
    
    /**
     * Tests if the given date is either:
     * @param dateStr the date to test.
     * @return true if the date is either equal to the start date or between the start and end date.
     */
    public static String nextDay(String dateStr)
    {
        DateTime date = ISODateTimeFormat.dateTime().parseDateTime(dateStr);
        
        return ISODateTimeFormat.dateTime().print(date.plusDays(1));
    }
    
    /**
     * Tests if the given date is either:
     * @param dateStr the date to test.
     * @param format the format ("date" or "basicDate").
     * @return true if the date is either equal to the start date or between the start and end date.
     */
    public static String nextDay(String dateStr, String format)
    {
        String nextDayStr = "";
        
        DateTime date = ISODateTimeFormat.dateTime().parseDateTime(dateStr);
        
        DateTime nextDay = date.plusDays(1);
        
        if ("basicDate".equals(format))
        {
            nextDayStr = ISODateTimeFormat.basicDate().print(nextDay);
        }
        else
        {
            nextDayStr = ISODateTimeFormat.date().print(nextDay);
        }
        
        return nextDayStr;
    }
    
    /**
     * Tests if the given metadata for the given content is of type {@link MetadataType#DATETIME}
     * @param contentId The id of the content
     * @param metadataName The metadata name
     * @return true if the given metadata for the given content is of type {@link MetadataType#DATETIME}
     */
    public static boolean isDatetime(String contentId, String metadataName)
    {
        Content content = _resolver.resolveById(contentId);
        String[] cTypes = content.getTypes();
        
        for (String cTypeId : cTypes)
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            
            if (cType.hasMetadataDefinition(metadataName))
            {
                MetadataDefinition metadataDef = cType.getMetadataDefinition(metadataName);
                MetadataType type = metadataDef.getType();
                
                return MetadataType.DATETIME.equals(type);
            }
        }
        
        return false;
    }
}