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

""" Gap Match type """

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

import Globals
from AccessControl import ClassSecurityInfo
from OFS.SimpleItem import SimpleItem
import re
from random import shuffle
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 GapMatchType(BaseQuestion):
    """ """

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

    manage_options = SimpleItem.manage_options

    def __init__(self, id):
        self.id=id
        self.variants = {}
        self.gapvariants = {}
        self.gappoints = {}
        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 'gap_match_type'
        
    security.declareProtected(perm_edit_question, 'setOtherVariants') 
    def setOtherVariants(self, variants):
        self.variants = variants
        txt = self.variants
        othervars = txt.split(',')
        othervariants = []
        for v in othervars:
            v.strip()
            if v != "":
                othervariants.append(v)
        self.othervariants = othervariants
        self.otherlength = len(self.othervariants)
        
    security.declareProtected(perm_view_question, 'getOtherVariantsTuple')    
    def getOtherVariantsTuple(self):
        """ """
        return self.othervariants
        
    security.declareProtected(perm_edit_question, 'setAllVariants')
    def setAllVariants(self):      #siia siis kõik variandid kokku ühte listi ja siis shuffleda    
        """ """
        all = []
        first = self.getGapvariants()
        second = self.getOtherVariantsTuple()
        for i in range (0, len(second)):
            z = second[i]
            all.append(z)
        for i in range (1, len(first)+1): 
            x = first.get('gap'+str(i))
            all.append(x)
        shuffle(all)
        self.allvariants = all    
        return all
        
    security.declareProtected(perm_view_question, 'getAllVariants')
    def getAllVariants(self):
        return self.allvariants
        
    def getAnswers(self):
        all = {}
        first = self.getGapvariants()
        second = self.getOtherVariantsTuple()
        i = 1
        for j in range (1, len(first)+1): 
            var = first.get('gap'+str(j))
            all['v'+str(i)] = var
            i += 1
        for var in second:
            all['v'+str(i)] = var
            i += 1
        return all   
        
    def VariantsTable(self):    #variandid tabelisse
        """ """
        if not hasattr(self, 'allvariants'):
            return ""
        allvariants = self.getAllVariants()
        AllLength = len(allvariants)
        table = '<table rules=cols, rows frame="box"><tr><td></td>'
        for i in range(0, AllLength):
            table += '<td>'+allvariants[i].decode('utf-8')+'</td>'
        table += '<td>'+self.utranslate('label_points', 'Points')+'</td></tr>'
        gapvariants = self.getGapvariants()
        gappoints = self.getGappoints()
        for i in range(1, len(gapvariants)+1):    
            table += '<tr><td>'+self.utranslate('Gap')+str(i)+'</td>'
            x = gapvariants.get('gap'+str(i))
            for j in range(0, AllLength):
                if x == allvariants[j]:
                    table += '<td align="center"><input type="radio" disabled="disabled" checked="checked"/></td>'
                if x != allvariants[j]:
                    table += '<td align="center"><input type="radio" disabled="disabled" /></td>'
            table += '<td align="center">'+gappoints.get('gappoints'+str(i))+'</td></tr>'
        table += '</table>'
        return table
        
    security.declareProtected(perm_view_question, 'getVariants')
    def getVariants(self):
        """ """
        return self.variants
        
    security.declareProtected(perm_view_question, 'setGapVariants')
    def setGapVariants(self, gapvariants):
        self.gapvariants = gapvariants    
        
    security.declareProtected(perm_view_question, 'getGapvariants')
    def getGapvariants(self):
        """ """
        return self.gapvariants
        
    security.declareProtected(perm_edit_question, 'setGapPoints')
    def setGapPoints(self, gap_points):
        self.gappoints = gap_points    
        
    security.declareProtected(perm_view_question, 'getGappoints')
    def getGappoints(self):
        """ """
        return getattr(self, 'gappoints', {})
        
    security.declareProtected(perm_view_question, 'getMaxPoints')
    def getMaxPoints(self):
        maxpoints = 0
        gappoints = self.getGappoints()
        for i in range(1, len(gappoints)+1):
            maxpoints += float(gappoints.get('gappoints'+str(i)))
        return maxpoints
        
    security.declareProtected(perm_edit_question, 'changeQuestion') 
    def changeQuestion(self, REQUEST):
        """ """
        variants = REQUEST.get('variants')
        self.setOtherVariants(variants)
        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 something is wrong
        if len(message) > 0:
            return REQUEST.RESPONSE.redirect(self.getId() +'/edit?message='+'<br />'.join(message))
        return REQUEST.RESPONSE.redirect(self.getId()+'/gap_match2.html')
        
    def gaps(self):
        """ """
        txt = self.getQuestion().decode('utf-8')
        allgaps = re.finditer('\[.*?\]', txt)
        allgaps1 = re.finditer('\[.*?\]', txt)
        correctanswer = {}
        
        p = None
        table = u'<table><tr>'
        table += '<td>'+self.utranslate('Text')+'</td>'
        table += '<td>'+self.utranslate('Gaps')+'</td>'
        table += '<td>'+self.utranslate('Points')+'</td>'
        table += '</tr>'
        
        gapscount = 0
        for gap in allgaps1:
            gapscount += 1

        self.gapscount = gapscount
        textgaps = {}
        gapvariants = self.getGapvariants()
        gappoints = self.getGappoints()

        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))
                gapvariant = gapvariants.get('gap'+str(k))
                if (gapvariant != None):
                    gapvariant = gapvariant.decode('utf-8')
                if m == gapvariant and x == 0:     
                    table += '<td><input type="text" name="gap'+str(i)+'" value="'+gapvariant+'" READONLY/></td>'
                    table += '<td><input type="text" size="1" name="gappoints'+str(i)+'" value="'+gappoints.get('gappoints'+str(k))+'" '
                    table += 'onKeyPress="return numbersonly(event)"/> </td></tr>'
                    x = 1
            if x == 0:
                table += '<td><input type="text" name="gap'+str(i)+'" value="'+correctanswer.get('res'+str(i))+'" READONLY/></td>'
                table += '<td><input type="text" size="1" name="gappoints'+str(i)+'" value="" onKeyPress="return numbersonly(event)"/></td></tr>'
            p = y
            i += 1
        table += '<tr><td>'+txt[z[1]:]+'</td></tr>'        
        table += '</table>'
        return table
        
    def add_variants(self, REQUEST):
        """ """
        # save variants and points
        gappoints = {}
        gapvariants = self.getGapvariants()
        for i in range(1, self.gapscount+1):
            if REQUEST.has_key('gap'+str(i)):
                gapvariants['gap'+str(i)] = REQUEST.get('gap'+str(i))
                points = REQUEST.get('gappoints'+str(i))
                if (points == ''):
                    points = '1'
                gappoints['gappoints'+str(i)] = points
        self.setAllVariants()
        self.setGapVariants(gapvariants)
        self.setGapPoints(gappoints)
        
        # send to waramu if needed                
        self._sendToWaramu()
            
        return REQUEST.RESPONSE.redirect(self.absolute_url())
        
    def replace(self, txt):
        x = re.findall('\[.*?\]', txt)
        i = 1
        for k in x:   
            txt = txt.replace(k, '<gap identifier="g'+str(i)+'"/>', 1)
            i = i + 1
        return txt
        
    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'
        xml=xml+'<responseDeclaration identifier="RESPONSE_'+self.getId()+'" cardinality="multiple" baseType="directedPair">\n'
        xml=xml+'<correctResponse>\n'
        gapvariants = self.getGapvariants()
        gapscount = len(gapvariants)
        for i in range(1, gapscount + 1):
            xml=xml+'<value>v'+str(i)+' g'+str(i)+'</value>\n'
        xml=xml+'</correctResponse>\n'
        xml=xml+'<mapping defaultValue="0" lowerBound="0">\n'
        gappoints = self.getGappoints()
        for i in range(1, gapscount + 1):
            xml=xml+'<mapEntry mapKey="v'+str(i)+' g'+str(i)+'" mappedValue="'+gappoints.get('gappoints'+str(i))+'"/>\n'
        xml=xml+'</mapping>\n'
        xml=xml+'</responseDeclaration>\n'
        xml=xml+'<outcomeDeclaration identifier="SCORE" cardinality="single" baseType="float"/>\n'
        xml=xml+'<itemBody>\n'
        xml=xml+'<gapMatchInteraction responseIdentifier="RESPONSE_'+self.getId()+'" shuffle="true">\n'    
        question = self.getQuestion()
        if fullURLs:
            from xml.sax.saxutils import escape
            question = escape(question)
        question = self.replace(question)
        xml += '<prompt>'
        question = self.fixQuestionText(question)
        if not fullURLs:
            question = self.replaceImageurl(question)
        xml += question
        xml += '</prompt>\n'
        j = 1
        for i in range(1, gapscount + 1):
            xml=xml+'<gapText identifier="v'+str(j)+'" matchMax="1">'+gapvariants.get('gap'+str(i)).decode('utf-8')+'</gapText>\n'
            j = j + 1
        for i in range(1, self.otherlength + 1):
            xml=xml+'<gapText identifier="v'+str(j)+'" matchMax="1">'+self.othervariants[i-1].decode('utf-8')+'</gapText>\n'
            j = j + 1 
