# -*- coding: iso-8859-1 -*-
"""
    MoinMoin - State action

    Change an given state/icon on the current page
    Need State.py

    @copyright: 2007 Flieger Richard (info@rf-mmx.de)
    @license: GNU GPL, see COPYING for details.
"""

from MoinMoin.Page import Page, config
from MoinMoin import PageEditor, formatter
import os
import re

# the statelist has to be the same as the statelist of the macro
statelist = {"todo" : "/!\\",
             "done" : "(./)",
             "aborted" : "{X}",
             "inprogress" : "(!)",
             "fun" : ":)" }

Defaultstate = "TODO"

def keyToValue( dict1 ):
    dict2 = {}
    for i in statelist:
        dict2[dict1[i]] = i
    return dict2

smileylist = keyToValue( statelist )

class StateAction:

    def __init__( self, request, referrer ):
        self.request = request
        self.referrer = referrer
        self.fmt = formatter.text_html.Formatter( self.request )
        self.pagename = self.referrer
        self.new = self.request.form.get( 'new', [None] )[0]
        self.MacroID = self.request.form.get( 'id', [None] )[0]
        self.old = self.request.form.get( 'old', [None] )[0]
        self.rev = int( self.request.form.get( 'rev', "" )[0])
        self.error = []

    def render( self ):
        _ = self.request.getText
        comment = _('''State was changed.''')
        statewaschanged = _('''State was changed''')
        statewasnotchanged = _('''State was not changed''')
        pagewaschanged = _('''Someone else changed this page while you were editing!''')
        page = Page( self.request, self.pagename )
        currentrev = page.get_real_rev()
        writable = page.isWritable()
        permission = self.request.user.may.write( self.pagename )
        if self.rev == currentrev and writable and permission:
            if not self.old:
                self.old = "todo"
            if self.new:
                try:
                    oldtext = PageEditor.PageEditor( self.request, self.pagename, do_editor_backup=0 )
                    oldtext = oldtext.get_raw_body()
                    newtext = oldtext
                    newtext = replaceByID( newtext, self.new, int(self.MacroID))
                    page = PageEditor.PageEditor( self.request, self.pagename, do_editor_backup=0 )
                    self.request.reset()
                    if not newtext == oldtext:
                        page.saveText( newtext, currentrev, comment=comment, trivial=1 )
                        query = { 'action': 'show' }
                        url = Page( self.request, self.pagename ).url( self.request, query, 0 )
                        self.request.http_redirect( url )
                        msg = statewaschanged
                    else:
                        msg = statewasnotchanged
                except self.error:
                    page = Page( self.request, self.pagename )
                    msg = statewasnotchanged
            else:
                msg = self.generateQueryMessage( )
        else:
            page = Page( self.request, self.pagename )
            msg = pagewaschanged

        page = Page( self.request, self.pagename )
        page.send_page( self.request, msg=msg )

        return ''
    
    def get_reversion(self):
        p = Page( self.request, self.pagename )
        rev = p.get_real_rev()
        return str(rev)
    
    def findallResults( self, text, pattern ):
        resultList = re.findall(pattern, text)
        return resultList

    def generateQueryMessage( self ):
        html = u""

        smileys = config.smileys.items()
        smileys.sort()
        sm =[]
        
        for off in range( len( smileys ) ):
            markup, smiley = smileys[off]
            smileyname = parsText( "(.*?)\....", smiley[3] )
            if smileyname not in sm:
                if markup in keyToValue( statelist ):
                    sm.append( smileyname )
                    iconimg = self.fmt.smiley( markup )
                    html += getHTML(self.old, markup, iconimg, self.MacroID, self.rev)
        return html
    
    def getID(self):
        try:
            id = self.request.stateID
        except self.error:
            id = 0
        return id
    
def getHTML( old, new, iconimg, id, rev ):
    html = u"""<a href="?action=state&old=%(old)s&new=%(new)s&id=%(id)s&rev=%(rev)s">%(iconimg)s</a>""" % { "new" : smileylist.get(new, Defaultstate).upper() , "old" : old, "id" : id, "rev" : rev, "iconimg" : iconimg }
    return html
    
def replaceByID( text, new, id ):
    newtext = text
    new = "[[State(%s)]]" % new
    pattern = re.compile( "\[\[State\(?\s*.*?\s*\)?\]\]" )
    id -= 1
    resultlist = pattern.findall( text )
    if resultlist:
        index = 0
        newtext = text
        pos1 = 0
        pos2 = 0
        pos1 = newtext[pos1:].find(resultlist[0])
        for result in resultlist:
            pos1 = pos2 + newtext[pos2:].find(result)
            pos2 = pos1 + len(result)
            if index == id:
                newtext = newtext[:pos1] + new + newtext[pos2:]
                break
            index += 1
    return newtext

def getResults(self, text ):
    pattern = re.compile( self.findregex)
    resultList = pattern.findall( text)
    pos = 0
    newresultList = []
    for result in resultList:
        pos = text.find(result,pos)
        if pos > self.contextsize:
            pos1 = pos - self.contextsize
        else:
            pos1 = 0
        pos2 = pos + len(result) + self.contextsize
        newresultList.append( (text[pos1:pos], result,text[pos+len(result):pos2]) ) 
        pos += len(result) +1
    return newresultList

def parsText( regex, source ):
    source = source.encode( "iso-8859-1" )
    import re
    variable = re.search( regex, source )
    if variable != None:
        variable = variable.group( 1 )
        value = variable.decode( "iso-8859-1" )
    else:
        return 0
    return value

def execute( pagename, request ):
    return StateAction( request, pagename ).render()