#!/usr/bin/python
# -*- coding: utf-8  -*-
#
# AfdlBot - Bot to maintain Wikipedia Afdl pages, see http://en.wikipedia.org/wiki/User:AfdlBot
# Written by an Anon E. Mouse Wikipedia editor, http://en.wikipedia.org/wiki/User:AnonEMouse
# June 2007
#
# Intended potential users of this bot:
# Wikipedia:WikiProject Macintosh/Deletion,
# Wikipedia:WikiProject Georgia Tech/Deletion
# Wikipedia:WikiProject Pornography/Deletion
# Wikipedia:WikiProject Video games/Deletion
# Wikipedia:WikiProject Warcraft/Deletion
# Wikipedia:WikiProject Webcomics/Deletion

# TODO: Templates, (and tfdl), mfdl?
# TODO: actually read categories for discussion, rather than just maintaining the already listed ones
# TODO: Deletion review as for categories
# TODO: follow down config-input categories, get all subcategories
# TODO: WikiProject Deletion Sorting and subst:ed Afds
# TODO: mark Afd when listing

import sys,re,wikipedia,codecs,time,config
from datetime import date, timedelta

site = wikipedia.getSite()
logfile = open("afd.log", 'w')
afdlBotPage = 'User:AfdlBot/Configuration'
afdlProjects = []

def followRedirects(title):
    """ Gets the page content, and as long as it's a redirect, follows those redirects. """
    page = wikipedia.Page(site, title);
    try:
        page.get()
        return page
    except wikipedia.NoPage:
        return page
    except wikipedia.SectionError:
        return page
    except wikipedia.IsRedirectPage, arg:
        return followRedirects(arg.args[0])

def parseDate(string):
    """ Accept YYYY-MM-DD or 17:55, June 8, 2007 formats, return a date object"""
    if string == None: return None
    # print 'parsing "' + string + '"'
    try:
        return date(*(time.strptime(string, '%Y-%m-%d')[0:3]))
    except ValueError:
        try:
            return date(*(time.strptime(string, '%H:%M, %B %d, %Y')[0:3]))
        except ValueError:
            try:
                return date(*(time.strptime(string, '%H:%M, %d %B %Y')[0:3]))
            except ValueError:
                return None

# Retular sub-expression to match 4 kinds of wikilinked dates
# [[2007]]-[[03-15]]
# [[2007-03-15]]
# [[July 3]], [[2007]]
# [[3 July]], [[2007]]
# Note {len(May)=3, len(September)=9}
datexpr = r'(\[\[\d{4}\]\]-\[\[\d\d\-\d\d\]\])|' + \
          r'(\[\[\d{4}-\d\d-\d\d\]\])|' + \
          r'(\[\[[A-Za-z]{3,9} \d\d\]\],?\s*\[\[\d{4}\]\])|' + \
          r'(\[\[\d\d [A-Za-z]{3,9}\]\],?\s*\[\[\d{4}\]\])'
def parseWikidate(string):
    """ Parses the above 4 formats into a date object. """
    if string == None: return None
    string = re.sub('[\]\[,]', '', string)
    # print 'newstring=', string
    # print 'parsing "' + string + '"'
    try:
        return date(*(time.strptime(string, '%Y-%m-%d')[0:3]))
    except ValueError:
        try:
            return date(*(time.strptime(string, '%B %d %Y')[0:3]))
        except ValueError:
            try:
                return date(*(time.strptime(string, '%d %B %Y')[0:3]))
            except ValueError:
                return None
    

def dateToPageName(d):
    """Need to produce single digits for days < 10. For example, 2007 June 9."""
    return d.strftime('%Y %B ') + str(d.day)


# The result was '''Speedy delete per G3'''. [[User talk:PeaceNT|'''''Peacent''''']] 02:29, 9 June 2007 (UTC)
Rresult = re.compile(r".*\<!--Template:Afd top.*The result was[^']*'''(?P<result>[^']*)'''.*" +
                     r"(?P<date>[0-9][0-9]:[0-9][0-9], [0-9][0-9] [A-Za-z]+ [0-9]{4}) \(UTC\)", re.DOTALL)


