#!/usr/bin/python

import os, re, sys
from optparse import OptionParser
from debian_bundle import deb822

class issue(deb822.Deb822):
    nonReleaseFields = ['Candidate',
                        'References',
                        'Description',
                        'Notes',
                        'Bugs']
    reservedPrefixes = ['Ubuntu-']
                        
    def __init__(self, path):
        self.file = open(path, 'r')
        self.d = deb822.Deb822(self.file)
        self.name = os.path.basename(path)

    def status(self, release):
        if self.d.has_key(release):
            return self.d[release]
        else:
            return ""

    def fieldIsRelease(self, field):
        if field in self.nonReleaseFields:
            return False
        for p in self.reservedPrefixes:
            if field[:len(p)] == p:
                return False
        return True

    def get_releases(self):
        releases = []
        for field in self.d.keys():
            if self.fieldIsRelease(field):
                releases.append(field)
        return releases

def filter_issue_names(L):
    ignorePatterns = [re.compile('.*~$'),
                      re.compile('^#.*'),
                      re.compile('^00.*')]
    for issue in L:
        for p in ignorePatterns:
            if p.match(issue):
                L.remove(issue)
                break
    return L
        
def get_issues(dir):
    issues = []
    L = os.listdir(dir)
    for f in L:
        if os.path.isdir(os.path.join(dir, f)):
            L.remove(f)

    L = filter_issue_names(L)
    L.sort()

    return [ issue(os.path.join(dir, f)) for f in L ]

def parse_status(s):
    ws = '\s*'
    versions = '(?P<versions>\((\S*,\s*)*\S*\s*\))'
    changerefs = '(?P<changerefs>\[(\S*,\s*)*\S*\s*\])'
    state = '(?P<state>\S*)'

    statusre = re.compile(ws + state + ws +
                          '(' + versions + '?)' + 
                          '(' + changerefs + '?)')
    m = statusre.match(s)
    if not m:
        raise SyntaxError
    else:
        return m

def filter_out_states(issues, release, states):
    filteredissues = []
    for i in issues:
        m = parse_status(i.status(release))
        drop = False
        for s in states:
            if s == m.group('state'):
                drop = True
                break
        if drop == False:
            filteredissues.append(i)

    return filteredissues

if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option("-d", "--dirs", action="append")
    parser.add_option("-r", "--release", dest="release")
    parser.add_option("-s", "--states", action="append")
    parser.add_option("-n", "--notstates", action="append")

    (options, args) = parser.parse_args()

    if not options.dirs:
        sys.stderr.write("Error: No dirs specified.\n")
        sys.exit(1)
    issues = []
    for d in options.dirs:
        issues = issues + get_issues(d)

    if options.notstates:
        issues = filter_out_states(issues, options.release, options.notstates)

    for i in issues:
        sys.stdout.write("  %s: %s\n" % (i.name, i.status(options.release)))