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

"""

    MoinMoin - Wiki Utility Functions

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

                2004 by Florian Festi,

                2006 by Mikko Virkkil,

                2005-2008 MoinMoin:ThomasWaldmann,

                2007 MoinMoin:ReimarBauer

    @license: GNU GPL, see COPYING for details.

"""

import cgi

import codecs

import os

import re

import time

import urllib

from MoinMoin import log

logging = log.getLogger(__name__)

from MoinMoin import config

from MoinMoin.util import pysupport, lock

from MoinMoin.support.python_compatibility import rsplit

from inspect import getargspec, isfunction, isclass, ismethod

from MoinMoin import web # needed so that next line works:

import werkzeug.utils

# Exceptions

class InvalidFileNameError(Exception):

    """ Called when we find an invalid file name """

    pass

# constants for page names

PARENT_PREFIX = "../"

PARENT_PREFIX_LEN = len(PARENT_PREFIX)

CHILD_PREFIX = "/"

CHILD_PREFIX_LEN = len(CHILD_PREFIX)

#############################################################################

### Getting data from user/Sending data to user

#############################################################################

def decodeUnknownInput(text):

    """ Decode unknown input, like text attachments

    First we try utf-8 because it has special format, and it will decode

    only utf-8 files. Then we try config.charset, then iso-8859-1 using

    'replace'. We will never raise an exception, but may return junk

    data.

    WARNING: Use this function only for data that you view, not for data

    that you save in the wiki.

    @param text: the text to decode, string

    @rtype: unicode

    @return: decoded text (maybe wrong)

    """

    # Shortcut for unicode input

    if isinstance(text, unicode):

        return text

    try:

        return unicode(text, 'utf-8')

    except UnicodeError:

        if config.charset not in ['utf-8', 'iso-8859-1']:

            try:

                return unicode(text, config.charset)

            except UnicodeError:

                pass

        return unicode(text, 'iso-8859-1', 'replace')

def decodeUserInput(s, charsets=[config.charset]):

    """

    Decodes input from the user.

    @param s: the string to unquote

    @param charsets: list of charsets to assume the string is in

    @rtype: unicode

    @return: the unquoted string as unicode

    """

    for charset in charsets:

        try:

            return s.decode(charset)

        except UnicodeError:

            pass

    raise UnicodeError('The string %r cannot be decoded.' % s)

def url_quote(s, safe='/', want_unicode=None):

    """ see werkzeug.utils.url_quote, we use a different safe param default value """

    try:

        assert want_unicode is None

    except AssertionError:

        log.exception("call with deprecated want_unicode param, please fix caller")

    return werkzeug.utils.url_quote(s, charset=config.charset, safe=safe)

def url_quote_plus(s, safe='/', want_unicode=None):

    """ see werkzeug.utils.url_quote_plus, we use a different safe param default value """

    try:

        assert want_unicode is None

    except AssertionError:

        log.exception("call with deprecated want_unicode param, please fix caller")

    return werkzeug.utils.url_quote_plus(s, charset=config.charset, safe=safe)

def url_unquote(s, want_unicode=None):

    """ see werkzeug.utils.url_unquote """

    try:

        assert want_unicode is None

    except AssertionError:

        log.exception("call with deprecated want_unicode param, please fix caller")

    return werkzeug.utils.url_unquote(s, charset=config.charset, errors='fallback:iso-8859-1')

def parseQueryString(qstr, want_unicode=None):

    """ see werkzeug.utils.url_decode """

    try:

        assert want_unicode is None

    except AssertionError:

        log.exception("call with deprecated want_unicode param, please fix caller")

    return werkzeug.utils.url_decode(qstr, charset=config.charset, errors='fallback:iso-8859-1',

                                     decode_keys=False, include_empty=False)