# Don't keep afdls more than a month old
archivedate = date.today() + timedelta(days=-31)

class AfdlProject(object):
    """A project (or other party) maintaining a list of Afds with Afdls."""

    # Regular expression matching an Afdl template
    Rafdl = re.compile(r'\s*(\*\s*)?{{\s*Afdl(\|(?P<params>.+?))?}}\s*', re.DOTALL | re.IGNORECASE)

    def parseAfdls(self, text):
        """ Parses Afdls from text, returns unparsed text."""
        last = 0
        rest = ''
        for m in AfdlProject.Rafdl.finditer(text):
            paramString = m.group('params')
            params = []
            if paramString:
                params = paramString.split('|')
            aa = AfdArticleFromAfdlParams(params)
            if aa:
                if m.start() > last:
                    rest += text[last:m.start()] + '\n'
                last = m.end()
                if aa.result:
                    if aa.closedate > archivedate:
                        self.closedAfds.append(aa)
                    else:
                        self.newArchived += 1
                else:
                    self.openAfds.append(aa)
        if last < len(text):
            rest += text[last:] + '\n'
        return rest

    # Matching a categories for deletion line is tough since it's not a template, but free form text.
    # * [[:Category:Anime and manga inspired webcomics]] to [[:Category:Anime and manga webcomics]] at [[Wikipedia:Categories for deletion/Log/2006 July 11#Category:Anime and manga inspired webcomics to Category:Anime and manga webcomics]] '''Kept''' ''([[July 10]] [[2006]] – [[July 20]] [[2006]])''
    # *[[:Category:Keentoons]] at [[Wikipedia:Categories for discussion/Log/2007 April 30#Category:Keentoons]]
    # * [[:Category:WikiProject Webcomics members]] at [[Wikipedia:Categories for deletion/Log/2006 July 20#WikiProject participants]] ''[[July 20]] [[2006]] – [[July 31]] [[2006]]''
    # * [[:Category:Big-bust models and performers]] ([[2007]]-[[03-15]] – [[2007]]-[[03-21]]) '''No consensus'''
    # *[[:Category:Naturally busty porn stars]] at [[Wikipedia:Categories for discussion/Log/2007 March 8#Category:Naturally busty porn stars]] ([[2007]]-[[03-08]] - ([[2007]]-[[03-14]]) '''Delete'''
    # * [[:Category:Adult video games]] at [[Wikipedia:Categories for deletion/Log/2006 May 12#Category:Adult video games to Category:Erotic computer and video games]] '''renamed to''' [[:Category:Erotic computer and video games]]
    # * [[:Category:Artifex]] at [[Wikipedia:Categories for discussion/Log/2007 April 17#Category:Artifex]] '''Speedy Delete'''
    Rcfd = re.compile(r'\s*(\*\s*)?\[\[:(?P<category>Category:[^\]]+)\]\](?P<optional>.*?)'
                      + r'(\s+at\s+\[\[(?P<cfd>Wikipedia:Categories[ _]for[ _]d[a-z]+/Log/[^\]]+)\]\])?\s*'
                      + r"((?P<optional2>.*?)'''(?P<result>[^'\n]+)''')?(?P<rest>.*)", re.IGNORECASE)
    
    # Similarly for deletion review.
    # * [[Air Force Amy]] at [[Wikipedia:Deletion_review/Log/2007 May 5#Air Force Amy]]  ([[2007-04-05]]—[[2007-04-06]]) '''Keep rewritten article.'''
    #* [[List of male performers in gay porn films]] at [[Wikipedia:Deletion review/Log/2007 April 18#List of male performers in gay porn films]] ([[2007-04-18]]—[[23 April]] [[2007]]) '''Deletion overturned'''
    Rdrv = re.compile(r'\s*(\*\s*)?\[\[:?(?P<target>[^\]]+)\]\](?P<optional>.*?)\s+at\s+'
                      + r'\[\[(?P<cfd>Wikipedia:Deletion[ _]review[ _]deletion/Log/[^\]]+)\]\]\s*'
                      + r"((?P<optional2>.*?)'''(?P<result>[^'\n]+)''')?(?P<rest>.*)", re.IGNORECASE)

    Rdatespan = re.compile(r'\s*\(\s*(?P<fromdate>' +datexpr+ r')\s*[^\[\)]*\s*(?P<todate>' +datexpr+ r')\s*\)\s*')
    # Rdatespan = re.compile(r'\s*\(\s*(?P<fromdate>' +datexpr+ u')\s*-|(–)\s*(?P<todate>' +datexpr+ r')\s*\)\s*')
    # Rdatespan = re.compile(r'\s*\(\s*(?P<fromdate>\[\[\S+\]\])\s*(?P<dash>-|(–))\s*(?P<todate>\[\[\S+\]\])\)\s*')
    # Rdatespan = re.compile(r'\s*\(\s*(?P<fromdate>' +datexpr+ ')\s*(-|(—)|(–))\s*(?P<todate>' +datexpr+ ')\s*\)\s*')
    
    def parseCfds(self, text):
        """ Parses Cfd listings from text, returns unparsed text."""
        last = 0
        rest = ''
        for m in AfdlProject.Rcfd.finditer(text):
            # print 'match=', m.group()
            # print 'category=', m.group('category')
            # print 'cfd=', m.group('cfd')
            # print 'optional=', m.group('optional')
            # print 'optional2=', m.group('optional2')
            # print 'result=', m.group('result')
            # print 'rest=', m.group('rest')
            cfdname = m.group('cfd')
            if cfdname:
                cfd = wikipedia.Page(site, m.group('cfd'))
            else:
                cfd = None
            category = wikipedia.Page(site, m.group('category'))
            cfdrest = ''
            if m.group('optional'):
                cfdrest += ' ' + m.group('optional')
                cfdrest = cfdrest.strip()
            if m.group('optional2'):
                cfdrest += ' ' + m.group('optional2')
                cfdrest = cfdrest.strip()
            if m.group('rest'):
                cfdrest += ' ' + m.group('rest')
                cfdrest = cfdrest.strip()
            datespan = AfdlProject.Rdatespan.search(cfdrest)
            fromdate = None
            todate = None
            if datespan:
                # print 'datespan=', datespan.group()
                # print 'fromdate=', datespan.group('fromdate')
                # print 'dash=', datespan.group('dash')
                # print 'todate=', datespan.group('todate')
                cfdrest = AfdlProject.Rdatespan.sub('', cfdrest)
                fromdate=parseWikidate(datespan.group('fromdate'))
                todate=parseWikidate(datespan.group('todate'))
                if fromdate and not cfd :
                    cfd = wikipedia.Page(site, 'Wikipedia:Categories for discussion/Log/' + dateToPageName(fromdate))
                    # Todo: check if cfd page links to category?
            c = CfdCategory(cfd, category, fromdate, todate, m.group('result'), cfdrest)
            if c.startdate: # in other words, if it's legitimate
                if m.start() > last:
                    rest += text[last:m.start()] + '\n'
                last = m.end()
                if c.result:
                    if not c.closedate or c.closedate > archivedate:
                        self.closedAfds.append(aa)
                    else:
                        self.newArchived += 1
                else:
                    self.openAfds.append(c)
        if last < len(text):
            rest += text[last:] + '\n'
        print 'rest after cfds=', rest
        return rest

    # Regular expression that matches an Afdl list page
    RafdlPage = re.compile(r'(?P<header>.*)' +
                       r'==\s*Open\s*==\s*(?P<open>.*)' +
                       r'==\s*Closed\s*==\s*(?P<closed>.*)', re.DOTALL) #Todo: separate footer?

    def __init__(self, listpage, articleCategories, articleTemplates, talkCategories, talkTemplates):
        # print listpage, articleTemplates, articleCategories, talkTemplates, talkCategories
        self.listpage = listpage
        self.articleTemplates = articleTemplates
        self.articleCategories = articleCategories
        self.talkTemplates = talkTemplates
        self.talkCategories = talkCategories
        self.openAfds = []
        self.closedAfds = []
        # Count the number of useful changes that would be made to list page when writing
        #- if none, don't write anything
        self.newOpen = 0
        self.newClosed = 0
        self.newArchived = 0
        # Todo: self.archivedAfds = []
        
        match = AfdlProject.RafdlPage.match(listpage.get())
        if not match:
            print 'Could not parse', listpage, '!!'
            logfile.write('Could not parse ' + str(listpage) + '!!\n')
            return
        self.header = match.group('header')

        openmatch = match.group('open')
        openmatch = AfdlProject.Rdateheader.sub('', openmatch)
        closedmatch = match.group('closed')
        closedmatch = AfdlProject.Rdateheader.sub('', closedmatch)
        
        self.opentext = self.parseAfdls(openmatch)
        self.opentext = self.parseCfds(self.opentext)
        # Some of the formerly open Afds will have just been closed, count them
        self.newClosed = len(self.closedAfds)
        self.closedtext = self.parseAfdls(closedmatch)
        self.closedtext = self.parseCfds(self.closedtext)
                        
    def __str__(self):
        """A console representation of the AfdlProject"""
        return str(self.listpage)

    def logAfd(self, page, afd, reason, spec):
        """ Add an article and its afd to the project lists. Log this in a file for fun."""
        # print self.listpage, page.title(), afd.title(), reason, spec
        aa = AfdArticle(afd, page)
        # print aa
        # Consider if article has been deleted or redirected
        if aa.result:
            # Todo: should we check archivedate? Or should we put it on the page at least once?
            self.closedAfds.append(aa)
            self.newClosed += 1
        else:
            self.openAfds.append(aa)
            self.newOpen += 1
        logfile.write(self.listpage.title() + '\t' + page.title() + '\t' + afd.title() + '\t' + reason + ':' + spec + '\n')
        logfile.flush()

    def checkAfdArticle(self, afd, article, talkpage):
        """ Check if an Afd for an article qualifies to be added to the project lists.
        Returns True if qualifies (and has been added), False if not. """

        # check for articles already in Afd list, those don't even need to be "gotten"
        for open in self.openAfds:
            if open.afd == afd and open.article == article:
                # print afd, 'matches', open
                if Rresult.match(afd.get()): # afd has a result, in other words, was closed
                    self.openAfds.remove(aa)
                    self.logAfd(article, afd, 'listed as open on', sortPageName)
                return True
        for closed in self.closedAfds:
            if closed.afd == afd and closed.article == article:
                return True

        if len(self.articleCategories)>0:
            for cat in article.categories():
                if cat.title().capitalize() in self.articleCategories:
                    self.logAfd(article, afd, 'article category', cat.title())
                    return True
        if len(self.articleTemplates)>0:
            for template in article.templates():
                if template.title().capitalize() in self.articleTemplates:
                    self.logAfd(article, afd, 'article template', template)
                    return True
        # Do we need to check talk page?
        if len(self.talkCategories) + len(self.talkTemplates) <= 0:
            return False
        if not talkpage.exists():
            return False
        if len(self.talkCategories) > 0:
            for cat in talkpage.categories():
                if cat.capitalize() in self.talkCategories:
                    self.logAfd(article, afd, 'talk category', cat.title())
                    return True
        if len(self.talkTemplates) > 0:
            for template in talkpage.templates():
                if template.capitalize() in self.talkTemplates:
                    self.logAfd(article, afd, 'talk template', template)
                    return True
        return False

    # Regular expression that matches the date header generated below
    Rdateheader = re.compile(r"^\s*'''\d\d? [A-Za-z]{3,9}'''\s+\(\[\[.*\|AfD*\]\].*\)[ \t]*\n", re.MULTILINE)

    def afdsByTime(self, list):
        list.sort()
        lastdate = None
        result = ''
        for afd in list:
            if afd.startdate != lastdate:
                # print 'changing lastdate', lastdate, 'to', afd.startdate
                lastdate = afd.startdate
                # '''19 June''' ([[Wikipedia:Articles for deletion/Log/2007 June 19|AfD]],
                #                [[Wikipedia:Categories for discussion/Log/2007 June 19|CfD]])
                datename = dateToPageName(afd.startdate)
                result += afd.startdate.strftime("'''%d %B'''") \
                          + ' ([[Wikipedia:Articles for deletion/Log/' + datename + '|AfD]],' \
                          + ' [[Wikipedia:Categories for discussion/Log/' + datename + '|CfD]])' + '\n'
            result += '* ' + str(afd) + '\n'
            logfile.write('* ' + str(afd).encode(config.console_encoding, 'replace') + '\n')
        return result

    def afdlsText(self):
        """Returns the AfdArticle lists in this project, also to logfile."""
        logfile.write(str(self) + '\n')
        text = self.header + '== Open ==\n' + self.opentext
        text += self.afdsByTime(self.openAfds)
        text += '== Closed ==\n' + self.closedtext
        text += self.afdsByTime(self.closedAfds)
        # Todo: archived Afds by alphabetical order?
        logfile.write(text.encode(config.console_encoding, 'replace'))
        return text

