# -*- coding: iso-8859-1 -*-

"""

    MoinMoin - EventAggregator library

    @copyright: 2008, 2009 by Paul Boddie <paul@boddie.org.uk>

    @copyright: 2000-2004 Juergen Hermann <jh@web.de>,

                2005-2008 MoinMoin:ThomasWaldmann.

    @license: GNU GPL (v2 or later), see COPYING.txt for details.

"""

from MoinMoin.Page import Page

from MoinMoin import search, version

import calendar

import datetime

import re

__version__ = "0.1"

# Regular expressions where MoinMoin does not provide the required support.

category_regexp = None

definition_list_regexp = re.compile(ur'^\s+(?P<term>.*?)::\s(?P<desc>.*?)$', re.UNICODE | re.MULTILINE)

date_regexp = re.compile(ur'(?P<year>[0-9]{4})-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})', re.UNICODE)

month_regexp = re.compile(ur'(?P<year>[0-9]{4})-(?P<month>[0-9]{2})', re.UNICODE)

# Utility functions.

def isMoin15():

    return version.release.startswith("1.5.")

def getCategoryPattern(request):

    global category_regexp

    try:

        return request.cfg.cache.page_category_regexact

    except AttributeError:

        # Use regular expression from MoinMoin 1.7.1 otherwise.

        if category_regexp is None:

            category_regexp = re.compile(u'^%s$' % ur'(?P<all>Category(?P<key>(?!Template)\S+))', re.UNICODE)

        return category_regexp

# The main activity functions.

def getPages(pagename, request):

    "Return the links minus category links for 'pagename' using the 'request'."

    query = search.QueryParser().parse_query('category:%s' % pagename)

    if isMoin15():

        results = search.searchPages(request, query)

        results.sortByPagename()

    else:

        results = search.searchPages(request, query, "page_name")

    cat_pattern = getCategoryPattern(request)

    pages = []

    for page in results.hits:

        if not cat_pattern.match(page.page_name):

            pages.append(page)

    return pages

def getPrettyPageName(page):

    "Return a nicely formatted title/name for the given 'page'."

    return page.split_title(force=1).replace("_", " ").replace("/", u" ? ")

def getEventDetails(page):

    "Return a dictionary of event details from the given 'page'."

    event_details = {}

    if page.pi["format"] == "wiki":

        for match in definition_list_regexp.finditer(page.body):

            # Permit case-insensitive list terms.

            term = match.group("term").lower()

            desc = match.group("desc")

            # Special value type handling.

            if term in ("start", "end"):

                desc = getDate(desc)

            elif term in ("topics",):

                desc = [value.strip() for value in desc.split(",")]

            if desc is not None:

                event_details[term] = desc

    return event_details

def getDate(s):

    "Parse the string 's', extracting and returning a date string."

    m = date_regexp.search(s)

    if m:

        return tuple(map(int, m.groups()))

    else:

        return None

def getMonth(s):

    "Parse the string 's', extracting and returning a month string."

    m = month_regexp.search(s)

    if m:

        return tuple(map(int, m.groups()))

    else:

        return None

def getCurrentMonth():

    "Return the current month as a (year, month) tuple."

    today = datetime.date.today()

    return (today.year, today.month)

def monthupdate(date, n):

    "Return 'date' updated by 'n' months."

    if n < 0:

        fn = prevmonth

    else:

        fn = nextmonth

    i = 0

    while i < abs(n):

        date = fn(date)

        i += 1

    return date

def daterange(first, last, step=1):

    """

    Get the range of dates starting at 'first' and ending on 'last', using the

    specified 'step'.

    """

    results = []

    months_only = len(first) == 2

    start_year = first[0]

    end_year = last[0]

    for year in range(start_year, end_year + step, step):

        if step == 1 and year < end_year:

            end_month = 12

        elif step == -1 and year > end_year:

            end_month = 1

        else:

            end_month = last[1]

        if step == 1 and year > start_year:

            start_month = 1

        elif step == -1 and year < start_year:

            start_month = 12

        else:

            start_month = first[1]

        for month in range(start_month, end_month + step, step):

            if months_only:

                results.append((year, month))

            else:

                if step == 1 and month < end_month:

                    _wd, end_day = calendar.monthrange(year, month)

                elif step == -1 and month > end_month:

                    end_day = 1

                else:

                    end_day = last[2]

                if step == 1 and month > start_month:

                    start_day = 1

                elif step == -1 and month < start_month:

                    _wd, start_day = calendar.monthrange(year, month)

                else:

                    start_day = first[2]

                for day in range(start_day, end_day + step, step):

                    results.append((year, month, day))

    return results

