# -*- coding: utf-8
# -*- Mode: Python; py-indent-offset: 4 -*-

""" TextEntry type """

__version__ = "$Revision:33$"[11:-2]

import Globals
from AccessControl import ClassSecurityInfo
from OFS.SimpleItem import SimpleItem
import re
from zope.interface import implements

from Products.QTAuthor.common import commons
from Products.QTAuthor.BaseQuestion import BaseQuestion
from Products.QTAuthor.Permissions import *
from Products.QTAuthor.interfaces import IBaseQuestion, IQuestionAuthoring

class TextEntryType(BaseQuestion):
    """ """

    meta_type = 'text_entry_type'
    security = ClassSecurityInfo()
    security.declareObjectPublic()
    implements(IBaseQuestion, IQuestionAuthoring)

    manage_options = SimpleItem.manage_options

    def __init__(self, id):
        self.id=id
        self.gapvariants = {}
        self.gappoints = {}
        self.number = 0
        BaseQuestion.__init__(self)
        
    security.declarePrivate('manage_afterAdd')
    def manage_afterAdd(self, item, container):
        self.index_object()    
    
    security.declareProtected(perm_view_question, 'getType')
    def getType(self):
        return 'text_entry_type'
        
    security.declareProtected(perm_view_question, 'getMaxPoints')
    def getMaxPoints(self):
        maxpoints = 0
        i = 1
        while i < self.gapscount + 1:
            for j in range(1, 4):
                if self.gapvariants.get('gap'+str(i)+'_'+str(j)):
                    points=self.gappoints.get('gappoints'+str(i)+'_'+str(j))
                    if maxpoints < points:
                        maxpoints = points
                j = j + 1
            i += 1
        return float(maxpoints)
        
    security.declareProtected(perm_edit_question, 'changeQuestion')
    def changeQuestion(self, REQUEST):
        """ """
        self.setCommonData(REQUEST)
        allgaps = re.findall('\[.*?\]', self.getQuestion(REQUEST))
        gapscount = len(allgaps)
        self.reindex_object()
        message = []
        # display message if at least one gap [] is empty
        for gap in allgaps:
            # check is that gap empty
            if gap == "[]":
                message.append("You have to write correct answer into each gap!")
                break;
        if gapscount == 0:
            message.append("Mark which words you want gapped!")
        if len(message) > 0:
            return REQUEST.RESPONSE.redirect(self.getId() +'/edit?message='+'<br />'.join(message)) 
        return REQUEST.RESPONSE.redirect(self.absolute_url()+'/text_entry2.html')  

        
    def replace(self, txt):
        x = re.findall('\[.*?\]', txt)
        i = 1
        for k in x:   
            txt = txt.replace(k, '<textEntryInteraction responseIdentifier="RESPONSE'+str(i)+'_'+self.getId()+'" expectedLength="15" />', 1)
            i = i + 1
        return txt
        
    def setTextGaps(self):
        txt = self.getQuestion()
        allgaps = re.findall('\[.*?\]', txt) 
        textgaps = {}
        i = 1
        for gap in allgaps:
            textgaps['gap'+str(i)] = gap
            i += 1  
        self.textgaps = textgaps    
        
    def getTextGaps(self):
        return self.textgaps    
        
    def gaps(self):
        """ """
        txt = self.getQuestion().decode('utf-8')
        allgaps = re.finditer('\[.*?\]', txt)
        allgaps1 = re.finditer('\[.*?\]', txt)
        correctanswer = {}
        
        p = None
        table = '<table>'
        table += '<tr><td>'+self.utranslate('Text')+'</td><td>'+self.utranslate('Choices')+'</td><td>'+self.utranslate('Points')+'</td></tr>'
        gapscount = 0
        for some in allgaps1:
            gapscount = gapscount + 1
        self.gapscount = gapscount
        
        textgaps = {}
        gapvariants = self.getVariants()
        gappoints = self.getPoints()

        i = 1
        for y in allgaps:
            x = y.group()
            correctanswer['res'+str(i)] = x[1:-1]
            textgaps['gap'+str(i)] = x
            z = y.span()
            e = 0
            if p: e=p.span()[1]
            table += '<tr><td>'+txt[e:z[0]]+'</td></tr>'
            table += '<tr><td>'+y.group()+'</td>'
            x = 0
            for k in range(1, gapscount + 1):
                m = correctanswer.get('res'+str(i))
                print "gap: ", k
                print "correctanswer: ", m.encode("utf-8")
                gapvariant1 = gapvariants.get('gap'+str(k)+'_1')
                if (gapvariant1 != None):
                    gapvariant1 = gapvariant1.decode('utf-8')
                #print "gapvariant1: ", gapvariant1
                if m == gapvariant1 and x == 0:     
                    table += '<td>1. <input type="text" name="gap'+str(i)+'_1" '
                    table += 'value="'+gapvariant1+'" READONLY/></td>'
                    table += '<td><input type="text" size="2" name="gappoints'+str(i)+'_1" value="'+gappoints.get('gappoints'+str(i)+'_1')+'" onKeyPress="return numbersonly(event)"/> </td></tr>'
                    for j in range(2, 4):
                        table += '<tr><td></td><td>'+str(j)+'. <input type="text" name="gap'+str(i)+'_'+str(j)+'" '
                        table += 'value="'+gapvariants.get('gap'+str(i)+'_'+str(j)).decode('utf-8')+'"/></td>'
                        table += '<td><input type="text" size="2" name="gappoints'+str(i)+'_'+str(j)+'"' 
                        table += 'value="'+gappoints.get('gappoints'+str(i)+'_'+str(j))+'" onKeyPress="return numbersonly(event)"/></td></tr>'
                    x = 1
            if x == 0:
                table += '<td>1. <input type="text" name="gap'+str(i)+'_1" value="'+correctanswer.get('res'+str(i))+'" READONLY/></td>'
                table += '<td><input type="text" size="2" name="gappoints'+str(i)+'_1" value="1" onKeyPress="return numbersonly(event)"/> </td></tr>'
                table += '<tr><td></td><td>2. <input type="text" name="gap'+str(i)+'_2"/><td><input type="text" size="2" name="gappoints'+str(i)+'_2" onKeyPress="return numbersonly(event)"/></td></tr>'
                table += '<tr><td></td><td>3. <input type="text" name="gap'+str(i)+'_3"/><td><input type="text" size="2" name="gappoints'+str(i)+'_3" onKeyPress="return numbersonly(event)"/></td></tr>'
            p = y
            i = i + 1
        table += '<tr><td>'+txt[z[1]:]+'</td></tr>'
        table += '</table>'
        self.textgaps = textgaps
        return table
        
    def add_variants(self, REQUEST):
        """ save variants and points """
        gapvariants = {}
        gappoints = {}
        number = 0
        for i in range(1, self.gapscount + 1):
            for j in range(1, 4):
                if REQUEST.has_key('gap'+str(i)+'_'+str(j)):
                    gapvariant = REQUEST.get('gap'+str(i)+'_'+str(j))
                    gapvariants['gap'+str(i)+'_'+str(j)] = gapvariant
                    points = REQUEST.get('gappoints'+str(i)+'_'+str(j))
                    if gapvariant != '' and points == '':
                        points = '1'
                    gappoints['gappoints'+str(i)+'_'+str(j)] = points
            number += 1
        self.number = number
        self.setVariants(gapvariants, gappoints)
        
        # send to waramu if needed                
        self._sendToWaramu()
        
        return REQUEST.RESPONSE.redirect(self.absolute_url())
        
    security.declareProtected(perm_edit_question, 'setVariants')
    def setVariants(self, gapvariants, gappoints):
        self.gapvariants = gapvariants
        self.gappoints = gappoints
        
    security.declareProtected(perm_view_question, 'getVariants')
    def getVariants(self):
        """ """
        return self.gapvariants
        