# end class AfdlProject

class AfdArticle(object):
    """An article for deletion, with its article (usually but not always 1-1)."""
    def __init__(self, afd, article, startdate=None, closedate=None, result=None):
        # print afd, article, startdate, closedate, result
        self.article = article
        self.afd = afd
        if startdate:
            self.startdate = startdate
        else:
            # An approximation - assuming first edit created
            # print 'getting version history'
            edits = afd.getVersionHistory(reverseOrder = True, getAll = True)
            if not edits: return # an AfD must have a startdate
            self.startdate = parseDate(edits[0][1])
        if result and closedate:
            self.result = result
            self.closedate = closedate
        else:
            # print 'getting afd'
            afdtext = afd.get()
            match = Rresult.match(afdtext)
            if match:
                if result and len(result) > 0:
                    self.result = result
                else:
                    self.result = match.group('result')
                    # print self.result
                if closedate:
                    self.closedate = closedate
                else:
                    self.closedate = parseDate(match.group('date'))
            else:
                self.result = self.closedate = None
        # print self

    def __str__(self):
        """A console representation of the AfdArticle"""
        return self.afdl()

    def __cmp__(self, other):
        """Allows sorting AfdArticles. Descending order by startdate. """
        return cmp(other.startdate, self.startdate)

    def afdl(self):
        """{{afdl|Rebecca Cummings|Rebecca Cummings (2nd nomination)|2007-05-30|2007-06-04|Delete}}"""
        retval = '{{afdl|' + self.article.title() + '|'
        if self.afd.title() != 'Wikipedia:Articles for deletion/' + self.article.title():
            retval += self.afd.title()
        retval += '|' + self.startdate.strftime('%Y-%m-%d') + '|'
        if self.result:
            # 2007-03-16
            retval += self.closedate.strftime('%Y-%m-%d') + '|' + self.result
        else:
            retval += '|'
        retval += '}}'
        return retval