def nextdate(date):

    "Return the date following the given 'date'."

    year, month, day = date

    _wd, end_day = calendar.monthrange(year, month)

    if day == end_day:

        if month == 12:

            return (year + 1, 1, 1)

        else:

            return (year, month + 1, 1)

    else:

        return (year, month, day + 1)

def prevdate(date):

    "Return the date preceding the given 'date'."

    year, month, day = date

    if day == 1:

        if month == 1:

            return (year - 1, 12, 31)

        else:

            _wd, end_day = calendar.monthrange(year, month - 1)

            return (year, month - 1, end_day)

    else:

        return (year, month, day - 1)

def nextmonth(date):

    "Return the (year, month) tuple following 'date'."

    year, month = date

    if month == 12:

        return (year + 1, 1)

    else:

        return year, month + 1

def prevmonth(date):

    "Return the (year, month) tuple preceding 'date'."

    year, month = date

    if month == 1:

        return (year - 1, 12)

    else:

        return year, month - 1

def span(start, end):

    "Return the difference between 'start' and 'end'."

    return end[0] - start[0], end[1] - start[1]

def getEvents(request, category_names, calendar_start=None, calendar_end=None):

    """

    Using the 'request', generate a list of events found on pages belonging to

    the specified 'category_names', using the optional 'calendar_start' and

    'calendar_end' month tuples of the form (year, month) to indicate a window

    of interest.

    Return a list of events, a dictionary mapping months to event lists (within

    the window of interest), a list of all events within the window of interest,

    the earliest month of an event within the window of interest, and the latest

    month of an event within the window of interest.

    """

    # Re-order the window, if appropriate.

    if calendar_start is not None and calendar_end is not None and calendar_start > calendar_end:

        calendar_start, calendar_end = calendar_end, calendar_start

    events = []

    shown_events = {}

    all_shown_events = []

    earliest = None

    latest = None

    for category_name in category_names:

        # Get the pages and page names in the category.

        pages_in_category = getPages(category_name, request)

        # Visit each page in the category.

        for page_in_category in pages_in_category:

            pagename = page_in_category.page_name

            # Get a real page, not a result page.

            real_page_in_category = Page(request, pagename)

            event_details = getEventDetails(real_page_in_category)

            # Define the event as the page together with its details.

            event = (real_page_in_category, event_details)

            events.append(event)

            # Test for the suitability of the event.

            if event_details.has_key("start") and event_details.has_key("end"):

                start_month = event_details["start"][:2]

                end_month = event_details["end"][:2]

                # Compare the months of the dates to the requested calendar

                # window, if any.

                if (calendar_start is None or end_month >= calendar_start) and \

                    (calendar_end is None or start_month <= calendar_end):

                    all_shown_events.append(event)

                    if earliest is None or start_month < earliest:

                        earliest = start_month

                    if latest is None or end_month > latest:

                        latest = end_month

                    # Store the event in the month-specific dictionary.

                    first = max(start_month, calendar_start or start_month)

                    last = min(end_month, calendar_end or end_month)

                    for event_month in daterange(first, last):

                        if not shown_events.has_key(event_month):

                            shown_events[event_month] = []

                        shown_events[event_month].append(event)

    return events, shown_events, all_shown_events, earliest, latest

def getConcretePeriod(calendar_start, calendar_end, earliest, latest):

    """

    From the requested 'calendar_start' and 'calendar_end', which may be None,

    indicating that no restriction is imposed on the period for each of the

    boundaries, use the 'earliest' and 'latest' event months to define a

    specific period of interest.

    """

    # Define the period as starting with any specified start month or the

    # earliest event known, ending with any specified end month or the latest

    # event known.

    first = calendar_start or earliest

    last = calendar_end or latest

    # If there is no range of months to show, perhaps because there are no

    # events in the requested period, and there was no start or end month

    # specified, show only the month indicated by the start or end of the

    # requested period. If all events were to be shown but none were found show

    # the current month.

    if first is None:

        first = last or getCurrentMonth()

    if last is None:

        last = first or getCurrentMonth()

    # Permit "expiring" periods (where the start date approaches the end date).

    return min(first, last), last

# vim: tabstop=4 expandtab shiftwidth=4