def makeQueryString(qstr=None, want_unicode=None, **kw):

    """ Make a querystring from arguments.

    kw arguments overide values in qstr.

    If a string is passed in, it's returned verbatim and keyword parameters are ignored.

    See also: werkzeug.utils.url_encode

    @param qstr: dict to format as query string, using either ascii or unicode

    @param kw: same as dict when using keywords, using ascii or unicode

    @rtype: string

    @return: query string ready to use in a url

    """

    try:

        assert want_unicode is None

    except AssertionError:

        log.exception("call with deprecated want_unicode param, please fix caller")

    if qstr is None:

        qstr = {}

    elif isinstance(qstr, (str, unicode)):

        return qstr

    if isinstance(qstr, dict):

        qstr.update(kw)

        return werkzeug.utils.url_encode(qstr, charset=config.charset, encode_keys=True)

    else:

        raise ValueError("Unsupported argument type, should be dict.")

def quoteWikinameURL(pagename, charset=config.charset):

    """ Return a url encoding of filename in plain ascii

    Use urllib.quote to quote any character that is not always safe.

    @param pagename: the original pagename (unicode)

    @param charset: url text encoding, 'utf-8' recommended. Other charset

                    might not be able to encode the page name and raise

                    UnicodeError. (default config.charset ('utf-8')).

    @rtype: string

    @return: the quoted filename, all unsafe characters encoded

    """

    # XXX please note that urllib.quote and werkzeug.utils.url_quote have

    # XXX different defaults for safe=...

    return werkzeug.utils.url_quote(pagename, charset=charset, safe='/')

escape = werkzeug.utils.escape

def clean_input(text, max_len=201):

    """ Clean input:

        replace CR, LF, TAB by whitespace

        delete control chars

        @param text: unicode text to clean

        @rtype: unicode

        @return: cleaned text

    """

    # we only have input fields with max 200 chars, but spammers send us more

    length = len(text)

    if length == 0 or length > max_len:

        return u''

    else:

        return text.translate(config.clean_input_translation_map)

def make_breakable(text, maxlen):

    """ make a text breakable by inserting spaces into nonbreakable parts

    """

    text = text.split(" ")

    newtext = []

    for part in text:

        if len(part) > maxlen:

            while part:

                newtext.append(part[:maxlen])

                part = part[maxlen:]

        else:

            newtext.append(part)

    return " ".join(newtext)

########################################################################

### Storage

########################################################################

# Precompiled patterns for file name [un]quoting

UNSAFE = re.compile(r'[^a-zA-Z0-9_]+')

QUOTED = re.compile(r'\(([a-fA-F0-9]+)\)')

def quoteWikinameFS(wikiname, charset=config.charset):

    """ Return file system representation of a Unicode WikiName.

    Warning: will raise UnicodeError if wikiname can not be encoded using

    charset. The default value of config.charset, 'utf-8' can encode any

    character.

    @param wikiname: Unicode string possibly containing non-ascii characters

    @param charset: charset to encode string

    @rtype: string

    @return: quoted name, safe for any file system

    """

    filename = wikiname.encode(charset)

    quoted = []

    location = 0

    for needle in UNSAFE.finditer(filename):

        # append leading safe stuff

        quoted.append(filename[location:needle.start()])

        location = needle.end()

        # Quote and append unsafe stuff

        quoted.append('(')

        for character in needle.group():

            quoted.append('%02x' % ord(character))

        quoted.append(')')

    # append rest of string

    quoted.append(filename[location:])

    return ''.join(quoted)