# end class AfdArticle

def AfdArticleFromAfdlParams(afdlp):
        """Reads an AfdArticle from ['article', 'AfD name', 'open YYYY-MM-DD', 'close YYYY-MM-DD', 'result'].
        Last 3 params optional. """
        # print afdlp
        if not afdlp or len(afdlp) < 1: return None
        if len(afdlp) > 1 and len(afdlp[1]) > 0:
            afdname = afdlp[1]
        else:
            afdname = 'Wikipedia:Articles for deletion/' + afdlp[0]
        afd = wikipedia.Page(site, afdname)
        # if not afd.exists(): return
        article = wikipedia.Page(site, afdlp[0])
        # Any missing params will be read from the afd
        if len(afdlp) > 4:
            aa = AfdArticle(afd, article, parseDate(afdlp[2]), parseDate(afdlp[3]), afdlp[4])
        elif len(afdlp) > 2:
            aa = AfdArticle(afd, article, parseDate(afdlp[2]), None, None)
        else:
            aa = AfdArticle(afd, article, None, None, None)
        # No AFD
        if not hasattr(aa, 'startdate'): return None
        return aa


class CfdCategory(AfdArticle):
    """Some special treatment for Categories for discussion/deletion debates."""

    # Parse date and subsection out of a cfd link
    Rcfdlink = re.compile(r'Wikipedia:Categories for d[a-z]+/Log/(?P<date>[A-Za-z0-9_ ]+)(#.*)?')
    
    def __init__(self, cfd, category, startdate, closedate, result, rest):
        # print cfd, category, startdate, closedate, result, rest
        self.article = category
        self.afd = cfd
        self.startdate = startdate
        self.closedate = closedate
        self.result = result
        self.rest = rest # any unparsed stuff
        if not startdate:
            match = CfdCategory.Rcfdlink.match(cfd.title())
            if match: #If not, should throw error
                self.startdate = parseDate(match.group('date'))
            else:
                # Throw error?
                return
        # Todo: parse result and closedate from cfd?
        # if result and not closedate:
            # self.closedate = self.startdate + timedelta(10) # Nasty hack
        # print self

    def __str__(self):
        """A console representation of the CfdCategory"""
        # *[[:Category:Naturally busty porn stars]] at [[Wikipedia:Categories for discussion/Log/2007 March 8#Category:Naturally busty porn stars]] ([[2007]]-[[03-08]] - ([[2007]]-[[03-14]]) '''Delete'''
        result = '[[:' + self.article.title() + ']] at [[' + self.afd.title() + ']] ([[' + str(self.startdate) + ']] -'
        if self.closedate:
            result += ' [[' + str(self.closedate) + ']]'
        result += ')'
        if self.result:
            result += " '''" + self.result + "'''"
        result += self.rest
        return result

