# -*- 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

from MoinMoin import wikiutil

import calendar

import datetime

import time

import re

__version__ = "0.3"

# Date labels.

month_labels = ["January", "February", "March", "April", "May", "June",

    "July", "August", "September", "October", "November", "December"]

weekday_labels = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]

# 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)

verbatim_regexp = re.compile(ur'(?:'

    ur'<<Verbatim\((?P<verbatim>.*?)\)>>'

    ur'|'

    ur'\[\[Verbatim\((?P<verbatim2>.*?)\)\]\]'

    ur'|'

    ur'`(?P<monospace>.*?)`'

    ur'|'

    ur'{{{(?P<preformatted>.*?)}}}'

    ur')', 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

# Action support functions.

def getCategories(request):

    """

    From the AdvancedSearch macro, return a list of category page names using

    the given 'request'.

    """

    # This will return all pages with "Category" in the title.

    cat_filter = getCategoryPattern(request).search

    return request.rootpage.getPageList(filter=cat_filter)

def getCategoryMapping(category_pagenames, request):

    """

    For the given 'category_pagenames' return a list of tuples of the form

    (category name, category page name) using the given 'request'.

    """

    cat_pattern = getCategoryPattern(request)

    mapping = []

    for pagename in category_pagenames:

        name = cat_pattern.match(pagename).group("key")

        if name != "Category":

            mapping.append((name, pagename))

    mapping.sort()

    return mapping

def getPageRevision(page):

    # From Page.edit_info...

    if hasattr(page, "editlog_entry"):

        line = page.editlog_entry()

    else:

        line = page._last_edited(page.request) # MoinMoin 1.5.x and 1.6.x

    timestamp = line.ed_time_usecs

    mtime = wikiutil.version2timestamp(long(timestamp)) # must be long for py 2.2.x

    return {"timestamp" : time.gmtime(mtime), "comment" : line.comment}

def getHTTPTimeString(tmtuple):

    return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (

        weekday_labels[tmtuple.tm_wday],

        tmtuple.tm_mday,

        month_labels[tmtuple.tm_mon -1], # zero-based labels

        tmtuple.tm_year,

        tmtuple.tm_hour,

        tmtuple.tm_min,

        tmtuple.tm_sec

        )

# 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 getSimpleWikiText(text):

    """

    Return the plain text representation of the given 'text' which may employ

    certain Wiki syntax features, such as those providing verbatim or monospaced

    text.

    """

    # NOTE: Re-implementing support for verbatim text and linking avoidance.

    return "".join([s for s in verbatim_regexp.split(text) if s is not None])

def getFormat(page):

    "Get the format used on 'page'."

    if isMoin15():

        return "wiki" # page.pi_format

    else:

        return page.pi["format"]

def getEventDetails(page):

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

    event_details = {}

    if getFormat(page) == "wiki":

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

            # Permit case-insensitive list terms.

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

            desc = match.group("desc")

            # Special value type handling.

            # Dates.

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

                desc = getDate(desc)

            # Lists (whose elements may be quoted).

            elif term in ("topics", "categories"):

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

            # Labels which may well be quoted.

            elif term in ("title", "summary", "description"):

                desc = getSimpleWikiText(desc)

            if desc is not None:

                event_details[term] = desc

    return event_details

def getEventSummary(event_page, event_details):

    """

    Return either the given title or summary of the event described by the given

    'event_page', according to the given 'event_details', or return the pretty

    version of the page name.

    """

    if event_details.has_key("title"):

        return event_details["title"]

    elif event_details.has_key("summary"):

        return event_details["summary"]

    else:

        return getPrettyPageName(event_page)

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 getCurrentYear():

    "Return the current year."

    today = datetime.date.today()

    return today.year

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 = []

    processed_pages = set()

    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

            # Only process each page once.

            if pagename in processed_pages:

                continue

            else:

                processed_pages.add(pagename)

            # 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 setEventTimestamps(request, events):

    """

    Using 'request', set timestamp details in the details dictionary of each of

    the 'events': a list of the form (event_page, event_details).

    Retutn the latest timestamp found.

    """

    latest = None

    for event_page, event_details in events:

        # Get the initial revision of the page.

        revisions = event_page.getRevList()

        event_page_initial = Page(request, event_page.page_name, rev=revisions[-1])

        # Get the created and last modified times.

        initial_revision = getPageRevision(event_page_initial)

        event_details["created"] = initial_revision["timestamp"]

        latest_revision = getPageRevision(event_page)

        event_details["last-modified"] = latest_revision["timestamp"]

        event_details["sequence"] = len(revisions) - 1

        event_details["last-comment"] = latest_revision["comment"]

        if latest is None or latest < event_details["last-modified"]:

            latest = event_details["last-modified"]

    return latest

def compareEvents(event1, event2):

    """

    Compare 'event1' and 'event2' by start and end date, where both parameters

    are of the following form:

    (event_page, event_details)

    """

    event_page1, event_details1 = event1

    event_page2, event_details2 = event2

    return cmp(

        (event_details1["start"], event_details1["end"]),

        (event_details2["start"], event_details2["end"])

        )

def getOrderedEvents(events):

    """

    Return a list with the given 'events' ordered according to their start and

    end dates. Each list element must be of the following form:

    (event_page, event_details)

    """

    ordered_events = events[:]

    ordered_events.sort(compareEvents)

    return ordered_events

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

def getCoverage(start, end, events):

    """

    Within the period defined by the 'start' and 'end' dates, determine the

    coverage of the days in the period by the given 'events', returning a set of

    covered days, along with a list of slots, where each slot contains a tuple

    of the form (set of covered days, events).

    """

    all_events = []

    full_coverage = set()

    # Get event details.

    for event in events:

        event_page, event_details = event

        # Test for the event in the period.

        if event_details["start"] <= end and event_details["end"] >= start:

            # Find the coverage of this period for the event.

            event_start = max(event_details["start"], start)

            event_end = min(event_details["end"], end)

            event_coverage = set(daterange(event_start, event_end))

            # Update the overall coverage.

            full_coverage.update(event_coverage)

            # Try and fit the event into the events list.

            for i, (coverage, covered_events) in enumerate(all_events):

                # Where the event does not overlap with the current

                # element, add it alongside existing events.

                if not coverage.intersection(event_coverage):

                    covered_events.append(event)

                    all_events[i] = coverage.union(event_coverage), covered_events

                    break

            # Make a new element in the list if the event cannot be

            # marked alongside existing events.

            else:

                all_events.append((event_coverage, [event]))

    return full_coverage, all_events

# User interface functions.

def getParameter(request, name):

    return request.form.get(name, [None])[0]

def getParameterMonth(arg):

    n = None

    if arg.startswith("current"):

        date = getCurrentMonth()

        if len(arg) > 8:

            n = int(arg[7:])

    elif arg.startswith("yearstart"):

        date = (getCurrentYear(), 1)

        if len(arg) > 10:

            n = int(arg[9:])

    elif arg.startswith("yearend"):

        date = (getCurrentYear(), 12)

        if len(arg) > 8:

            n = int(arg[7:])

    else:

        date = getMonth(arg)

    if n is not None:

        date = monthupdate(date, n)

    return date

def getFormMonth(request, calendar_name, argname):

    if calendar_name is None:

        calendar_prefix = argname

    else:

        calendar_prefix = "%s-%s" % (calendar_name, argname)

    arg = getParameter(request, calendar_prefix)

    if arg is not None:

        return getParameterMonth(arg)

    else:

        return None

def getFormMonthPair(request, yeararg, montharg):

    year = getParameter(request, yeararg)

    month = getParameter(request, montharg)

    if year and month:

        return (int(year), int(month))

    else:

        return None

def getPrettyPageName(page):

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

    if isMoin15():

        title = page.split_title(page.request, force=1)

    else:

        title = page.split_title(force=1)

    return title.replace("_", " ").replace("/", u" ? ")

def getMonthLabel(month):

    "Return an unlocalised label for the given 'month'."

    return month_labels[month - 1] # zero-based labels

def getDayLabel(weekday):

    "Return an unlocalised label for the given 'weekday'."

    return weekday_labels[weekday]

def linkToPage(request, page, text, query_string=None):

    """

    Using 'request', return a link to 'page' with the given link 'text' and

    optional 'query_string'.

    """

    text = wikiutil.escape(text)

    if isMoin15():

        url = wikiutil.quoteWikinameURL(page.page_name)

        if query_string is not None:

            url = "%s?%s" % (url, query_string)

        return wikiutil.link_tag(request, url, text, getattr(page, "formatter", None))

    else:

        return page.link_to_raw(request, text, query_string)

def getPageURL(request, page):

    "Using 'request', return the URL of 'page'."

    if isMoin15():

        return request.getQualifiedURL(page.url(request))

    else:

        return request.getQualifiedURL(page.url(request, relative=0))

# vim: tabstop=4 expandtab shiftwidth=4