def unquoteWikiname(filename, charsets=[config.charset]):

    """ Return Unicode WikiName from quoted file name.

    We raise an InvalidFileNameError if we find an invalid name, so the

    wiki could alarm the admin or suggest the user to rename a page.

    Invalid file names should never happen in normal use, but are rather

    cheap to find.

    This function should be used only to unquote file names, not page

    names we receive from the user. These are handled in request by

    urllib.unquote, decodePagename and normalizePagename.

    Todo: search clients of unquoteWikiname and check for exceptions.

    @param filename: string using charset and possibly quoted parts

    @param charsets: list of charsets used by string

    @rtype: Unicode String

    @return: WikiName

    """

    ### Temporary fix start ###

    # From some places we get called with Unicode strings

    if isinstance(filename, type(u'')):

        filename = filename.encode(config.charset)

    ### Temporary fix end ###

    parts = []

    start = 0

    for needle in QUOTED.finditer(filename):

        # append leading unquoted stuff

        parts.append(filename[start:needle.start()])

        start = needle.end()

        # Append quoted stuff

        group = needle.group(1)

        # Filter invalid filenames

        if (len(group) % 2 != 0):

            raise InvalidFileNameError(filename)

        try:

            for i in range(0, len(group), 2):

                byte = group[i:i+2]

                character = chr(int(byte, 16))

                parts.append(character)

        except ValueError:

            # byte not in hex, e.g 'xy'

            raise InvalidFileNameError(filename)

    # append rest of string

    if start == 0:

        wikiname = filename

    else:

        parts.append(filename[start:len(filename)])

        wikiname = ''.join(parts)

    # FIXME: This looks wrong, because at this stage "()" can be both errors

    # like open "(" without close ")", or unquoted valid characters in the file name.

    # Filter invalid filenames. Any left (xx) must be invalid

    #if '(' in wikiname or ')' in wikiname:

    #    raise InvalidFileNameError(filename)

    wikiname = decodeUserInput(wikiname, charsets)

    return wikiname

# time scaling

def timestamp2version(ts):

    """ Convert UNIX timestamp (may be float or int) to our version

        (long) int.

        We don't want to use floats, so we just scale by 1e6 to get

        an integer in usecs.

    """

    return long(ts*1000000L) # has to be long for py 2.2.x

def version2timestamp(v):

    """ Convert version number to UNIX timestamp (float).

        This must ONLY be used for display purposes.

    """

    return v / 1000000.0

# This is the list of meta attribute names to be treated as integers.

# IMPORTANT: do not use any meta attribute names with "-" (or any other chars

# invalid in python attribute names), use e.g. _ instead.

INTEGER_METAS = ['current', 'revision', # for page storage (moin 2.0)

                 'data_format_revision', # for data_dir format spec (use by mig scripts)

                ]

class MetaDict(dict):

    """ store meta informations as a dict.

    """

    def __init__(self, metafilename, cache_directory):

        """ create a MetaDict from metafilename """

        dict.__init__(self)

        self.metafilename = metafilename

        self.dirty = False

        lock_dir = os.path.join(cache_directory, '__metalock__')

        self.rlock = lock.ReadLock(lock_dir, 60.0)

        self.wlock = lock.WriteLock(lock_dir, 60.0)

        if not self.rlock.acquire(3.0):

            raise EnvironmentError("Could not lock in MetaDict")

        try:

            self._get_meta()

        finally:

            self.rlock.release()

    def _get_meta(self):

        """ get the meta dict from an arbitrary filename.

            does not keep state, does uncached, direct disk access.

            @param metafilename: the name of the file to read

            @return: dict with all values or {} if empty or error

        """

        try:

            metafile = codecs.open(self.metafilename, "r", "utf-8")

            meta = metafile.read() # this is much faster than the file's line-by-line iterator

            metafile.close()

        except IOError:

            meta = u''

        for line in meta.splitlines():

            key, value = line.split(':', 1)

            value = value.strip()

            if key in INTEGER_METAS:

                value = int(value)

            dict.__setitem__(self, key, value)

    def _put_meta(self):

        """ put the meta dict into an arbitrary filename.

            does not keep or modify state, does uncached, direct disk access.

            @param metafilename: the name of the file to write

            @param metadata: dict of the data to write to the file

        """

        meta = []

        for key, value in self.items():

            if key in INTEGER_METAS:

                value = str(value)

            meta.append("%s: %s" % (key, value))

        meta = '\r\n'.join(meta)

        metafile = codecs.open(self.metafilename, "w", "utf-8")

        metafile.write(meta)

        metafile.close()

        self.dirty = False

    def sync(self, mtime_usecs=None):

        """ No-Op except for that parameter """

        if not mtime_usecs is None:

            self.__setitem__('mtime', str(mtime_usecs))

        # otherwise no-op

    def __getitem__(self, key):

        """ We don't care for cache coherency here. """

        return dict.__getitem__(self, key)

    def __setitem__(self, key, value):

        """ Sets a dictionary entry. """

        if not self.wlock.acquire(5.0):

            raise EnvironmentError("Could not lock in MetaDict")

        try:

            self._get_meta() # refresh cache

            try:

                oldvalue = dict.__getitem__(self, key)

            except KeyError:

                oldvalue = None

            if value != oldvalue:

                dict.__setitem__(self, key, value)

                self._put_meta() # sync cache

        finally:

            self.wlock.release()