# end class CfdCategory(AfdArticle)

    
def readAfdlProjects(projpagename):
    """ Reads specifications of all AfdlProjects on input page. """
    projPage = followRedirects(projpagename)
    # Afd List:, article templates:, article categories:, talk templates:
    # The Afd List one is mandatory, the rest are optional
    Rspec = re.compile(r'==[^=]*'
                       + r'^\*\s*Afd List:[^\[]*\[\[(?P<listpage>[^\]]+)\]\][^\*=$]*$'
                       +'[^=]*',
                       re.IGNORECASE | re.MULTILINE)
    # Note that the category includes the word 'Category:' but the template doesn't include the
    # word 'Template:'. This is to match the results of the Page methods.
    Rtemplate = re.compile(r'\[\[Template:(?P<template>[^\]]+)\]\]', re.IGNORECASE)
    Rcategory = re.compile(r'\[\[:(?P<category>Category:[^\]]+)\]\]', re.IGNORECASE)
    RartCat = re.compile(r'(^\*\s*Article categories:[^\*$]*$)', re.IGNORECASE)
    RartTem = re.compile(r'(^\*\s*Article templates:[^\*$]*$)', re.IGNORECASE)
    RtalkCat = re.compile(r'(^\*\s*Talk categories:[^\*$]*$)', re.IGNORECASE)
    RtalkTem = re.compile(r'(^\*\s*Talk templates:[^\*$]*$)', re.IGNORECASE)
    for match in Rspec.finditer(projPage.get()):
        # print match
        listpagename = match.group('listpage')
        listPage = followRedirects(listpagename)
        if not listPage.exists():
            continue
        articleTemplates = []
        articleCategories = []
        talkTemplates = []
        talkCategories = []
        # print 'listpage=', listpage
        for line in match.group().splitlines():
            # print line
            if RartCat.match(line):
                for cat in Rcategory.finditer(line):
                    articleCategories.append(cat.group('category').capitalize())
                # print articleCategories
            if RartTem.match(line):
                for template in Rtemplate.finditer(line):
                    articleTemplates.append(template.group('template').capitalize())
                # print articleTemplates
            if RtalkCat.match(line):
                for cat in Rcategory.finditer(line):
                    talkCategories.append(cat.group('category').capitalize())
                # print talkCategories
            if RtalkTem.match(line):
                for template in Rtemplate.finditer(line):
                    talkTemplates.append(template.group('template').capitalize())
                # print talkTemplates
        afdlProjects.append(AfdlProject(listPage, articleCategories, articleTemplates, talkCategories, talkTemplates))



