import AccessControl
import OFS, Globals
from OFS import SimpleItem
import types
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import add_dtml
import YlTest
#from YlTest import asendaHTML
#import TestiYlesanne
#from TestiYlesanne import TestiYlesanne
from YlAlus import YlAlus


class ValikYlesanne(YlAlus):
    "Valikvastustega ülesanne"
    meta_type='ValikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
    vastus=1
 
    def __init__(self, uuskysimus, uusvastus=1):
        """
        """
        self.kysimus=uuskysimus
        if self.sobivuskontroll(uusvastus):
          self.vastus=uusvastus # kas 0 või 1
        else:
          raise Exception("sobimatu vastus")
          
    def ylesandeNimetus(self, REQUEST):
         "Ülesande tüübi nimi"
         self.get_lang(('ivatests',), REQUEST)
         return REQUEST['L_it_check_exercise']
         
            
    def sobivuskontroll(self, valik):
       if valik==0 or valik==1:
          return 1
       else:
          return 0
        
    def annaKysimus(self):
        return self.kysimus
        
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<input type='checkbox' name='%s' />" % elemendinimi
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        if self.vastus:
          return "+"
        else:
          return "-"
          
    def tegelikHTML(self, REQUEST):
       "Opetaja lahendus"
       return self.vaatamineHTML(REQUEST)
          
    def pakutudHTML(self, REQUEST):
       "Pakutud andmete esitus veebis"
       self.get_lang(('ivatests',),REQUEST)
       if self.vastusPakutud:
        if self.pakutudAndmed=="on":
          return "+"
        else:
          return "-"
       else:
        return REQUEST['L_it_no_saved_answer']

    def kasPihtasArvutus(self):
       "Ylekate"
       return 1

    def kasPihtas(self):
       "uuring"
       arv=0
       if self.pakutudAndmed=="on":
         arv=1
       if arv==self.vastus:
         return 1
       else:
         return 0


    def automaatPunkte(self):
       "Automaatne punktide arv"
       if self.kasPihtas():
         return self.normPunktid
       else:
         return 0
         
          
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, näitab vastusevaliku märkeruudu"
        olek=""
        if self.vastus:
           olek=" CHECKED "
        return "<input type='checkbox' name='vastus' "+olek+"/>"
        
    def vastuseMuutmisLeht(self, vastus):
        "Vastuse salvestamine, üle kaetud"
        if vastus is not None:
          self.vastus=1
        else:
          self.vastus=0
          
    def koopia(self):
       "Koopia ülesandest"
       t=ValikYlesanne(self.kysimus, self.vastus)
       t.id=self.id
       t.normPunktid=self.normPunktid
       return t
Globals.InitializeClass(ValikYlesanne)       
       