#    security.declareProtected(perm_edit_question, 'setPoints')    
#    def setPoints(self, points):    
#        self.gappoints = points
        
    security.declareProtected(perm_view_question, 'getPoints')
    def getPoints(self):
        """ """
        return self.gappoints
        
    def setGapsCount(self, count):
        self.gapscount = count
        
    def getGapsCount(self):
        return self.gapscount
        
    security.declareProtected(perm_view_question, 'getGapstext')
    def getGapstext(self):          #text_entry_indexisse: kõik lüngad, variandid ja punktid tabelina
        """ """
        table = u'<table><tr><td width="80" nowrap="nowrap">'+self.utranslate('Gaps')+'</td>'
        table += '<td width="130" nowrap="nowrap">'+self.utranslate('Choices')+'</td>'
        table += '<td>'+self.utranslate('Points')+'</td></tr>'
        gapvariants = self.getVariants()
        gappoints = self.getPoints()
        gapscount = self.getGapsCount()
        textgaps = self.getTextGaps()
        for i in range(1, gapscount+1):
            try:
                table += '<tr><td>'+textgaps.get('gap'+str(i)).decode('utf-8')+'</td>'
            except UnicodeEncodeError:
                table += '<tr><td>'+textgaps.get('gap'+str(i))+'</td>'
            table += '<td nowrap="nowrap">1. '+gapvariants.get('gap'+str(i)+'_1').decode('utf-8')+'</td>'
            table += '<td align="center">'+gappoints.get('gappoints'+str(i)+'_1')+'</td></tr>'
            for j in range(2, 4):
                if gapvariants.get('gap'+str(i)+'_'+str(j)) != '' and gapvariants.get('gap'+str(i)+'_'+str(j)) != None:
                    gapvariant = gapvariants.get('gap'+str(i)+'_'+str(j)).decode('utf-8')
                    table += '<tr><td></td><td nowrap="nowrap">'+str(j)+'. '+gapvariant+'</td>'
                    table += '<td align="center">'+gappoints.get('gappoints'+str(i)+'_'+str(j))+'</td></tr>'
        table += '</table>'
        return table

    def xml2(self, fullURLs=False):
        """ """
        xml = u'<?xml version="1.0" encoding="UTF-8"?>\n'
        xml += '<assessmentItem xmlns="http://www.imsglobal.org/xsd/imsqti_v2p1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \n'
        xml += 'xsi:schemaLocation="http://www.imsglobal.org/xsd/imsqti_v2p1 http://www.imsglobal.org/xsd/imsqti_v2p1.xsd" \n'
        xml += 'identifier="'+self.getId()+'" title="'+self.replaceSymbols(self.getTitle())+'" adaptive="false" timeDependent="false">\n'
        i = 1
        while i < self.gapscount + 1:
            j = 1
            xml=xml+'<responseDeclaration identifier="RESPONSE'+str(i)+'_'+self.getId()+'" cardinality="single" baseType="string">\n'
            xml=xml+'<correctResponse>\n'
            xml=xml+'<value>'+self.gapvariants.get('gap'+str(i)+'_1').decode('utf-8')+'</value>\n'
            xml=xml+'</correctResponse>\n'
            xml=xml+'<mapping defaultValue="0">\n'
            for j in range(1, 4):
                if self.gapvariants.get('gap'+str(i)+'_'+str(j)):
                    xml=xml+'<mapEntry mapKey="'+self.gapvariants.get('gap'+str(i)+'_'+str(j)).decode('utf-8')+'" '
                    xml=xml+'mappedValue="'+self.gappoints.get('gappoints'+str(i)+'_'+str(j))+'"/>\n'
                j = j + 1
            xml=xml+'</mapping>\n'
            xml=xml+'</responseDeclaration>\n'
            xml += '<outcomeDeclaration identifier="SCORE%s" cardinality="single" baseType="integer"/>\n' % i
            i = i + 1
        xml=xml+'<itemBody>\n'
        xml=xml+'<p>'
        question = self.getQuestion()
        if fullURLs:
            from xml.sax.saxutils import escape
            question = escape(question)
        question = self.replace(question)
        if not fullURLs:
            question = self.replaceImageurl(question)      
        if not isinstance(question, unicode):
            question = question.decode('utf-8')
        xml += question
        xml=xml+'</p>'
        xml=xml+'</itemBody>\n'
        
        xml += '<responseProcessing>'
        for i in range(1, self.gapscount + 1):
            xml += '<responseCondition>'
            xml += '<responseIf>'
            xml += '<isNull>'
            xml += '<variable identifier="RESPONSE%s_%s" />' % (i, self.getId())
            xml += '</isNull>'
            xml += '<setOutcomeValue identifier="SCORE%s">' % i
            xml += '<baseValue baseType="float">0.0</baseValue>'
            xml += '</setOutcomeValue>'
            xml += '</responseIf>'
            xml += '<responseElse>'
            xml += '<setOutcomeValue identifier="SCORE%s">' % i
            xml += '<mapResponse identifier="RESPONSE%s_%s"/>' % (i, self.getId())
            xml += '</setOutcomeValue>'
            xml += '</responseElse>'
            xml += '</responseCondition>'
        xml += "</responseProcessing>"
        
        xml=xml+'</assessmentItem>\n'
        
        return xml
        
    security.declareProtected(perm_view_question, 'getInteractionType')
    def getInteractionType(self):
        """ """
        return "textEntryInteraction"
        
    def importQuestion(self, data, dom):
        """ """
        additionalFiles = {}
        questext = data.split('<itemBody>')
        questext = questext[1].split('</itemBody>')        
        questext = questext[0]
        
        images = re.findall('src\=".*?\"', questext)
        url = self.get_root().absolute_url()
        for im in images:
            z = im
            im = im.split('"')
            im = im[1]
            
            new_img_id = self.random_generator('image_')
            
            additionalFiles[im] = new_img_id
            questext = questext.replace(z, 'src="'+url+'/images/'+new_img_id+'"', 1)
                