# Regular expression that matches a "subst"ed Afd debate
# {{Wikipedia:Articles for deletion/Dr. John E. Douglas}}
Rafd = re.compile(r'{{\s*(?P<afd>Wikipedia:Articles for deletion/(?P<title>[^}]*))}}')

def processAfdList(afdListName):
    """ Searches input page name for Afds of pages matching project categories and templates. """
    print 'Processing', afdListName
    listpage = followRedirects(afdListName)
    if not listpage.exists(): return
    listtext = listpage.get()
    # print listtext
    for match in Rafd.finditer(listtext):
        # print 'match=', match.group()
        afdname = match.group('afd')
        # print afdname
        afdtitle = match.group('title')
        afd = followRedirects(afdname)
        # print afd.linkedPages()
        # need to follow every link, to deal with multiple nominations in one AFD
        checked = [] # only follow a link once per Afd
        for article in afd.linkedPages():
            # print 'article', article, 'section', article.section()
            if article.section() != None: continue
            if ':' in article.title(): continue # mainspace pages only
            if article in checked: continue
            checked.append(article)
            article = followRedirects(article.title())
            if not article.exists(): continue
            # print 'considering ', article
            # print article.templatesWithParams()
            for (template, params) in article.templatesWithParams():
                if template == 'AfDM' and 'page='+afdtitle in params:
                    talkpage = wikipedia.Page(site, 'Talk:' + article.title())
                    for proj in afdlProjects:
                        # check them all: even if listed in one, may be listed in many
                        proj.checkAfdArticle(afd, article, talkpage)
                    break # assume only one AfDM template per article