class TekstivastusegaYlesanne(YlAlus):
    "Tekstivastustega ülesanne"
    meta_type='TekstivastusegaYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        """
        """
        self.kysimus=uuskysimus
        self.seaPunktiArvutus(0)
        
        
    def ylesandeNimetus(self, REQUEST):
        "Ülesande tüübi nimi"
        self.get_lang(('ivatests',), REQUEST)
        return REQUEST['L_it_text_answer_exercise']                    
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<textarea name='%s' /></textarea>" % elemendinimi
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        return "..."
          
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        self.get_lang(('ivatests',), REQUEST)
        if self.vastusPakutud:
          import YlTest
          return YlTest.asendaHTML(str(self.pakutudAndmed))
        else:
          return REQUEST['L_it_no_answer_text']
          
    def tegelikHTML(self, REQUEST):
        "Opetaja vastus"
        return "Igal oma vastus"
          
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, vastust ei saa ette määrata"
        return "..."       
        
          
    def koopia(self):
       "Koopia ülesandest"
       t=TekstivastusegaYlesanne(self.kysimus)
       t.id=self.id
       t.normPunktid=self.normPunktid
       return t
       
Globals.InitializeClass(TekstivastusegaYlesanne)    


class OigeTekstivastusegaYlesanne(YlAlus):
    "Küsimus, millele leidub õige vastus"
    meta_type="OigeTekstivastusegaYlesanne"

    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.variandid=[]
        
    def ylesandeNimetus(self, REQUEST):
        "Nimetus"
        self.get_lang(('ivatests',),REQUEST)
#        return "OVYl"
        return REQUEST['L_it_one_answer']
        
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        self.variandid=[]
        for i in range(len(reamassiiv)):
          if len(reamassiiv[i].split(":"))>1:
            if reamassiiv[i].split(":")[1]=="QUESTION":
              self.kysimus=reamassiiv[i+1].strip()
            if reamassiiv[i][0:7]==":ANSWER" and reamassiiv[i][7:8]!="S":
              self.variandid.append(reamassiiv[i].split(":")[2])
            if reamassiiv[i][0:5]==":CASE":
              if reamassiiv[i][6:7]=="0":
                self.tostuTundlik=0
              else:
                self.tostuTundlik=1
              
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        tulemus=":TYPE:S\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        tulemus=tulemus+":ANSWERS:1\n"
        tulemus=tulemus+":CASE:%s\n" % self.tostuTundlik
        for i in range(len(self.variandid)):
          tulemus=tulemus+":ANSWER%s:%s:100:0:0\n" % (i+1, self.variandid[i])
        return tulemus
        

    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<input type='text' name='%s' />" % elemendinimi
    

    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       import YlTest
       tulemus="<ul>"
       for x in self.variandid:
         tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(x)+"</li>"
       tulemus=tulemus+"</ul>"
       return tulemus
       
    def vaatamineHTML(self, REQUEST):
       "Lahenduse vaatamine"
       return self.tegelikHTML(REQUEST)
 

    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed)

    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        tulemus=REQUEST['L_it_correct_answers']+"<table>"
        for i in range(len(self.variandid)):
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(self.variandid[i])+"'></td></tr>"
        tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td></tr>"
        if len(self.variandid)==0:
          tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td></tr>"

        tulemus=tulemus+"</table>"
        return tulemus
        
    def vastuseMuutmisLeht(self, vastus):
        "Vastuse salvestamine, üle kaetud, kutsutakse muutmisLehelt"
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        self.variandid=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.variandid.append(vastus[i])
#        REQUEST.RESPONSE.redirect('muutmisVorm')

    def kasPihtas(self):
       "Kas tabati"
       tabamus=0
       if not self.vastusPakutud:
         return 0
       for x in self.variandid:
         if self.tostuTundlik:
           if x == self.pakutudAndmed:
             tabamus=1
         else:
           if x.lower()==self.pakutudAndmed.lower():
             tabamus=1
       return tabamus
       
    
    def automaatPunkte(self):
       "Automaatselt arvestatavad punktid"
       if self.kasPihtas():
         return self.normPunktid
       else:
         return 0    

    def koopia(self):
       "Koopia"
       t=OigeTekstivastusegaYlesanne(self.kysimus)
       for x in self.variandid:
         t.variandid.append(x)
       t.id=self.id
       t.normPunktid=self.normPunktid       
       return t
       
       

class MitmikvalikYlesanne(YlAlus):
    "Mitme võimaliku õige variandiga ülesanne"
    meta_type='MitmikvalikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.valikud=[]
        self.selgitused=[]
        self.oigedValikud=[]
        
    def ylesandeNimetus(self, REQUEST):
        "Ülesande tüübi nimi"
        self.get_lang(('ivatests',), REQUEST)
        return REQUEST['L_it_multiple_choice_exercise']
                               
        
        
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        self.valikud=[]
        self.selgitused=[]
        self.oigedValikud=[]
        self.kysimus="Kysimus puudub"
        leitud=0
        for i in range(len(reamassiiv)):
          if len(reamassiiv[i].split(":"))>1:
            if reamassiiv[i].split(":")[1]=="QUESTION":
              self.kysimus=reamassiiv[i+1].strip()
            if reamassiiv[i][0:7]==":ANSWER" and reamassiiv[i][7:8]!="S":
              self.valikud.append(reamassiiv[i+1].strip())              
              leitud=leitud+1
              if reamassiiv[i].split(":")[2]!="0":
                self.oigedValikud.append(leitud)
            if reamassiiv[i][0:7]==":REASON" and reamassiiv[i][7:8]!="S":
              self.selgitused.append(reamassiiv[i+1].strip())              
              
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        tulemus=":TYPE:MC:1:0:C\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        if len(self.oigedValikud)==0:
          protsent="0"
        else:
          protsent=str(100/len(self.oigedValikud))
        for i in range(len(self.valikud)):
          arv="0"
          if i in self.oigedValikud:
            arv=protsent
          tulemus=tulemus+":ANSWER%s:%s:H\n%s\n:REASON%s:H\n%s\n" % (i+1, arv, self.valikud[i], i+1, self.selgitused[i])
        return tulemus

        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td>"+YlTest.asendaHTML(self.valikud[i])+"</td>"+\
            "<td><input type='checkbox' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td></tr>"
         tulemus=tulemus+"</table>"
        else:
         tulemus=REQUEST['L_it_no_choices']
        return tulemus
        
    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       tulemus=""
       for i in range(len(self.valikud)):
         tulemus=tulemus+self.valikud[i]+" "
         if i in self.oigedValikud:
           tulemus=tulemus+"+"
         else:
           tulemus=tulemus+"-"
         try:
           tulemus=tulemus+" "+self.selgitused[i] 
         except:
           pass
         tulemus=tulemus+"<br />"
       return tulemus
       
       if len(self.oigedValikud)==0:
         return "Lahendus puudub"
       else:
         tulemus=""
         for x in self.oigedValikud:
           tulemus=tulemus+self.valikud[x]+"<br />"
         return tulemus
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus=""
        if len(self.valikud)>0:
          tulemus=tulemus+"<ul>"
          for i in range(len(self.valikud)):
           try:           
            tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(self.valikud[i])+" &nbsp; "+YlTest.asendaHTML(self.selgitused[i])+"</li>"
           except Exception, teade:
            tulemus=tulemus+str(teade)
          tulemus=tulemus+"</ul>"
        else:
          tulemus=REQUEST["L_it_no_choices_in_viewing"]
        return tulemus
        
        
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        self.get_lang(('ivatests',), REQUEST)
        if self.vastusPakutud:
          if self.pakutudAndmed is None:
            return "Vastus valimata"
          try:
            tulemus=""
            for x in self.pakutudAndmed:
              tulemus=tulemus+YlTest.asendaHTML(self.valikud[int(x)])+"<br />"            
            return tulemus
          except:
            return REQUEST['L_it_problem_with_data']          

    def kasPihtasArvutus(self):
        "Ylekate"
        return 0

    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus="<table><tr><td>"+REQUEST['L_it_ov_variant']+"</td><td>"+REQUEST['L_it_ov_explanation']+"</td><td>"+REQUEST['L_it_ov_correct']+"</td></tr>"
        for i in range(len(self.valikud)):
          margitud=""
          if i in self.oigedValikud:
            margitud="CHECKED"
          selgitustekst=""
          if i < len(self.selgitused):
            selgitustekst=YlTest.asendaHTML(self.selgitused[i])
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(self.valikud[i])+"'></td>"+\
            "<td><input type='text' name='selgitus' value='"+selgitustekst+"'></td>"+\
            "<td><input type='checkbox' name='valikunr' "+\
            "value='"+str(i)+"' "+margitud+"></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        if len(self.valikud)==0:
          tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='1'></td></tr>"

        tulemus=tulemus+"</table>"
        return tulemus
        
    def vastuseMuutmisLeht(self, REQUEST, vastus=None):
        "Vastuse salvestamine, üle kaetud"
        if REQUEST is None: return
        if hasattr(REQUEST, "selgitus"):
          selgitus=getattr(REQUEST, "selgitus")
        else:
          selgitus=()
        if hasattr(REQUEST, "valikunr"):
          valikunr=getattr(REQUEST, "valikunr")
        else:
          valikunr=()
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
          selgitus=(selgitus,)
        self.oigedValikud=[]
        if valikunr is None:
          valikunr=()
        if type(valikunr) is types.StringType:
          valikunr=(valikunr,)
        for x in valikunr:
          self.oigedValikud.append(int(x))
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            if i < len(selgitus):
             self.selgitused.append(selgitus[i])
          else:
            if i in self.oigedValikud:
              self.oigedValikud.remove(i)
            for j in range(len(self.oigedValikud)):
              if self.oigedValikud[j]>i:
                self.oigedValikud[j]=self.oigedValikud[j]-1

    def automaatPunkte(self):
      "Automaatne punktiarvutus"
#      return self.oigedValikud
      if not self.vastusPakutud: return 0
      if self.pakutudAndmed is None: return 0
      if type(self.pakutudAndmed) is types.StringType:
        vastused=(int(self.pakutudAndmed),)
      else:
        vastused=map(int, self.pakutudAndmed)
#      return vastused + self.oigedValikud
#      pihtas=[]
      korras=0
      for i in range(len(self.valikud)):
         if ((i in self.oigedValikud) and (i in vastused)) or \
            ((i not in self.oigedValikud) and (i not in vastused)):
          #Kui pakutu ja oige on ühesugune
          korras=korras+1
#          pihtas.append(i)
#      return pihtas
      korras=korras*1.0
      return self.normPunktid*korras/len(self.valikud)
        
          
    def koopia(self):
       "Koopia ülesandest"
       t=MitmikvalikYlesanne(self.kysimus)
       for x in self.valikud:
         t.valikud.append(x)
       for x in self.selgitused:
         t.selgitused.append(x)
       for x in self.oigedValikud:
         t.oigedValikud.append(x)
       t.id=self.id       
       t.normPunktid=self.normPunktid
       return t

Globals.InitializeClass(MitmikvalikYlesanne)

class YksikvalikYlesanne(YlAlus):
    "Üksiku valikuga ülesanne"
    meta_type='YksikvalikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.valikud=[]
        self.selgitused=[]
        self.oigeValik=-1
        
    def ylesandeNimetus(self, REQUEST):
         "Ülesande tüübi nimi"
         self.get_lang(('ivatests',), REQUEST)
         return REQUEST['L_it_one_answer_exercise']

        
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        import YlTest
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td>"+YlTest.asendaHTML(self.valikud[i])+"</td>"+\
            "<td><input type='radio' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td>"
          tulemus=tulemus+"</tr>"
         tulemus=tulemus+"</table>"
        else:
         tulemus="Valikud puuduvad"
        return tulemus
        
    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       if self.oigeValik==-1:
         return "Lahendus puudub"
       return self.valikud[self.oigeValik]

        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        tulemus=""
        if len(self.valikud)>0:
          tulemus=tulemus+"<ul>"
          for i in range(len(self.valikud)):
            tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(self.valikud[i])
            try:
              tulemus=tulemus+"|"+YlTest.asendaHTML(self.selgitused[i])
            except:
              pass
            tulemus=tulemus+"</li>"
          tulemus=tulemus+"</ul>"
        else:
          tulemus="Valikud puuduvad"
        return tulemus
        
        
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          if self.pakutudAndmed is None:
            return "Vastus valimata"
          try:
            return YlTest.asendaHTML(self.valikud[int(self.pakutudAndmed)]) +"|" + self.annaSelgitus(int(self.pakutudAndmed))          
          except:
            return "Probleem andmetega"          

    def kasPihtasArvutus(self):
        "Ylekate"
        return 1

    def kasPihtas(self):
        "Arvutus ise"
        try:
          return int(self.pakutudAndmed)==self.oigeValik
        except:
          return 0
          
    def automaatPunkte(self):
       "Automaatne punktide arv"
       if self.kasPihtas():
         return self.normPunktid
       else:
         return 0
         
    def annaSelgitus(self, nr):
       "selgituse väljastus, kuna selgituse lahter tuli hiljem juurde"
       try:
         return self.selgitused[nr]
       except:
         return ""
         
    def annaMuutmisVormiRida(self, REQUEST, nr):
          "Ühe rea loomine"
          margitud=""
          if nr==self.oigeValik:
            margitud="CHECKED"
          valik=""
          try:
            valik=self.valikud[nr] 
          except:
            pass
          return "<tr><td><input type='text' name='vastus' value='"+YlTest.asendaHTML(valik)+"'></td>"+\
            "<td><input type='radio' name='valikunr' "+\
            "value='"+str(nr)+"' "+margitud+"></td><td><input type='text' name='selgitus' value='"+YlTest.asendaHTML(self.annaSelgitus(nr))+"' /></tr>"
        

         
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus="<table><tr><td>"+REQUEST['L_it_yv_variants']+"</td><td>"+REQUEST['L_it_yv_correct']+"</td><td>"+REQUEST['L_it_yv_explanation']+"</td></tr>"
        for i in range(len(self.valikud)+4):
           tulemus=tulemus+self.annaMuutmisVormiRida(REQUEST, i)
#          margitud=""
#          if i==self.oigeValik:
#            margitud="CHECKED"
#          tulemus=tulemus+"\n<tr>"+\
#            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(self.valikud[i])+"'></td>"+\
#            "<td><input type='radio' name='valikunr' "+\
#            "value='"+str(i)+"' "+margitud+"></td></tr>"
#        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td>"+\
#                "<td><input type='radio' name='valikunr' value='"+str(len(self.valikud))+"'></td>"+\
#                "<td><input type='text' name='selgitus'""</tr>"
#        if len(self.valikud)==0:
#          tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td>"+\
#                "<td><input type='radio' name='valikunr' value='1'></td></tr>"

        tulemus=tulemus+"</table>"
        return tulemus
        
    def muutmisLehtBak(self, REQUEST=None, kysimus="", vastus="", selgitus="", valikunr=-1):
        "Vastuse salvestamine, üle kaetud"
        self.kysimus=kysimus 
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        if selgitus is None:
          selgitus=()
        if type(selgitus) is types.StringType:
          selgitus=(selgitus,)
        valikunr=int(valikunr)         
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            self.selgitused.append(selgitus[i])
              
          else:
            if valikunr==i:
              valikunr=-1
            if valikunr>i:
              valikunr=valikunr-1
        self.oigeValik=valikunr
        REQUEST.RESPONSE.redirect('muutmisVorm')
        
    def vastuseMuutmisLeht(self, REQUEST, vastus):
        "Vastuse muutmine"
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,)
        if hasattr(REQUEST, 'selgitus'):
          selgitus=REQUEST.selgitus
        else:
          selgitus=()
        if type(selgitus) is types.StringType:
          selgitus=(selgitus,)
        if hasattr(REQUEST, 'valikunr'):
          valikunr=REQUEST.valikunr
        else:
          valikunr=-1
        valikunr=int(valikunr)         
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            self.selgitused.append(selgitus[i])
              
          else:
            if valikunr==i:
              valikunr=-1
            if valikunr>i:
              valikunr=valikunr-1
        self.oigeValik=valikunr
                            

          
    def koopia(self):
       "Koopia ülesandest"
       t=YksikvalikYlesanne(self.kysimus)
       for x in self.valikud:
         t.valikud.append(x)
       try:
        for x in self.selgitused:
          t.selgitused.append(x)
       except:
         pass
       t.oigeValik=self.oigeValik
       t.id=self.id
       t.normPunktid=self.normPunktid
       return t

Globals.InitializeClass(YksikvalikYlesanne)

class ArvuvahemikuliseVastusegaYlesanne(YlAlus):
  "Vajab arvulist vastust soovitud piirkonnas"
  meta_type="ArvuvahemikuliseVastusegaYlesanne"
  
  def __init__(self, uuskysimus):
     "Loomine"
     self.kysimus=uuskysimus
     self.alamPiir=-1
     self.ylemPiir=-1
     self.oigeVastus=-1
     self.arvutusTyyp=0  # vahemik
     

  def taitmineHTML(self, REQUEST, elemendinimi):
     "Vastuse sisestamise koht"
     return "<input type='text' name='%s' />" % elemendinimi
    

  def ylesandeNimetus(self, REQUEST):
     "Tüübinimi kasutajale"
     self.get_lang(('ivatests',), REQUEST)
     return REQUEST["L_it_number_space_exercise"]

  def tegelikHTML(self, REQUEST):
     "Õpetaja lahendus"     
     return str(self.alamPiir)+" &lt;= x="+str(self.oigeVastus)+" &lt;= "+str(self.ylemPiir)

  def vaatamineHTML(self, REQUEST):
     "Lahenduse vaatamine"
     return self.tegelikHTML(REQUEST)
 

  def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed)
 
  def vastuseMuutmisVorm(self, REQUEST):
      "muutmisvorm"
      self.get_lang(('ivatests',), REQUEST)
      tulemus="<table>"
      tulemus=tulemus+"<tr><td>"+REQUEST["L_it_av_min_correct"]+"</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.alamPiir)+"'/></td></tr>"             
      tulemus=tulemus+"<tr><td>"+REQUEST["L_it_av_centre_correct"]+"</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.oigeVastus)+"'/></td></tr>"
      tulemus=tulemus+"<tr><td>"+REQUEST["L_it_av_max_correct"]+"</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.ylemPiir)+"'/></td></tr>"
      tyybimargised=["", ""]
      tyybimargised[self.arvutusTyyp]=" selected "
      
      tulemus=tulemus+"<tr><td>"+REQUEST["L_it_av_checking_type"]+"</td><td>"+\
        """
          <select name="arvutusTyyp">
            <option value="0" %s >%s</option>
            <option value="1" %s >%s</option>
          </select>
         </td></tr>
        """ % (tyybimargised[0], REQUEST["L_it_av_space"], tyybimargised[1], REQUEST["L_it_av_linear"])
      tulemus=tulemus+"</td></tr></table>"
      return tulemus
     
  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Salvestus"
     import re
     if type(vastus) is None: return "Vigane vastus"
     if len(vastus)!=3: return "Pole piirid paigas"
     for i in range(2):
       vastus[i]=re.sub(',', '.', vastus[i]);
     self.alamPiir=float(vastus[0])
     self.oigeVastus=float(vastus[1])
     self.ylemPiir=float(vastus[2])
     if hasattr(REQUEST, "arvutusTyyp"):
       self.arvutusTyyp=int(REQUEST["arvutusTyyp"])
       
  def automaatPunkte(self):
    "Automaatne punktiarvutus"
    if self.vastusPakutud:
      try:
         x=float(self.pakutudAndmed)
      except:
         return 0
      if self.arvutusTyyp==0: #vahemik
        if x>=self.alamPiir and x<=self.ylemPiir:
          return self.normPunktid
        else:
          return 0
      if self.arvutusTyyp==1: #Lineaar maksimumiga
        if x<self.alamPiir:
           return 0
        if x>self.ylemPiir:
           return 0
        if x>self.alamPiir and x<=self.oigeVastus:        
          return ((x-self.alamPiir)*1.0/(self.oigeVastus-self.alamPiir))*self.normPunktid
        if x==self.alamPiir:
          if x==self.oigeVastus: return self.normPunktid
          else: return 0
        if x>=self.oigeVastus and x<self.ylemPiir:
          return  (1-((x-self.oigeVastus)*1.0/(self.ylemPiir-self.oigeVastus)))*self.normPunktid
        if x==self.ylemPiir:
          if x==self.oigeVastus: return self.normPunktid
          else: return 0
    else:
      return 0


  def koopia(self):
     "Koopia"
     t=ArvuvahemikuliseVastusegaYlesanne(self.kysimus)
     t.alamPiir=self.alamPiir
     t.ylemPiir=self.ylemPiir
     t.oigeVastus=self.oigeVastus
     t.arvutusTyyp=self.arvutusTyyp
     t.normPunktid=self.normPunktid
     return t
     
       
class ProtsentYlesanne(YlAlus):
  "Protsendiarvutus mitmel moel"
  meta_type="ProtsentYlesanne"
  
  def __init__(self, uuskysimus):
    "Loomine"
    self.kysimus=uuskysimus
    self.kysitav=0 
      #0-protsent (aine/lahus), 1 lahusti, 2 aine, 3 aine/lahusti
    self.aineAlamPiir=10
    self.aineYlemPiir=100
    self.lahustiAlamPiir=110
    self.lahustiYlemPiir=1000
    self.lahustiTekst="vesi; destilleeritud vesi"
    self.lahustiYhik="g"
    self.aineTekst="sool; suhkur"
    self.aineYhik="g"
    self.vastuseTapsusProtsent=10
    self.aineKogus=-1
    self.lahustiKogus=-1
    self.tekitaAndmed()
    self.arvutusTyyp=0
    
  def tekitaAndmed(self):
    "Juhuslike algandmete loomine"
    import random
    self.aineKogus=self.aineAlamPiir+int(random.random()*(self.aineYlemPiir-self.aineAlamPiir))
    self.lahustiKogus=self.lahustiAlamPiir+int(random.random()*(self.lahustiYlemPiir-self.lahustiAlamPiir))
    
  def leiaProtsent(self):
    "Lahuse protsent"
    return 100*(float(self.aineKogus)/float(float(self.aineKogus)+float(self.lahustiKogus)))
    
  def juhusona(self, tekst, eraldaja=";"):
    "Juhuslik jupp eraldajatega lahutatud tekstist"
    import random
    m=tekst.split(eraldaja)
    return m[int(random.random()*len(m))]
        

  def taitmineHTML(self, REQUEST, elemendinimi):
    "Lahendajale"
    self.tekitaAndmed()
    tulemus="<input type='hidden' name='"+elemendinimi+"' value='"+str(self.aineKogus)+"' />"+\
       "<input type='hidden' name='"+elemendinimi+"' value='"+str(self.lahustiKogus)+"' />"+\
       "<input type='hidden' name='"+elemendinimi+"' value='"+str(self.kysitav)+"' />\n<table>"
    if self.kysitav==0:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td><input type='text' name='"+elemendinimi+"' /></td><td>%</td></tr>"      
    
    if self.kysitav==1:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td><input type='text' name='"+elemendinimi+"' /></td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td>"+str(round(self.leiaProtsent(), 2))+"</td><td>%</td></tr>"      
    
    if self.kysitav==2:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td><input type='text' name='"+elemendinimi+"' /></td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td>"+str(round(self.leiaProtsent(),2))+"</td><td>%</td></tr>"      
    
    if self.kysitav==3:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>Mitu protsenti moodutab <br /> teine esimesest: </td><td><input type='text' name='"+elemendinimi+"' /></td><td>%</td></tr>"      
      
    tulemus=tulemus+"</table>"
    return tulemus
    
  def ylesandeNimetus(self, REQUEST):
    "Nimetus"
    self.get_lang(('ivatests',), REQUEST)
    return REQUEST["L_it_percent_excercise"]
    
    
  def kysitavTekstina(self, REQUEST, nr=-1):
    "Küsitav suurus tekstina"
    self.get_lang(('ivatests',), REQUEST)
    if nr==-1: nr=self.kysitav
    nr=int(nr)
    #suurused=["Lahuse protsent", "Lahusti kogus", "Aine kogus", "Aine / lahusti"]
    suurused=[REQUEST["L_it_pr_term_solution_percent"], REQUEST["L_it_pr_term_solvent_amount"], REQUEST["L_it_pr_term_soluble_amount"], REQUEST["L_it_pr_term_soluble_to_solvent"] ]
    try:
     return suurused[nr]
    except:
     return "Probleem: "+nr
    
  def kasPaiknebVahemikus(self, pakutud, oige, nihkeprotsent):
    "abifunktsioon"
    import re
    import types
    try:
      if type(pakutud)==types.StringType:
        pakutud=re.sub(',', '.', pakutud)
      pakutud=float(pakutud)
    except:
      return 0
    if pakutud>=oige-oige*float(nihkeprotsent)/100 and \
       pakutud<=oige+oige*float(nihkeprotsent)/100:
         return 1
    return 0
    
  def paigutaPakutudAndmed(self):
    "Pakututest tagasi "
    import re
    self.aineKogus=float(re.sub(',', '.', self.pakutudAndmed[0]))
    self.lahustiKogus=float(re.sub(',', '.', self.pakutudAndmed[1]))
    self.kysitav=int(self.pakutudAndmed[2])
    return self.pakutudAndmed[3]
    self.pakutudAndmed[3]=float(re.sub(',', '.', self.pakutudAndmed[3]))

  def tegelikHTML(self, REQUEST):
    "Õpetaja lahendus"
    self.get_lang(('ivatests',),REQUEST)
    tulemus=""
    if self.vastusPakutud:
     self.paigutaPakutudAndmed()
     tulemus=tulemus+"<table>"+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"

     tulemus=tulemus+   "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"
     tulemus=tulemus+   "<tr><td>"+REQUEST["L_it_pr_term_solution_percent"]+": </td><td>"+str(round(self.leiaProtsent(), 2))+"%</td><td></td></tr>"
     tulemus=tulemus+   "<tr><td>"+REQUEST["L_it_pr_term_soluble_to_solvent"]+": </td><td>"+str(round(float(self.aineKogus)/float(self.lahustiKogus)*100, 2))+"% </td><td></td><td></td></tr>"
     tulemus=tulemus+   "</table>"      
    tulemus=tulemus+ REQUEST["L_it_pr_term_asking_answer"]+": "+str(self.kysitavTekstina(REQUEST))
    return tulemus    
    
  def vaatamineHTML(self, REQUEST):
     "Lahenduse vaatamine"     
     return self.tegelikHTML(REQUEST)
     
  def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed[3])
          
  def automaatPunkte(self):
    "Automaatselt arvutatav punktide arv"
    self.paigutaPakutudAndmed()
    if (not hasattr(self, 'arvutusTyyp')) or self.arvutusTyyp==0:
     if self.kasPihtas():
      return self.normPunktid
     else:
      return 0
    if self.arvutusTyyp==1: #lineaar
      return self.kuidasPihtas()*self.normPunktid
     
    
  def kasPihtas(self):
    "Pihtasarvutus"
    self.kysitav=int(self.kysitav)
    if self.kysitav==0:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], self.leiaProtsent(), float(self.vastuseTapsusProtsent))
    if self.kysitav==1:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], float(self.lahustiKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==2:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], float(self.aineKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==3:
      return (self.kasPaiknebVahemikus(self.pakutudAndmed[3], 100*float(self.aineKogus)/float(self.lahustiKogus), self.vastuseTapsusProtsent))
    return "probleem"      
         
    
  def kuidasPihtas(self):
    "Keskelt maksimumpunktidega lineaarne vahemik"
    self.kysitav=int(self.kysitav)
    if self.kysitav==0:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], self.leiaProtsent(), float(self.vastuseTapsusProtsent))
    if self.kysitav==1:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], float(self.lahustiKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==2:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], float(self.aineKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==3:
      return (self.lineaarProtsentSuhe(self.pakutudAndmed[3], 100*float(self.aineKogus)/float(self.lahustiKogus), self.vastuseTapsusProtsent))
    return "probleem"      
         
      


  def vastuseMuutmisVorm(self, REQUEST):
    "Ülesande koostamine"
    self.get_lang(('ivatests',), REQUEST)
    tulemus="<table>"+\
     "<tr><td>"+REQUEST["L_it_pr_soluble_amount_space"]+"</td><td><input type='text' name='vastus' value='"+str(self.aineAlamPiir)+"' />-<input type='text' name='vastus' value='"+str(self.aineYlemPiir)+"' /></td></tr>"+\
     "<tr><td>"+REQUEST["L_it_pr_solvent_amount_space"]+"</td><td><input type='text' name='vastus' value='"+str(self.lahustiAlamPiir)+"' />-<input type='text' name='vastus' value='"+str(self.lahustiYlemPiir)+"'/></td></tr>"+\
     "<tr><td>"+REQUEST["L_it_pr_soluble_names"]+"</td><td><input type='text' name='vastus' value='"+self.aineTekst+"' />, <input type='text' name='vastus' value='"+self.aineYhik+"' /></td></tr>"
    tulemus=tulemus+ "<tr><td>"+REQUEST["L_it_pr_solvent_names"]+"</td><td><input type='text' name='vastus'  value='"+self.lahustiTekst+"' />, <input type='text' name='vastus' value='"+self.lahustiYhik+"' /></td></tr>"+\
     "<tr><td>"+REQUEST["L_it_pr_answer_exactitude_percent"]+"</td><td><input type='text' name='vastus' value='"+str(self.vastuseTapsusProtsent)+"'></td></tr>"+\
     "<tr><td>"+REQUEST["L_it_pr_answer_type"]+"</td><td><select name='vastus'>"
    for i in range(4):
       tulemus=tulemus+"<option value='"+str(i)+"' "
       if i==self.kysitav:
         tulemus=tulemus+" SELECTED "
       tulemus=tulemus+">"+self.kysitavTekstina(REQUEST, i)+"</option>"
    tulemus=tulemus+"</select></td></tr>"
    tyybimargised=["", ""]
    tyybimargised[self.arvutusTyyp]=" selected "
      
    tulemus=tulemus+"<tr><td>"+REQUEST["L_it_pr_checking_type"]+"</td><td>"+\
        """
          <select name="arvutusTyyp">
            <option value="0" %s >%s</option>
            <option value="1" %s >%s</option>
          </select>
         </td></tr>
        """ % (tyybimargised[0], REQUEST["L_it_pr_space"], tyybimargised[1], REQUEST["L_it_pr_linear"])
    tulemus=tulemus+"</td></tr></table>"
    return tulemus
     

  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Andmete talletus"
     import re
     self.aineAlamPiir=float(re.sub(',', '.', vastus[0]))
     self.aineYlemPiir=float(re.sub(',', '.',vastus[1]))    
     self.lahustiAlamPiir=float(re.sub(',', '.',vastus[2]))
     self.lahustiYlemPiir=float(re.sub(',', '.',vastus[3]))
     self.aineTekst=vastus[4]
     self.aineYhik=vastus[5]
     self.lahustiTekst=vastus[6]
     self.lahustiYhik=vastus[7]
     self.vastuseTapsusProtsent=float(re.sub(',', '.',vastus[8]))
     self.kysitav=int(vastus[9])
     if hasattr(REQUEST, "arvutusTyyp"):
       self.arvutusTyyp=int(REQUEST["arvutusTyyp"])


     
  def koopia(self):
    "Koopia ülesandest"
    t=ProtsentYlesanne(self.kysimus)
    t.aineAlamPiir=self.aineAlamPiir
    t.aineYlemPiir=self.aineYlemPiir
    t.lahustiAlamPiir=self.lahustiAlamPiir
    t.lahustiYlemPiir=self.lahustiYlemPiir
    t.aineTekst=self.aineTekst
    t.aineYhik=self.aineYhik
    t.lahustiTekst=self.lahustiTekst
    t.lahustiYhik=self.lahustiYhik
    t.vastuseTapsusProtsent=self.vastuseTapsusProtsent
    t.kysitav=self.kysitav
    t.arvutusTyyp=self.arvutusTyyp
    t.normPunktid=self.normPunktid
    return t



class VastavusYlesanne(YlAlus):
    "Variantide kokkusobitamine"
    meta_type="VastavusYlesanne"
    security=ClassSecurityInfo()
    security.declareObjectPublic()

    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
        
    def ylesandeNimetus(self, REQUEST):
        "Ülesande tüübi nimi"
        self.get_lang(('ivatests',), REQUEST)
        return REQUEST['L_it_matching_exercise']
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Lahendaja sisestus"
        tulemus="<table>"
        for i in range(len(self.kysimused)):
          tulemus=tulemus+"<tr><td>"+self.kysimused[self.jarjestus[i]]+"</td><td>"
          tulemus=tulemus+"<select name='"+elemendinimi+"'>"
          for j in range(len(self.vastused)):
            tulemus=tulemus+"<option value='"+str(j)+"'>"+self.vastused[j]+"</option>\n"
          tulemus=tulemus+"</select></td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def tegelikHTML(self, REQUEST):
        "Õpetaja lahendus"
        tulemus="<table>"
        for i in range(len(self.jarjestus)):
          tulemus=tulemus+"<tr><td>"+self.kysimused[self.jarjestus[i]]+\
            "</td><td>"+self.vastused[self.jarjestus[i]]+"</td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduse vaatamine"
        return self.tegelikHTML(REQUEST)
        
    
        
    def pakutudHTML(self, REQUEST):
       "Pakutud andmete esitus veebis"
       self.get_lang(('ivatests',),REQUEST)
       tulemus=""
       if self.vastusPakutud:
         tulemus=tulemus+"<table>"
         for i in range(len(self.kysimused)):
           tulemus=tulemus+"<tr><td>"+self.kysimused[i]+"</td><td>"+\
             self.vastused[int(self.pakutudAndmed[i])]+"</td></tr>\n"
         tulemus=tulemus+"</table>"
       return tulemus
       
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        self.get_lang(('ivatests',),REQUEST)
        tulemus="<table><tr><td>"+REQUEST['L_it_mt_left']+"</td><td>"+REQUEST['L_it_mt_right']+"</td></tr>"
        for i in range(len(self.kysimused)):
          tulemus=tulemus+"<tr><td><input type='text' name='kys' value='"+\
            self.kysimused[i]+"' /></td><td><input type='text' name='vastus' value='"+\
            self.vastused[i]+"' /></td></tr>\n"
        tulemus=tulemus+"<tr><td><input type='text' name='kys' /></td>"+\
          "<td><input type='text' name='vastus' ></td></tr>\n"
        tulemus=tulemus+"<tr><td><input type='text' name='kys' /></td>"+\
          "<td><input type='text' name='vastus' ></td></tr>\n"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def vastuseMuutmisLeht(self, REQUEST, vastus=None):
        "Vastuse salvestamine, üle kaetud"
        if REQUEST is None: return
        if hasattr(REQUEST, 'kys'):
          kys=getattr(REQUEST, 'kys')
        else:
          kys=()
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        if type(kys) is types.StringType:
          vastus=(kys,) 
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
#        for x in kys:
#          self.kysimused.append(x)
#        for x in vastus:
#          self.vastused.append(x)
        for i in range(len(kys)):
          if len(kys[i])>0:
            self.kysimused.append(kys[i])
            self.vastused.append(vastus[i])
        for i in range(len(self.kysimused)):
          self.jarjestus.append(i)
        import random
        random.shuffle(self.jarjestus)
    
       
    def automaatPunkte(self):
       "Automaatne punktide arv"
       kokku=0
       for i in range(len(self.jarjestus)):
         if self.jarjestus[i]==int(self.pakutudAndmed[i]):
           kokku=kokku+1
       if len(self.jarjestus)==0:
         return self.normPunktid
       return float(kokku)/float(len(self.jarjestus))*self.normPunktid
       
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        tulemus=":TYPE:M:long:long:E:1\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        for i in range(len(self.kysimused)):
          tulemus=tulemus+":L"+str(i+1)+"\n"+self.kysimused[i]+"\n:R"+\
           str(i+1)+"\n"+self.vastused[i]+"\n"
	return tulemus
    
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
        nr=0
        for i in range(len(reamassiiv)):
          if reamassiiv[i].split(":")[1]=="QUESTION":
            self.kysimus=reamassiiv[i+1]
          if reamassiiv[i].split(":")[1][0]=="L":
            self.kysimused.append(reamassiiv[i+1])
            self.vastused.append(reamassiiv[i+3])
        for i in range(len(self.kysimused)):
          self.jarjestus.append(i)
        import random
        random.shuffle(self.jarjestus)
        
    
    def koopia(self):
       "Koopia ylesandest"
       t=VastavusYlesanne(self.kysimus)
       for x in self.kysimused:
         t.kysimused.append(x)
       for x in self.vastused:
         t.vastused.append(x)
       for x in self.jarjestus:
         t.jarjestus.append(x)
       t.normPunktid=self.normPunktid
       return t
 




#------------------------------------- Julia ülesanne ----------------------------------------
# 7648552
#----------



class TaisnurkneKolmnurk(YlAlus):
  "Täisnurkse kolmnurga hüpotenuusi leidmine"
  meta_type="TaisnurkneKolmnurk"
  
  def __init__(self, uuskysimus):
    "Loomine"
    self.kysimus=uuskysimus
    self.kaateti1AlamPiir=1
    self.kaateti1YlemPiir=30
    self.kaateti2AlamPiir=1
    self.kaateti2YlemPiir=30
    self.vastuseTapsus=0.01
    self.kaatet1=-1
    self.kaatet2=-1
    self.tekitaAndmed()
    self.arvutusTyyp=0
    
  def tekitaAndmed(self):
    "Juhuslike algandmete loomine"
    import random
    self.kaatet1=self.kaateti1AlamPiir+int(random.random()*(self.kaateti1YlemPiir-self.kaateti1AlamPiir))
    self.kaatet2=self.kaateti2AlamPiir+int(random.random()*(self.kaateti2YlemPiir-self.kaateti2AlamPiir))


  def leiaOigeVastus(self):
    "Hüpotenuusi pikkus"
    return sqrt(self.kaatet1*self.kaatet1+self.kaatet2*self.kaatet2)

  def taitmineHTML(self, REQUEST, elemendinimi):
    "Lahendajale"
    self.tekitaAndmed()
    tulemus="<input type='hidden' name='"+elemendinimi+"' value='"+str(self.kaatet1)+"' />"+\
       "<input type='hidden' name='"+elemendinimi+"' value='"+str(self.kaatet2)+"' />\n<table>"
    tulemus=tulemus+\
       "<tr><td>Esimene kaatet on: </td><td>"+str(self.kaatet1)+"</td><td>cm</td></tr>"+\
       "<tr><td>Teine kaatet on: </td><td>"+str(self.kaatet2)+"</td><td>cm</td></tr>"+\
       "<tr><td>H&uuml;potenuusi pikkus on: </td><td><input type='text' name='"+elemendinimi+"' /></td><td>cm (t&auml;psusega "+str(self.vastuseTapsus)+" cm)</td></tr>"      
    tulemus=tulemus+"</table>"
    return tulemus

  def ylesandeNimetus(self, REQUEST):
    "Nimetus"
    return "T&auml;isnurkse kolmnurga h&uuml;potenuusi leidmine"
    
  def kasPaiknebVahemikus(self, pakutud, oige, nihe):
    "abifunktsioon"
    import re
    import types
    try:
      if type(pakutud)==types.StringType:
        pakutud=re.sub(',', '.', pakutud)
      pakutud=float(pakutud)
    except:
      return 0
    if ((pakutud-oige)<nihe) and ((pakutud-oige)>(-nihe)):
      return 1
    return 0
    
  def paigutaPakutudAndmed(self):
    "Pakututest tagasi "
    import re
    self.kaatet1=float(re.sub(',', '.', self.pakutudAndmed[0]))
    self.kaatet2=float(re.sub(',', '.', self.pakutudAndmed[1]))
    return self.pakutudAndmed[2]
    self.pakutudAndmed[2]=float(re.sub(',', '.', self.pakutudAndmed[2]))

  def tegelikHTML(self, REQUEST):
    "Õpetaja lahendus"
    self.get_lang(('ivatests',),REQUEST)
    tulemus=""
    if self.vastusPakutud:
     self.paigutaPakutudAndmed()
     tulemus=tulemus+"<table>"+\
        "<tr><td>Esimene kaatet: </td><td>"+str(self.kaatet1)+"</td><td>cm</td></tr>"
     tulemus=tulemus+   "<tr><td>Teine kaatet: </td><td>"+str(self.kaatet2)+"</td><td>cm</td></tr>"
     tulemus=tulemus+   "<tr><td>H&uuml;potenuus: </td><td>"+str(round(self.leiaOigeVastus(), 2))+" cm</td><td></td></tr>"
     tulemus=tulemus+   "</table>"
    return tulemus    
    
  def vaatamineHTML(self, REQUEST):
     "Lahenduse vaatamine"     
     return self.tegelikHTML(REQUEST)
     
  def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed[3])
          
  def automaatPunkte(self):
    "Automaatselt arvutatav punktide arv"
    self.paigutaPakutudAndmed()
    if self.kasPihtas():
      return self.normPunktid
    else:
      return 0
     
    
  def kasPihtas(self):
    "Pihtasarvutus"
    return self.kasPaiknebVahemikus(self.pakutudAndmed[3], self.leiaOigeVastus(), float(self.vastuseTapsus))
    
  def vastuseMuutmisVorm(self, REQUEST):
    "Ülesande koostamine"
    self.get_lang(('ivatests',), REQUEST)
    tulemus="<table>"+\
     "<tr><td>Esimese kaateti vahemik: </td><td><input type='text' name='vastus' value='"+str(self.kaateti1AlamPiir)+"' />-<input type='text' name='vastus' value='"+str(self.kaateti1YlemPiir)+"' /></td></tr>"+\
     "<tr><td>Teise kaateti vahemik: </td><td><input type='text' name='vastus' value='"+str(self.kaateti2AlamPiir)+"' />-<input type='text' name='vastus' value='"+str(self.kaateti2YlemPiir)+"'/></td></tr>"+\
     "<tr><td>Vastuse t&auml;psus: </td><td><input type='text' name='vastus' value='"+str(self.vastuseTapsus)+"'></td></tr>"
    tulemus=tulemus+"</table>"
    return tulemus

  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Andmete talletus"
     import re
     self.kaateti1AlamPiir=float(re.sub(',', '.', vastus[0]))
     self.kaateti1YlemPiir=float(re.sub(',', '.',vastus[1]))    
     self.kaateti2AlamPiir=float(re.sub(',', '.',vastus[2]))
     self.kaateti2YlemPiir=float(re.sub(',', '.',vastus[3]))
     self.vastuseTapsus=float(re.sub(',', '.',vastus[4]))
     
  def koopia(self):
    "Koopia ülesandest"
    t=TaisnurkneKolmnurk(self.kysimus)
    t.kaateti1AlamPiir=self.kaateti1AlamPiir
    t.kaateti1YlemPiir=self.kaateti1YlemPiir
    t.kaateti2AlamPiir=self.kaateti2AlamPiir
    t.kaateti2YlemPiir=self.kaateti2YlemPiir
    t.vastuseTapsus=self.vastuseTapsus
    t.normPunktid=self.normPunktid
    return t
    
#----------------------------------------------------------------------------------------------