# Quoting of wiki names, file names, etc. (in the wiki markup) -----------------------------------

# don't ever change this - DEPRECATED, only needed for 1.5 > 1.6 migration conversion

QUOTE_CHARS = u'"'

#############################################################################

### InterWiki

#############################################################################

INTERWIKI_PAGE = "InterWikiMap"

def generate_file_list(request):

    """ generates a list of all files. for internal use. """

    # order is important here, the local intermap file takes

    # precedence over the shared one, and is thus read AFTER

    # the shared one

    intermap_files = request.cfg.shared_intermap

    if not isinstance(intermap_files, list):

        intermap_files = [intermap_files]

    else:

        intermap_files = intermap_files[:]

    intermap_files.append(os.path.join(request.cfg.data_dir, "intermap.txt"))

    request.cfg.shared_intermap_files = [filename for filename in intermap_files

                                         if filename and os.path.isfile(filename)]

def get_max_mtime(file_list, page):

    """ Returns the highest modification time of the files in file_list and the

    page page. """

    timestamps = [os.stat(filename).st_mtime for filename in file_list]

    if page.exists():

        # exists() is cached and thus cheaper than mtime_usecs()

        timestamps.append(version2timestamp(page.mtime_usecs()))

    if timestamps:

        return max(timestamps)

    else:

        return 0 # no files / pages there

def load_wikimap(request):

    """ load interwiki map (once, and only on demand) """

    from MoinMoin.Page import Page

    now = int(time.time())

    if getattr(request.cfg, "shared_intermap_files", None) is None:

        generate_file_list(request)

    try:

        _interwiki_list = request.cfg.cache.interwiki_list

        old_mtime = request.cfg.cache.interwiki_mtime

        if request.cfg.cache.interwiki_ts + (1*60) < now: # 1 minutes caching time

            max_mtime = get_max_mtime(request.cfg.shared_intermap_files, Page(request, INTERWIKI_PAGE))

            if max_mtime > old_mtime:

                raise AttributeError # refresh cache

            else:

                request.cfg.cache.interwiki_ts = now

    except AttributeError:

        _interwiki_list = {}

        lines = []

        for filename in request.cfg.shared_intermap_files:

            f = codecs.open(filename, "r", config.charset)

            lines.extend(f.readlines())

            f.close()

        # add the contents of the InterWikiMap page

        lines += Page(request, INTERWIKI_PAGE).get_raw_body().splitlines()

        for line in lines:

            if not line or line[0] == '#':

                continue

            try:

                line = "%s %s/InterWiki" % (line, request.script_root)

                wikitag, urlprefix, dummy = line.split(None, 2)

            except ValueError:

                pass

            else:

                _interwiki_list[wikitag] = urlprefix

        del lines

        # add own wiki as "Self" and by its configured name

        _interwiki_list['Self'] = request.script_root + '/'

        if request.cfg.interwikiname:

            _interwiki_list[request.cfg.interwikiname] = request.script_root + '/'

        # save for later

        request.cfg.cache.interwiki_list = _interwiki_list

        request.cfg.cache.interwiki_ts = now

        request.cfg.cache.interwiki_mtime = get_max_mtime(request.cfg.shared_intermap_files, Page(request, INTERWIKI_PAGE))

    return _interwiki_list

