/*
 *  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 java.io.IOException;
import java.net.URLDecoder;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.joda.time.DateTime;
import org.joda.time.format.ISODateTimeFormat;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.filter.ContentFilterExtensionPoint;
import org.ametys.cms.repository.Content;
import org.ametys.cms.tag.Tag;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.web.filter.WebContentFilter;
import org.ametys.web.filter.WebContentFilter.AccessLimitation;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.ZoneItem;

/**
 * Query and generate news according to many parameters.
 */
public class EventsGenerator extends AbstractEventGenerator
{
    /** The ametys object resolver. */
    protected AmetysObjectResolver _ametysResolver;

    /** The filter extension point. */
    protected ContentFilterExtensionPoint _filterExtPt;

    /** The events helper */
    protected EventsFilterHelper _eventsFilterHelper;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _filterExtPt = (ContentFilterExtensionPoint) serviceManager.lookup(ContentFilterExtensionPoint.ROLE);
        _ametysResolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _eventsFilterHelper = (EventsFilterHelper) serviceManager.lookup(EventsFilterHelper.ROLE);
    }

    @Override
    public void generate() throws IOException, SAXException, ProcessingException
    {
        Request request = ObjectModelHelper.getRequest(objectModel);
        @SuppressWarnings("unchecked")
        Map<String, Object> parentContextAttrs = (Map<String, Object>) objectModel.get(ObjectModelHelper.PARENT_CONTEXT);
        if (parentContextAttrs == null)
        {
            parentContextAttrs = Collections.EMPTY_MAP;
        }

        DateTime today = new DateTime();

        // Get site and language in sitemap parameters. Can not be null.
        String siteName = parameters.getParameter("site", (String) request.getAttribute("site"));
        String lang = parameters.getParameter("lang", (String) request.getAttribute("renderingLanguage"));
        if (StringUtils.isEmpty(lang))
        {
            lang = (String) request.getAttribute("sitemapLanguage");
        }
        // Get the parameters.
        int monthsBefore = parameters.getParameterAsInteger("months-before", 3);
        int monthsAfter = parameters.getParameterAsInteger("months-after", 3);
        // Type can be "calendar", "single-day" or "agenda".
        String type = parameters.getParameter("type", "calendar");
        String view = parameters.getParameter("view", "");
        int year = parameters.getParameterAsInteger("year", today.getYear());
        int month = parameters.getParameterAsInteger("month", today.getMonthOfYear());
        int day = parameters.getParameterAsInteger("day", today.getDayOfMonth());
        // Select a single tag or "all".
        String singleTag = parameters.getParameter("tag", "all");
        if (StringUtils.isNotEmpty(singleTag) && !"all".equals(singleTag))
        {
            singleTag = singleTag.toUpperCase();
        }
        
        
        Page page = (Page) request.getAttribute(Page.class.getName());
        // Get the zone item, as a request attribute or from the ID in the
        // parameters.
        ZoneItem zoneItem = (ZoneItem) request.getAttribute(ZoneItem.class.getName());
        String zoneItemId = parameters.getParameter("zoneItemId", "");
        if (zoneItem == null && StringUtils.isNotEmpty(zoneItemId))
        {
            zoneItemId = URLDecoder.decode(zoneItemId, "UTF-8");
            zoneItem = (ZoneItem) _ametysResolver.resolveById(zoneItemId);
        }
        
        if (page == null && zoneItem != null)
        {
            // Wrapped page such as _plugins/calendar/page/YEAR/MONTH/DAY/ZONEITEMID/events_1.3.html => get the page from its zone item
            // The page is needed to get restriction
            page = zoneItem.getZone().getPage();
        }
        
        DateTime dateTime = new DateTime(year, month, day, 0, 0, 0, 0);
        String title = _eventsFilterHelper.getTitle(zoneItem);
        String rangeType = parameters.getParameter("rangeType", _eventsFilterHelper.getDefaultRangeType(zoneItem));
        boolean maskOrphan = _eventsFilterHelper.getMaskOrphan(zoneItem);
        AccessLimitation accessLimitation = _eventsFilterHelper.getAccessLimitation(zoneItem);
        boolean pdfDownload = _eventsFilterHelper.getPdfDownload(zoneItem);
        boolean icalDownload = _eventsFilterHelper.getIcalDownload(zoneItem);
        String link = _eventsFilterHelper.getLink(zoneItem);
        String linkTitle = _eventsFilterHelper.getLinkTitle(zoneItem);
        
        boolean doRetrieveView = !StringUtils.equalsIgnoreCase("false", parameters.getParameter("do-retrieve-view", "true"));

        // Get the content types to match
        Set<String> contentTypes = _eventsFilterHelper.getContentTypes(zoneItem);

        // Get the tags to match, from the zone item or from the parameters.
        String[] tagsArray = (String[]) parentContextAttrs.get("tags");
        Set<String> tags = _eventsFilterHelper.getTags(zoneItem, tagsArray);
        // Get the categories of the tags to match, from the zone item or from
        // the parameters.
        String[] tagCategoriesArray = (String[]) parentContextAttrs.get("tag-categories");
        Set<Tag> categories = _eventsFilterHelper.getTagCategories(zoneItem, siteName, tagCategoriesArray);
        // Get all tags belonging to the categories.
        Set<String> categoryTags = _eventsFilterHelper.getAllTags(categories);
        // Restrain the list to a single tag if provided.
        if (categoryTags.contains(singleTag) && StringUtils.isNotEmpty(singleTag) && !"all".equals(singleTag))
        {
            categoryTags = Collections.singleton(singleTag);
        }

        String pagePath = page != null ? page.getPathInSitemap() : "";

        // Get the declared events filter.
        EventsFilter eventsFilter = (EventsFilter) _filterExtPt.getExtension(EventsFilterHelper.EVENTS_FILTER_ID);

        // Get the date range and deduce the expression (single day or
        // month-before to month-after).
        EventsFilterHelper.DateRange dateRange = _eventsFilterHelper.getDateRange(type, year, month, day, monthsBefore, monthsAfter, rangeType);
        Expression expression = _eventsFilterHelper.getExpression(type, dateRange);

        // Configure the filter to return the wanted contents.
        _eventsFilterHelper.configureFilter(eventsFilter, expression, contentTypes, tags, categoryTags, view, maskOrphan, accessLimitation);

        // Get the corresponding contents.
        AmetysObjectIterable<Content> eventContents = eventsFilter.getMatchingContents(siteName, lang, page);

        AttributesImpl atts = new AttributesImpl();

        atts.addCDATAAttribute("page-path", pagePath);
        atts.addCDATAAttribute("today", ISODateTimeFormat.date().print(today));
        if (dateRange.getStartDate() != null)
        {
            atts.addCDATAAttribute("start", ISODateTimeFormat.date().print(new DateTime(dateRange.getStartDate())));
        }
        if (dateRange.getEndDate() != null)
        {
            atts.addCDATAAttribute("end", ISODateTimeFormat.date().print(new DateTime(dateRange.getEndDate())));
        }

        atts.addCDATAAttribute("year", Integer.toString(year));
        atts.addCDATAAttribute("month", String.format("%02d", month));
        atts.addCDATAAttribute("day", String.format("%02d", day));
        atts.addCDATAAttribute("months-before", Integer.toString(monthsBefore));
        atts.addCDATAAttribute("months-after", Integer.toString(monthsAfter));

        atts.addCDATAAttribute("title", title);
        atts.addCDATAAttribute("mask-orphan", Boolean.toString(maskOrphan));
        atts.addCDATAAttribute("pdf-download", Boolean.toString(pdfDownload));
        atts.addCDATAAttribute("ical-download", Boolean.toString(icalDownload));
        atts.addCDATAAttribute("link", link);
        atts.addCDATAAttribute("link-title", linkTitle);

        if (zoneItem != null)
        {
            atts.addCDATAAttribute("zoneItemId", zoneItem.getId());
        }
        if (StringUtils.isNotEmpty(rangeType))
        {
            atts.addCDATAAttribute("range", rangeType);
        }
        if (StringUtils.isNotEmpty(singleTag))
        {
            atts.addCDATAAttribute("single-tag", singleTag);
        }

        contentHandler.startDocument();
        XMLUtils.startElement(contentHandler, "events", atts);

        _saxRssUrl(zoneItem);

        // Generate months (used in calendar mode) and days (used in full-page
        // agenda mode).
        _saxMonths(dateRange);
        _saxDays(dateTime.toDate(), rangeType);

        _saxDaysNew(dateRange, rangeType);

        // Generate tags and categories.
        _saxTags(tags);
        _saxCategories(categories);

        // Generate the matching contents.
        XMLUtils.startElement(contentHandler, "contents");

        saxMatchingContents(contentHandler, eventsFilter, eventContents, page, doRetrieveView);

        XMLUtils.endElement(contentHandler, "contents");

        XMLUtils.endElement(contentHandler, "events");
        contentHandler.endDocument();
    }

    private void _saxRssUrl(ZoneItem zoneItem) throws SAXException 
    {
        if (zoneItem != null && zoneItem.getServiceParameters().getBoolean("rss", false))
        {
            // Split protocol and id
            String[] zoneItemId = zoneItem.getId().split("://");
            String url = "_plugins/calendar/" + zoneItemId[1] + "/rss.xml";
            
            XMLUtils.createElement(contentHandler, "rssUrl", url);
        }
    }
    
    /**
     * SAX all contents matching the given filter
     * 
     * @param handler The content handler to SAX into
     * @param filter The filter
     * @param contents iterator on the contents.
     * @param currentPage The current page.
     * @param saxContentItSelf true to sax the content, false will only sax some meta
     * @throws SAXException If an error occurs while SAXing
     * @throws IOException If an error occurs while retrieving content.
     */
    public void saxMatchingContents(ContentHandler handler, WebContentFilter filter, AmetysObjectIterable<Content> contents, Page currentPage, boolean saxContentItSelf) throws SAXException, IOException
    {
        boolean checkUserAccess = filter.getAccessLimitation() == AccessLimitation.USER_ACCESS;
        
        for (Content content : contents)
        {
            if (_filterHelper.isContentValid(content, currentPage, filter))
            {
                saxContent(handler, content, saxContentItSelf, filter, checkUserAccess);
            }
        }
    }

    /**
     * SAX information on the months spanning the date range.
     * @param dateRange the date range.
     * @throws SAXException if a error occurs while saxing
     */
    protected void _saxMonths(EventsFilterHelper.DateRange dateRange) throws SAXException
    {
        if (dateRange != null && dateRange.getStartDate() != null && dateRange.getEndDate() != null)
        {
            AttributesImpl atts = new AttributesImpl();

            XMLUtils.startElement(contentHandler, "months");

            DateTime date = new DateTime(dateRange.getStartDate());
            DateTime end = new DateTime(dateRange.getEndDate());

            while (date.isBefore(end))
            {
                int year = date.getYear();
                int month = date.getMonthOfYear();

                String monthStr = String.format("%d-%02d", year, month);
                String dateStr = ISODateTimeFormat.dateTime().print(date);

                atts.clear();
                atts.addCDATAAttribute("str", monthStr);
                atts.addCDATAAttribute("raw", dateStr);
                XMLUtils.startElement(contentHandler, "month", atts);

                XMLUtils.endElement(contentHandler, "month");

                date = date.plusMonths(1);
            }

            XMLUtils.endElement(contentHandler, "months");
        }
    }

    /**
     * Generate days to build a "calendar" view.
     * 
     * @param dateRange a date belonging to the time span to generate.
     * @param rangeType the range type, "month" or "week".
     * @throws SAXException if an error occurs while saxing
     */
    protected void _saxDaysNew(EventsFilterHelper.DateRange dateRange, String rangeType) throws SAXException
    {
        XMLUtils.startElement(contentHandler, "calendar-months");

        DateTime date = new DateTime(dateRange.getStartDate());
        DateTime end = new DateTime(dateRange.getEndDate());

        while (date.isBefore(end))
        {
            int year = date.getYear();
            int month = date.getMonthOfYear();

            String monthStr = String.format("%d-%02d", year, month);
            String dateStr = ISODateTimeFormat.dateTime().print(date);

            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("str", monthStr);
            attrs.addCDATAAttribute("raw", dateStr);
            attrs.addCDATAAttribute("year", Integer.toString(year));
            attrs.addCDATAAttribute("month", Integer.toString(month));
            XMLUtils.startElement(contentHandler, "month", attrs);

            _saxDays(date.toDate(), "month");

            XMLUtils.endElement(contentHandler, "month");

            date = date.plusMonths(1);
        }

        XMLUtils.endElement(contentHandler, "calendar-months");
    }

    /**
     * Generate days to build a "calendar" view.
     * 
     * @param date a date belonging to the time span to generate.
     * @param type the range type, "month" or "week".
     * @throws SAXException if an error occurs while saxing
     */
    protected void _saxDays(Date date, String type) throws SAXException
    {
        AttributesImpl attrs = new AttributesImpl();

        DateTime dateTime = new DateTime(date);

        int rangeStyle = DateUtils.RANGE_MONTH_MONDAY;
        DateTime previousDay = null;
        DateTime nextDay = null;

        // Week.
        if ("week".equals(type))
        {
            rangeStyle = DateUtils.RANGE_WEEK_MONDAY;

            // Get the first day of the week.
            previousDay = dateTime.dayOfWeek().withMinimumValue();
            // First day of next week.
            nextDay = previousDay.plusWeeks(1);
            // First day of previous week.
            previousDay = previousDay.minusWeeks(1);
        }
        else
        {
            rangeStyle = DateUtils.RANGE_MONTH_MONDAY;

            // Get the first day of the month.
            previousDay = dateTime.dayOfMonth().withMinimumValue();
            // First day of previous month.
            nextDay = previousDay.plusMonths(1);
            // First day of next month.
            previousDay = previousDay.minusMonths(1);
        }

        addNavAttributes(attrs, new DateTime(date), previousDay, nextDay);

        // Get an iterator on the days to be present on the calendar.
        Iterator<Calendar> days = DateUtils.iterator(date, rangeStyle);

        XMLUtils.startElement(contentHandler, "calendar", attrs);

        DateTime previousWeekDay = dateTime.minusWeeks(1);
        DateTime nextWeekDay = dateTime.plusWeeks(1);

        AttributesImpl weekAttrs = new AttributesImpl();
        addNavAttributes(weekAttrs, new DateTime(date), previousWeekDay, nextWeekDay);

        XMLUtils.startElement(contentHandler, "week", weekAttrs);

        while (days.hasNext())
        {
            Calendar dayCal = days.next();
            DateTime day = new DateTime(dayCal);
            String rawDateStr = ISODateTimeFormat.dateTime().print(day);
            String dateStr = ISODateTimeFormat.date().print(day);
            String yearStr = Integer.toString(dayCal.get(Calendar.YEAR));
            String monthStr = Integer.toString(dayCal.get(Calendar.MONTH) + 1);
            String dayStr = Integer.toString(dayCal.get(Calendar.DAY_OF_MONTH));

            AttributesImpl dayAttrs = new AttributesImpl();

            dayAttrs.addCDATAAttribute("raw", rawDateStr);
            dayAttrs.addCDATAAttribute("date", dateStr);
            dayAttrs.addCDATAAttribute("year", yearStr);
            dayAttrs.addCDATAAttribute("month", monthStr);
            dayAttrs.addCDATAAttribute("day", dayStr);

            XMLUtils.createElement(contentHandler, "day", dayAttrs);

            // Break on week on the last day of the week (but not on the last
            // week).
            if (dayCal.get(Calendar.DAY_OF_WEEK) == _eventsFilterHelper.getLastDayOfWeek(dayCal) && days.hasNext())
            {
                previousWeekDay = day.minusDays(6);
                nextWeekDay = day.plusDays(8);
                weekAttrs.clear();

                addNavAttributes(weekAttrs, day, previousWeekDay, nextWeekDay);

                XMLUtils.endElement(contentHandler, "week");
                XMLUtils.startElement(contentHandler, "week", weekAttrs);
            }
        }

        XMLUtils.endElement(contentHandler, "week");
        XMLUtils.endElement(contentHandler, "calendar");
    }

    /**
     * Add nav attributes.
     * 
     * @param attrs the attributes object to fill in.
     * @param current the current date.
     * @param previousDay the previous date.
     * @param nextDay the next date.
     */
    protected void addNavAttributes(AttributesImpl attrs, DateTime current, DateTime previousDay, DateTime nextDay)
    {
        attrs.addCDATAAttribute("current", ISODateTimeFormat.dateTime().print(current));

        attrs.addCDATAAttribute("previous", ISODateTimeFormat.dateTime().print(previousDay));
        attrs.addCDATAAttribute("previousYear", previousDay.year().getAsString());
        attrs.addCDATAAttribute("previousMonth", previousDay.monthOfYear().getAsString());
        attrs.addCDATAAttribute("previousDay", previousDay.dayOfMonth().getAsString());

        attrs.addCDATAAttribute("next", ISODateTimeFormat.dateTime().print(nextDay));
        attrs.addCDATAAttribute("nextYear", nextDay.year().getAsString());
        attrs.addCDATAAttribute("nextMonth", nextDay.monthOfYear().getAsString());
        attrs.addCDATAAttribute("nextDay", nextDay.dayOfMonth().getAsString());
    }

    /**
     * Generate the list of selected tags.
     * @param tags the list of tags.
     * @throws SAXException if an error occurs while saxing
     */
    protected void _saxTags(Collection<String> tags) throws SAXException
    {
        XMLUtils.startElement(contentHandler, "tags");
        for (String tag : tags)
        {
            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("name", tag);
            XMLUtils.createElement(contentHandler, "tag", attrs);
        }
        XMLUtils.endElement(contentHandler, "tags");
    }

    /**
     * Generate the list of selected tags that act as categories and their descendant tags.
     * @param categories the list of categories to generate.
     * @throws SAXException if an error occurs while saxing
     */
    protected void _saxCategories(Collection<Tag> categories) throws SAXException
    {
        XMLUtils.startElement(contentHandler, "tag-categories");
        for (Tag category : categories)
        {
            AttributesImpl categoryAttrs = new AttributesImpl();

            XMLUtils.startElement(contentHandler, "category", categoryAttrs);

            category.getTitle().toSAX(contentHandler, "title");

            XMLUtils.startElement(contentHandler, "tags");
            for (Tag tag : _eventsFilterHelper.getAllTags(category))
            {
                AttributesImpl tagAttrs = new AttributesImpl();
                tagAttrs.addCDATAAttribute("name", tag.getName());
                XMLUtils.startElement(contentHandler, "tag", tagAttrs);

                tag.getTitle().toSAX(contentHandler);

                XMLUtils.endElement(contentHandler, "tag");
            }
            XMLUtils.endElement(contentHandler, "tags");

            XMLUtils.endElement(contentHandler, "category");
        }
        XMLUtils.endElement(contentHandler, "tag-categories");
    }



}