"""Mailcap file handling.  See RFC 1524."""

import os

__all__ = ["getcaps","findmatch"]

# Part 1: top-level interface.

def getcaps():

    """Return a dictionary containing the mailcap database.

    The dictionary maps a MIME type (in all lowercase, e.g. 'text/plain')

    to a list of dictionaries corresponding to mailcap entries.  The list

    collects all the entries for that MIME type from all available mailcap

    files.  Each dictionary contains key-value pairs for that MIME type,

    where the viewing command is stored with the key "view".

    """

    caps = {}

    for mailcap in listmailcapfiles():

        try:

            fp = open(mailcap, 'r')

        except IOError:

            continue

        morecaps = readmailcapfile(fp)

        fp.close()

        for key, value in morecaps.iteritems():

            if not key in caps:

                caps[key] = value

            else:

                caps[key] = caps[key] + value

    return caps

def listmailcapfiles():

    """Return a list of all mailcap files found on the system."""

    # XXX Actually, this is Unix-specific

    if 'MAILCAPS' in os.environ:

        str = os.environ['MAILCAPS']

        mailcaps = str.split(':')

    else:

        if 'HOME' in os.environ:

            home = os.environ['HOME']

        else:

            # Don't bother with getpwuid()

            home = '.' # Last resort

        mailcaps = [home + '/.mailcap', '/etc/mailcap',

                '/usr/etc/mailcap', '/usr/local/etc/mailcap']

    return mailcaps

# Part 2: the parser.

def readmailcapfile(fp):

    """Read a mailcap file and return a dictionary keyed by MIME type.

    Each MIME type is mapped to an entry consisting of a list of

    dictionaries; the list will contain more than one such dictionary

    if a given MIME type appears more than once in the mailcap file.

    Each dictionary contains key-value pairs for that MIME type, where

    the viewing command is stored with the key "view".

    """

    caps = {}

    while 1:

        line = fp.readline()

        if not line: break

        # Ignore comments and blank lines

        if line[0] == '#' or line.strip() == '':

            continue

        nextline = line

        # Join continuation lines

        while nextline[-2:] == '\\\n':

            nextline = fp.readline()

            if not nextline: nextline = '\n'

            line = line[:-2] + nextline

        # Parse the line

        key, fields = parseline(line)

        if not (key and fields):

            continue

        # Normalize the key

        types = key.split('/')

        for j in range(len(types)):

            types[j] = types[j].strip()

        key = '/'.join(types).lower()

        # Update the database

        if key in caps:

            caps[key].append(fields)

        else:

            caps[key] = [fields]

    return caps

def parseline(line):

    """Parse one entry in a mailcap file and return a dictionary.

    The viewing command is stored as the value with the key "view",

    and the rest of the fields produce key-value pairs in the dict.

    """

    fields = []

    i, n = 0, len(line)

    while i < n:

        field, i = parsefield(line, i, n)

        fields.append(field)

        i = i+1 # Skip semicolon

    if len(fields) < 2:

        return None, None

    key, view, rest = fields[0], fields[1], fields[2:]

    fields = {'view': view}

    for field in rest:

        i = field.find('=')

        if i < 0:

            fkey = field

            fvalue = ""

        else:

            fkey = field[:i].strip()

            fvalue = field[i+1:].strip()

        if fkey in fields:

            # Ignore it

            pass

        else:

            fields[fkey] = fvalue

    return key, fields

def parsefield(line, i, n):

    """Separate one key-value pair in a mailcap entry."""

    start = i

    while i < n:

        c = line[i]

        if c == ';':

            break

        elif c == '\\':

            i = i+2

        else:

            i = i+1

    return line[start:i].strip(), i

# Part 3: using the database.

def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):

    """Find a match for a mailcap entry.

    Return a tuple containing the command line, and the mailcap entry

    used; (None, None) if no match is found.  This may invoke the

    'test' command of several matching entries before deciding which

    entry to use.

    """

    entries = lookup(caps, MIMEtype, key)

    # XXX This code should somehow check for the needsterminal flag.

    for e in entries:

        if 'test' in e:

            test = subst(e['test'], filename, plist)

            if test and os.system(test) != 0:

                continue

        command = subst(e[key], MIMEtype, filename, plist)

        return command, e

    return None, None

def lookup(caps, MIMEtype, key=None):

    entries = []

    if MIMEtype in caps:

        entries = entries + caps[MIMEtype]

    MIMEtypes = MIMEtype.split('/')

    MIMEtype = MIMEtypes[0] + '/*'

    if MIMEtype in caps:

        entries = entries + caps[MIMEtype]

    if key is not None:

        entries = filter(lambda e, key=key: key in e, entries)

    return entries

def subst(field, MIMEtype, filename, plist=[]):

    # XXX Actually, this is Unix-specific

    res = ''

    i, n = 0, len(field)

    while i < n:

        c = field[i]; i = i+1

        if c != '%':

            if c == '\\':

                c = field[i:i+1]; i = i+1

            res = res + c

        else:

            c = field[i]; i = i+1

            if c == '%':

                res = res + c

            elif c == 's':

                res = res + filename

            elif c == 't':

                res = res + MIMEtype

            elif c == '{':

                start = i

                while i < n and field[i] != '}':

                    i = i+1

                name = field[start:i]

                i = i+1

                res = res + findparam(name, plist)

            # XXX To do:

            # %n == number of parts if type is multipart/*

            # %F == list of alternating type and filename for parts

            else:

                res = res + '%' + c

    return res

def findparam(name, plist):

    name = name.lower() + '='

    n = len(name)

    for p in plist:

        if p[:n].lower() == name:

            return p[n:]

    return ''

# Part 4: test program.

def test():

    import sys

    caps = getcaps()

    if not sys.argv[1:]:

        show(caps)

        return

    for i in range(1, len(sys.argv), 2):

        args = sys.argv[i:i+2]

        if len(args) < 2:

            print "usage: mailcap [MIMEtype file] ..."

            return

        MIMEtype = args[0]

        file = args[1]

        command, e = findmatch(caps, MIMEtype, 'view', file)

        if not command:

            print "No viewer found for", type

        else:

            print "Executing:", command

            sts = os.system(command)

            if sts:

                print "Exit status:", sts

def show(caps):

    print "Mailcap files:"

    for fn in listmailcapfiles(): print "\t" + fn

    print

    if not caps: caps = getcaps()

    print "Mailcap entries:"

    print

    ckeys = caps.keys()

    ckeys.sort()

    for type in ckeys:

        print type

        entries = caps[type]

        for e in entries:

            keys = e.keys()

            keys.sort()

            for k in keys:

                print "  %-15s" % k, e[k]

            print

if __name__ == '__main__':

    test()