def split_wiki(wikiurl):

    """

    Split a wiki url.

    *** DEPRECATED FUNCTION FOR OLD 1.5 SYNTAX - ONLY STILL HERE FOR THE 1.5 -> 1.6 MIGRATION ***

    Use split_interwiki(), see below.

    @param wikiurl: the url to split

    @rtype: tuple

    @return: (tag, tail)

    """

    # !!! use a regex here!

    try:

        wikitag, tail = wikiurl.split(":", 1)

    except ValueError:

        try:

            wikitag, tail = wikiurl.split("/", 1)

        except ValueError:

            wikitag, tail = 'Self', wikiurl

    return wikitag, tail

def split_interwiki(wikiurl):

    """ Split a interwiki name, into wikiname and pagename, e.g:

    'MoinMoin:FrontPage' -> "MoinMoin", "FrontPage"

    'FrontPage' -> "Self", "FrontPage"

    'MoinMoin:Page with blanks' -> "MoinMoin", "Page with blanks"

    'MoinMoin:' -> "MoinMoin", ""

    can also be used for:

    'attachment:filename with blanks.txt' -> "attachment", "filename with blanks.txt"

    @param wikiurl: the url to split

    @rtype: tuple

    @return: (wikiname, pagename)

    """

    try:

        wikiname, pagename = wikiurl.split(":", 1)

    except ValueError:

        wikiname, pagename = 'Self', wikiurl

    return wikiname, pagename

def resolve_wiki(request, wikiurl):

    """

    Resolve an interwiki link.

    *** DEPRECATED FUNCTION FOR OLD 1.5 SYNTAX - ONLY STILL HERE FOR THE 1.5 -> 1.6 MIGRATION ***

    Use resolve_interwiki(), see below.

    @param request: the request object

    @param wikiurl: the InterWiki:PageName link

    @rtype: tuple

    @return: (wikitag, wikiurl, wikitail, err)

    """

    _interwiki_list = load_wikimap(request)

    # split wiki url

    wikiname, pagename = split_wiki(wikiurl)

    # return resolved url

    if wikiname in _interwiki_list:

        return (wikiname, _interwiki_list[wikiname], pagename, False)

    else:

        return (wikiname, request.script_root, "/InterWiki", True)

def resolve_interwiki(request, wikiname, pagename):

    """ Resolve an interwiki reference (wikiname:pagename).

    @param request: the request object

    @param wikiname: interwiki wiki name

    @param pagename: interwiki page name

    @rtype: tuple

    @return: (wikitag, wikiurl, wikitail, err)

    """

    _interwiki_list = load_wikimap(request)

    if wikiname in _interwiki_list:

        return (wikiname, _interwiki_list[wikiname], pagename, False)

    else:

        return (wikiname, request.script_root, "/InterWiki", True)

def join_wiki(wikiurl, wikitail):

    """

    Add a (url_quoted) page name to an interwiki url.

    Note: We can't know what kind of URL quoting a remote wiki expects.

          We just use a utf-8 encoded string with standard URL quoting.

    @param wikiurl: wiki url, maybe including a $PAGE placeholder

    @param wikitail: page name

    @rtype: string

    @return: generated URL of the page in the other wiki

    """

    wikitail = url_quote(wikitail)

    if '$PAGE' in wikiurl:

        return wikiurl.replace('$PAGE', wikitail)

    else:

        return wikiurl + wikitail

#############################################################################

### Page types (based on page names)

#############################################################################

def isSystemPage(request, pagename):

    """ Is this a system page? Uses AllSystemPagesGroup internally.

    @param request: the request object

    @param pagename: the page name

    @rtype: bool

    @return: true if page is a system page

    """

    return (request.dicts.has_member('SystemPagesGroup', pagename) or

        isTemplatePage(request, pagename))

def isTemplatePage(request, pagename):

    """ Is this a template page?

    @param pagename: the page name

    @rtype: bool

    @return: true if page is a template page

    """

    return request.cfg.cache.page_template_regexact.search(pagename) is not None