def main():
    args = wikipedia.handleArgs() # take out the global params

    readAfdlProjects(afdlBotPage)
    # for proj in afdlProjects:
    #   print proj
    #   print proj.afdlsText()
    # return

    if len(args) > 0:
        for arg in args:
            processAfdList(arg)
    else:
        checkdate = date.today() + timedelta(days=+2)
        lastdate = date.today() + timedelta(days=-12)
        while checkdate > lastdate :
            checkdate = checkdate + timedelta(days=-1)
            # Wikipedia:Articles_for_deletion/Log/2007_June_9
            checkpagename = 'Wikipedia:Articles_for_deletion/Log/' + dateToPageName(checkdate)
            processAfdList(checkpagename)

    for proj in afdlProjects:
        print proj, 'newOpen', proj.newOpen, 'newClosed', proj.newClosed, 'newArchived', proj.newArchived
        if proj.newOpen + proj.newClosed + proj.newArchived > 0:
            comment = ''
            if proj.newOpen > 0:
                comment += '+' + str(proj.newOpen) + ' open'
            if proj.newClosed > 0:
                if len(comment) > 0: comment += ', '
                comment += '+' + str(proj.newClosed) + ' closed'
            if proj.newArchived > 0:
                if len(comment) > 0: comment += ', '
                comment += '-' + str(proj.newArchived) + ' archived'
            comment += ' deletion discussions'
            print comment
            text = proj.afdlsText()
            print text
            proj.listpage.put(text, comment, watchArticle = True, minorEdit = False)

if __name__ == "__main__":
    try:
        main()
    finally:
        wikipedia.stopme()
        logfile.close()