#        def recukrsiivne(self, element, quetionText=""):
#          
#          for node in idemBody.childNodes:
#              if node is text node:
#                  questionText += node.nodeValue
#              if node is 'interaction' bla bla:
#                  quesitontext += "[vairant]"
#              if node is tavaline node:
#                  questionText += self.recurksriine(node)
#                  
#          return qustionText
        
#        itemBody = getElement('itembody')
#        questonText = self.recukrsiivne(itemBody, "")        

        allvariants = {}
        gapvariants = {}
        gappoints = {}
        rightanswers = []
                
        responseDeclarations = dom.getElementsByTagName("responseDeclaration")
        for res in responseDeclarations:
            i = responseDeclarations.index(res) + 1
            correctresponse = res.getElementsByTagName("correctResponse")
            correctanswer = correctresponse[0].getElementsByTagName("value")
            correct = correctanswer[0].childNodes[0].data
            rightanswers.append(correct)
            
            mapEntries = res.getElementsByTagName("mapEntry")
            for j in range(1, 4):
                if len(mapEntries)>=j:
                    mappedValue = mapEntries[j-1].getAttribute("mappedValue")
                    mapKey = mapEntries[j-1].getAttribute("mapKey")
                else:
                    mappedValue = ''
                    mapKey = ''
                gappoints['gappoints'+str(i)+'_'+str(j)] = mappedValue.encode('utf-8')
                gapvariants['gap'+str(i)+'_'+str(j)] = mapKey.encode('utf-8')             
        
        x = re.findall('\<textEntryInteraction.*?\>', questext)
        for k in x:
            index = x.index(k)
            correct = rightanswers[index]
            text = '['+correct.encode('utf-8')+']'
            questext = questext.replace(k, text, 1)
        self.setQuestion(questext)
        
        self.setTextGaps()
        self.setGapsCount(len(responseDeclarations))
        self.setVariants(gapvariants, gappoints)
        self.setWhichImages(questext)
        return additionalFiles
        
    def getQuestionStats(self):
        """ """
        table = '<table border="1"><tr><th>Gaps</th><th>Frequencies</th></tr>'
        variants = self.getVariants()
        query = {'getQuesId': self.getId(),}
        results = self.cat_answers(query)
        
        array = {}
        for result in results:
            ans_obj = result.getObject()
            ans_send = ans_obj.getAnswerSend()
            pairs = re.findall('\<pair\>.*?\<\/pair\>', ans_send) 
            for pair in pairs:
                pair_index = pairs.index(pair)
                cm = re.compile('<value>(.*?)</value>', re.S)
                val = cm.search(ans_send).group(1)                                        
                gap = 'gap'+str(pair_index+1)
                if gap in array:
                    gaparray = array.get(gap)
                else:
                    gaparray = {'different': [], 'allvariants': []}
                different = gaparray.get('different')
                if val not in different:
                    different.append(val)
                gaparray['different'] = different
                allvariants = gaparray.get('allvariants')
                allvariants.append(val)
                gaparray['allvariants'] = allvariants
                array[gap] = gaparray
       
        for i in range(1, len(array)+1):
            table += '<tr><td valign="top">gap'+str(i)+'</td><td valign="top">'
            gap = array.get('gap'+str(i))
            different = gap.get('different')
            allvariants = gap.get('allvariants')
            for j in range(1, 4):
                if variants.get('gap'+str(i)+'_'+str(j)) != None and variants.get('gap'+str(i)+'_'+str(j)) != '':
                    var = variants.get('gap'+str(i)+'_'+str(j))
                    varcount = allvariants.count(var)
                    table += var + '=' +str(varcount) + '<br />'
                    if var in different:
                        different.remove(var)
            for var in different:
                varcount = allvariants.count(var)
                table += var + '=' + str(varcount) + '<br />'
            table += '</td></tr>'

        return table
        
    def getCSVstats(self, ans_send, frequencies):
        import re
        text = ""
        ques_id = self.getId()
        if ques_id in frequencies:
            array = frequencies.get(ques_id)
        else:
            array = {}
        pairs = re.findall('\<pair\>.*?\<\/pair\>', ans_send) 
        for pair in pairs:
            pair_index = pairs.index(pair)
            cm = re.compile('<value>(.*?)</value>', re.S)
            val = cm.search(ans_send).group(1)
            text += val + ';'
            gap = 'gap'+str(pair_index+1)
            if gap in array:
                gaparray = array.get(gap)
            else:
                gaparray = {'different': [], 'allvariants': []}
            different = gaparray.get('different')
            if val not in different:
                different.append(val)
            gaparray['different'] = different
            allvariants = gaparray.get('allvariants')
            allvariants.append(val)
            gaparray['allvariants'] = allvariants
            array[gap] = gaparray
        frequencies[ques_id] = array
        return {'csvtext': text, 'frequencies': frequencies}

Globals.InitializeClass(TextEntryType)	
	
# EOF