def isGroupPage(pagename, cfg):

    """ Is this a name of group page?

    @param pagename: the page name

    @rtype: bool

    @return: true if page is a form page

    """

    return cfg.cache.page_group_regexact.search(pagename) is not None

def filterCategoryPages(request, pagelist):

    """ Return category pages in pagelist

    WARNING: DO NOT USE THIS TO FILTER THE FULL PAGE LIST! Use

    getPageList with a filter function.

    If you pass a list with a single pagename, either that is returned

    or an empty list, thus you can use this function like a `isCategoryPage`

    one.

    @param pagelist: a list of pages

    @rtype: list

    @return: only the category pages of pagelist

    """

    func = request.cfg.cache.page_category_regexact.search

    return [pn for pn in pagelist if func(pn)]

def getLocalizedPage(request, pagename): # was: getSysPage

    """ Get a system page according to user settings and available translations.

    We include some special treatment for the case that <pagename> is the

    currently rendered page, as this is the case for some pages used very

    often, like FrontPage, RecentChanges etc. - in that case we reuse the

    already existing page object instead creating a new one.

    @param request: the request object

    @param pagename: the name of the page

    @rtype: Page object

    @return: the page object of that system page, using a translated page,

             if it exists

    """

    from MoinMoin.Page import Page

    i18n_name = request.getText(pagename)

    pageobj = None

    if i18n_name != pagename:

        if request.page and i18n_name == request.page.page_name:

            # do not create new object for current page

            i18n_page = request.page

            if i18n_page.exists():

                pageobj = i18n_page

        else:

            i18n_page = Page(request, i18n_name)

            if i18n_page.exists():

                pageobj = i18n_page

    # if we failed getting a translated version of <pagename>,

    # we fall back to english

    if not pageobj:

        if request.page and pagename == request.page.page_name:

            # do not create new object for current page

            pageobj = request.page

        else:

            pageobj = Page(request, pagename)

    return pageobj

def getFrontPage(request):

    """ Convenience function to get localized front page

    @param request: current request

    @rtype: Page object

    @return localized page_front_page, if there is a translation

    """

    return getLocalizedPage(request, request.cfg.page_front_page)

def getHomePage(request, username=None):

    """

    Get a user's homepage, or return None for anon users and

    those who have not created a homepage.

    DEPRECATED - try to use getInterwikiHomePage (see below)

    @param request: the request object

    @param username: the user's name

    @rtype: Page

    @return: user's homepage object - or None

    """

    from MoinMoin.Page import Page

    # default to current user

    if username is None and request.user.valid:

        username = request.user.name

    # known user?

    if username:

        # Return home page

        page = Page(request, username)

        if page.exists():

            return page

    return None

def getInterwikiHomePage(request, username=None):

    """

    Get a user's homepage.

    cfg.user_homewiki influences behaviour of this:

    'Self' does mean we store user homepage in THIS wiki.

    When set to our own interwikiname, it behaves like with 'Self'.

    'SomeOtherWiki' means we store user homepages in another wiki.

    @param request: the request object

    @param username: the user's name

    @rtype: tuple (or None for anon users)

    @return: (wikiname, pagename)

    """

    # default to current user

    if username is None and request.user.valid:

        username = request.user.name

    if not username:

        return None # anon user

    homewiki = request.cfg.user_homewiki

    if homewiki == request.cfg.interwikiname:

        homewiki = u'Self'

    return homewiki, username

def AbsPageName(context, pagename):

    """

    Return the absolute pagename for a (possibly) relative pagename.

    @param context: name of the page where "pagename" appears on

    @param pagename: the (possibly relative) page name

    @rtype: string

    @return: the absolute page name

    """

    if pagename.startswith(PARENT_PREFIX):

        while context and pagename.startswith(PARENT_PREFIX):

            context = '/'.join(context.split('/')[:-1])

            pagename = pagename[PARENT_PREFIX_LEN:]

        pagename = '/'.join(filter(None, [context, pagename, ]))

    elif pagename.startswith(CHILD_PREFIX):

        if context:

            pagename = context + '/' + pagename[CHILD_PREFIX_LEN:]

        else:

            pagename = pagename[CHILD_PREFIX_LEN:]

    return pagename