#        question = self.replace(self.getQuestion())
#        xml += '<p>'
#        xml += self.replaceImageurl(question)
#        xml += '</p>\n'
        xml=xml+'</gapMatchInteraction>\n'
        xml=xml+'</itemBody>\n'
        xml=xml+ self.map_response()
        xml=xml+'</assessmentItem>\n'
        
        return xml
    
    security.declareProtected('QTAuthor: View question', 'getInteractionType')
    def getInteractionType(self):
        """ """
        return "gapMatchInteraction"
        
    def importQuestion(self, data, dom):
        """ """
        additionalFiles = {}
        questext = data.split('</gapText>')
        questext = questext[-1].split('</gapMatchInteraction')
        questext = questext[0]
        #prompt = dom.getElementsByTagName("prompt")
        
        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)
        
        allvariants = {}
        gapvariants = {}
        points = {}
        rightanswers = []
        
        correctresponse = dom.getElementsByTagName("correctResponse")
        correctanswers = correctresponse[0].getElementsByTagName("value")
        for ans in correctanswers:
            correct = ans.childNodes[0].data
            rightanswers.append(correct)
        
        variants = dom.getElementsByTagName("gapText")
        
        for i in range(1, len(variants)+1):
            varIdentifier = variants[i-1].getAttribute("identifier")
            
            var = variants[i-1].childNodes
            vartext = var[0].data
            
            allvariants[varIdentifier] = vartext.encode('utf-8')
            
        gaps = dom.getElementsByTagName("gap")    
        for i in range(1, len(gaps)+1):
            gap_id = gaps[i-1].getAttribute("identifier")
            for a in rightanswers:
                ans = a.split(" ")
                if gap_id == ans[0]: var_id = ans[1] 
                if gap_id == ans[1]: var_id = ans[0]
                if gap_id == ans[0] or gap_id == ans[1]:
                    variant = allvariants.get(var_id)
                    del allvariants[var_id]
                    questext = questext.replace('<gap identifier="'+gap_id.encode('utf-8')+'"/>', '['+variant+']')
                    gapvariants['gap'+str(i)] = variant    
        self.setQuestion(questext)
        self.setGapVariants(gapvariants)
            
        othervariants = ''
        keys = allvariants.keys()
        for i in range(0, len(allvariants)):
            var = allvariants.get(keys[i])
            othervariants += var 
            if i != len(allvariants)-1:
                othervariants += ', '
        self.setOtherVariants(othervariants)   
            
        mapEntries = dom.getElementsByTagName("mapEntry")
        for i in range(1, len(mapEntries)+1):
            mappedValue = mapEntries[i-1].getAttribute("mappedValue")
            points['gappoints'+str(i)] = mappedValue.encode('utf-8')
        self.setGapPoints(points)
        
        self.setAllVariants()
        self.setWhichImages(questext)
        return additionalFiles
        
    def getQuestionStats(self):
        """ """
        table = '<table border="1"><tr><td></td>'
        allvariants = self.getAnswers()
        query = {'getQuesId': self.getId(),}
        results = self.cat_answers(query)
        
        for v in allvariants:
            table += '<td>'+allvariants.get(v)+'</td>'
        table += '</tr>'
        
        gaps = self.getGapvariants()
        for g in gaps:
            table += '<tr><td>'+g+'</td>'
            for v in allvariants:
                count = 0
                for result in results:
                    ans_obj = result.getObject()
                    ans_send = ans_obj.getAnswerSend()
                    values = re.findall('\<value\>.*?\<\/value\>', ans_send)
                    for value in values:
                        value = value.replace('<value>', '')
                        value = value.replace('</value>', '')
                        value = value.split(' ')
                        var = value[0]
                        gap = value[1].replace('g', 'gap')
                        if g == gap and v == var:
                            count += 1
                table += '<td align="center">'+str(count)+'</td>'
            table += '</tr>'
        table += '</table>'
        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 = {}
        values = re.findall('\<value\>.*?\<\/value\>', ans_send)
        allvariants = self.getAnswers()
        for value in values:
            value = value.replace('<value>', '')
            value = value.replace('</value>', '')
            value = value.split(' ')
            var = value[0]
            chosen = allvariants.get(var)
            text += chosen + ';'
            gap = value[1].replace('g', 'gap')
            if gap in array:
                gaparray = array.get(gap)
            else:
                gaparray = []
            gaparray.append(chosen)
            array[gap] = gaparray
        frequencies[ques_id] = array
        return {'csvtext': text, 'frequencies': frequencies}

Globals.InitializeClass(GapMatchType)	

# EOF