def RelPageName(context, pagename):

    """

    Return the relative pagename for some context.

    @param context: name of the page where "pagename" appears on

    @param pagename: the absolute page name

    @rtype: string

    @return: the relative page name

    """

    if context == '':

        # special case, context is some "virtual root" page with name == ''

        # every page is a subpage of this virtual root

        return CHILD_PREFIX + pagename

    elif pagename.startswith(context + CHILD_PREFIX):

        # simple child

        return pagename[len(context):]

    else:

        # some kind of sister/aunt

        context_frags = context.split('/')   # A, B, C, D, E

        pagename_frags = pagename.split('/') # A, B, C, F

        # first throw away common parents:

        common = 0

        for cf, pf in zip(context_frags, pagename_frags):

            if cf == pf:

                common += 1

            else:

                break

        context_frags = context_frags[common:] # D, E

        pagename_frags = pagename_frags[common:] # F

        go_up = len(context_frags)

        return PARENT_PREFIX * go_up + '/'.join(pagename_frags)

def pagelinkmarkup(pagename, text=None):

    """ return markup that can be used as link to page <pagename> """

    from MoinMoin.parser.text_moin_wiki import Parser

    if re.match(Parser.word_rule + "$", pagename, re.U|re.X) and \

            (text is None or text == pagename):

        return pagename

    else:

        if text is None or text == pagename:

            text = ''

        else:

            text = '|%s' % text

        return u'[[%s%s]]' % (pagename, text)

#############################################################################

### mimetype support

#############################################################################

import mimetypes

MIMETYPES_MORE = {

 # OpenOffice 2.x & other open document stuff

 '.odt': 'application/vnd.oasis.opendocument.text',

 '.ods': 'application/vnd.oasis.opendocument.spreadsheet',

 '.odp': 'application/vnd.oasis.opendocument.presentation',

 '.odg': 'application/vnd.oasis.opendocument.graphics',

 '.odc': 'application/vnd.oasis.opendocument.chart',

 '.odf': 'application/vnd.oasis.opendocument.formula',

 '.odb': 'application/vnd.oasis.opendocument.database',

 '.odi': 'application/vnd.oasis.opendocument.image',

 '.odm': 'application/vnd.oasis.opendocument.text-master',

 '.ott': 'application/vnd.oasis.opendocument.text-template',

 '.ots': 'application/vnd.oasis.opendocument.spreadsheet-template',

 '.otp': 'application/vnd.oasis.opendocument.presentation-template',

 '.otg': 'application/vnd.oasis.opendocument.graphics-template',

 # some systems (like Mac OS X) don't have some of these:

 '.patch': 'text/x-diff',

 '.diff': 'text/x-diff',

 '.py': 'text/x-python',

 '.cfg': 'text/plain',

 '.conf': 'text/plain',

 '.irc': 'text/plain',

}

[mimetypes.add_type(mimetype, ext, True) for ext, mimetype in MIMETYPES_MORE.items()]

MIMETYPES_sanitize_mapping = {

    # this stuff is text, but got application/* for unknown reasons

    ('application', 'docbook+xml'): ('text', 'docbook'),

    ('application', 'x-latex'): ('text', 'latex'),

    ('application', 'x-tex'): ('text', 'tex'),

    ('application', 'javascript'): ('text', 'javascript'),

}

MIMETYPES_spoil_mapping = {} # inverse mapping of above

for _key, _value in MIMETYPES_sanitize_mapping.items():

    MIMETYPES_spoil_mapping[_value] = _key

class MimeType(object):

    """ represents a mimetype like text/plain """

    def __init__(self, mimestr=None, filename=None):

        self.major = self.minor = None # sanitized mime type and subtype

        self.params = {} # parameters like "charset" or others

        self.charset = None # this stays None until we know for sure!

        self.raw_mimestr = mimestr

        if mimestr:

            self.parse_mimetype(mimestr)

        elif filename:

            self.parse_filename(filename)

    def parse_filename(self, filename):

        mtype, encoding = mimetypes.guess_type(filename)

        if mtype is None:

            mtype = 'application/octet-stream'

        self.parse_mimetype(mtype)

    def parse_mimetype(self, mimestr):

        """ take a string like used in content-type and parse it into components,

            alternatively it also can process some abbreviated string like "wiki"

        """

        parameters = mimestr.split(";")

        parameters = [p.strip() for p in parameters]

        mimetype, parameters = parameters[0], parameters[1:]

        mimetype = mimetype.split('/')

        if len(mimetype) >= 2:

            major, minor = mimetype[:2] # we just ignore more than 2 parts

        else:

            major, minor = self.parse_format(mimetype[0])

        self.major = major.lower()

        self.minor = minor.lower()

        for param in parameters:

            key, value = param.split('=')

            if value[0] == '"' and value[-1] == '"': # remove quotes

                value = value[1:-1]

            self.params[key.lower()] = value

        if 'charset' in self.params:

            self.charset = self.params['charset'].lower()

        self.sanitize()

    def parse_format(self, format):

        """ maps from what we currently use on-page in a #format xxx processing

            instruction to a sanitized mimetype major, minor tuple.

            can also be user later for easier entry by the user, so he can just

            type "wiki" instead of "text/moin-wiki".

        """

        format = format.lower()

        if format in config.parser_text_mimetype:

            mimetype = 'text', format

        else:

            mapping = {

                'wiki': ('text', 'moin-wiki'),

                'irc': ('text', 'irssi'),

            }

            try:

                mimetype = mapping[format]

            except KeyError:

                mimetype = 'text', 'x-%s' % format

        return mimetype

    def sanitize(self):

        """ convert to some representation that makes sense - this is not necessarily

            conformant to /etc/mime.types or IANA listing, but if something is

            readable text, we will return some text/* mimetype, not application/*,

            because we need text/plain as fallback and not application/octet-stream.

        """

        self.major, self.minor = MIMETYPES_sanitize_mapping.get((self.major, self.minor), (self.major, self.minor))

    def spoil(self):

        """ this returns something conformant to /etc/mime.type or IANA as a string,

            kind of inverse operation of sanitize(), but doesn't change self

        """

        major, minor = MIMETYPES_spoil_mapping.get((self.major, self.minor), (self.major, self.minor))

        return self.content_type(major, minor)

    def content_type(self, major=None, minor=None, charset=None, params=None):

        """ return a string suitable for Content-Type header

        """

        major = major or self.major

        minor = minor or self.minor

        params = params or self.params or {}

        if major == 'text':

            charset = charset or self.charset or params.get('charset', config.charset)

            params['charset'] = charset

        mimestr = "%s/%s" % (major, minor)

        params = ['%s="%s"' % (key.lower(), value) for key, value in params.items()]

        params.insert(0, mimestr)

        return "; ".join(params)

    def mime_type(self):

        """ return a string major/minor only, no params """

        return "%s/%s" % (self.major, self.minor)

    def module_name(self):

        """ convert this mimetype to a string useable as python module name,

            we yield the exact module name first and then proceed to shorter

            module names (useful for falling back to them, if the more special

            module is not found) - e.g. first "text_python", next "text".

            Finally, we yield "application_octet_stream" as the most general

            mimetype we have.

            Hint: the fallback handler module for text/* should be implemented

                  in module "text" (not "text_plain")

        """

        mimetype = self.mime_type()

        modname = mimetype.replace("/", "_").replace("-", "_").replace(".", "_")

        fragments = modname.split('_')

        for length in range(len(fragments), 1, -1):

            yield "_".join(fragments[:length])

        yield self.raw_mimestr

        yield fragments[0]

        yield "application_octet_stream"

#############################################################################

### Plugins

#############################################################################