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

class YlAlus(
     Persistent,
     OFS.SimpleItem.Item,
     Traversable,
     AccessControl.Role.RoleManager
     ):
     "Testi ülesanne"
     meta_type="YlAlus"
     kysimus="Ülesande küsimus"
     viiteURL=""
     viiteTekst=""
     pilt=None
     kirjeldavTekst=""
     vastusPakutud=0
     tostuTundlik=1
     opetajaPunktid=None
     opetajaKommentaar=""
     normPunktid=10
     punktiArvutus=1

     def ylesandeNimetus(self, REQUEST):
       "Ülesande tüübi nimi"
#       return self.meta_type

     def punkte(self):
        "Arvestatavate punktide arv"
        if self.kasPunktiArvutus():
          if self.annaOpetajaPunktid() is not None:
            return self.annaOpetajaPunktid()
          else:
            return self.automaatPunkte()
          
        
     def automaatPunkte(self):
        "Kaetakse punktiarvutusel üle"
        return "X"
        
     def annaNormPunktid(self):
        "Võimalik normijärgsete maksimumpunktide arv vastavas ülesandes"
        return self.normPunktid
        
     def normPunktidHTML(self, REQUEST):
        "Väljund tabelisse"
        if self.kasPunktiArvutus():
          return str(self.annaNormPunktid())
        else:
          return "-/"+str(self.annaNormPunktid())
        
     def seaNormPunktid(self, REQUEST, punktid):
        "Normpunktide salvestus"
        self.get_lang(('ivatests',),REQUEST)
        import re
        try:
          punktid=re.sub(',', '.', punktid)
          self.normPunktid=float(punktid)
          return ""
        except:
          self.normPunktid=0
          return REQUEST['L_it_incorrect_point_count']
        
     def kasPunktiArvutus(self):
        "Kas vastav ülesanne on punktiarvutuse osa"
        try:
          return self.punktiArvutus
        except:
          return 0
        
     def seaPunktiArvutus(self, olek):
        "Punktiarvutus"
        if olek:
          self.punktiArvutus=1
        else:
          self.punktiArvutus=0
        
     def seaOpetajaKommentaar(self, kommentaar):
        "Õpetaja kommentaar lahendusele"
        self.opetajaKommentaar=kommentaar
        
     def annaOpetajaKommentaar(self):
        "Antakse kui on"
        if hasattr(self, "opetajaKommentaar"):
#         if type(self.opetajaKommentaar) is types.StringType:
          return str(self.opetajaKommentaar)
#         return "Vigane kommentaar"
        else:
          return ""
          
     def opetajaKommentaarHTML(self, REQUEST):
        "Kodeeritult"
        return YlTest.asendaHTML(self.annaOpetajaKommentaar())
          
     def seaOpetajaPunktid(self, punktid):
        "Õpetaja pakutud punktid lahendusele"
        if punktid is None:
          self.opetajaPunktid=None
          return
        try:
          self.opetajaPunktid=float(punktid)
          if float(punktid)==int(punktid):
            self.opetajaPunktid=int(punktid)
        except:
          pass
        
     def annaOpetajaPunktid(self):
        "Antakse kui on"
        if self.kasPunktiArvutus():
          if hasattr(self, "opetajaPunktid"):
            return self.opetajaPunktid
          else:
            return None
        return "-"
        
     def kysimusHTML(self, REQUEST):
        "Küsimus HTML-kodeeritult"
        import YlTest
        return YlTest.asendaHTML(self.kysimus)
        
     def viideHTML(self, REQUEST):
        "Vajutatav viide HTML-kodeeritult"
        try:
          if self.viiteURL=="" or self.viiteTekst=="":
             return ""
          return "<br /><a href='"+self.viiteURL+"'>"+YlTest.asendaHTML(self.viiteTekst)+"</a>"
        except:
          return ""
          
     def annaKirjeldavTekst(self, REQUEST):
       "Kirjeldav tekst"
       if hasattr(self, 'kirjeldavTekst'):
         return self.kirjeldavTekst
       else:
         return ""
         
     def kirjeldavTekstHTML(self, REQUEST):
       "Kirjeldav tekst kodeeritult"
       return YlTest.asendaHTML(self.annaKirjeldavTekst(REQUEST))
       
     def seaKirjeldavTekst(self, REQUEST, tekst):
       "Teksti seadmine"
       self.kirjeldavTekst=tekst
       
          
     def piltHTML(self, REQUEST):
        if self.kasPilt():
          return "<br /><img src='"+self.absolute_url()+"/naitaPilti'>"
        else:
          return ""
          
     def esitlusHTML(self, REQUEST):
        "Küsimus koos ilustustega"
        tulemus=""
        if self.annaKirjeldavTekst(REQUEST)!="":
          tulemus=tulemus+self.annaKirjeldavTekst(REQUEST)+"<br />"
        return tulemus+self.kysimusHTML(REQUEST)+self.viideHTML(REQUEST)+self.piltHTML(REQUEST)
        
     def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "Täitmiseks mõeldud osa"
        
     def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        return "Variantide vaatamiseks mõeldud osa"


     def kasPihtasArvutus(self):
       "Kas uuritakse tabamust"
       return 0

     def kasPihtasHTML(self, REQUEST):
        "Kas saadi vastusega pihta"
        if self.kasPihtasArvutus():
           if self.kasPihtas():
              return "+"
           else:
              return "-"
        else:
           return "Tabamust ei uurita"

     def kasPihtas(self):
        "Sisemine uuring alamklassis"
        return 0
        
     def tegelikHTML(self, REQUEST):
        "Opetaja pakutud oige vastus"
        return "Ainuoige lahendus puudub"
        
     def kirjeldavTekstVormis(self, REQUEST, elemendiNimi="kirjeldavTekst"):
        "Ülesannet kirjeldav tekst"
        self.get_lang(('ivatests',), REQUEST)
        tekst=REQUEST['L_it_describing_text']+":<br />\n<textarea name='"+elemendiNimi+"'>"+self.annaKirjeldavTekst(REQUEST)+"</textarea>"
        return tekst

     def kysimusVormis(self, REQUEST, elemendiNimi="kysimus"):
        return REQUEST['L_it_ex_question']+""":<br /><input type="text" name="%s" value="%s" />"""  % (elemendiNimi, self.kysimusHTML(REQUEST))
        
     def viideVormis(self, REQUEST):
        "Viite vorm"
        self.get_lang(('ivatests',), REQUEST)
        url=tekst=""
        try:
          url=self.viiteURL
          tekst=self.viiteTekst
        except:
          pass
        return """
         <table>
          <tr>
           <td>%s:</td>
           <td><input type="text" name="viiteURL" value="%s" /></td>
          </tr>
          <tr>
           <td>%s:</td>
           <td><input type="text" name="viiteTekst" value="%s" /></td>
          </tr>
         </table>
        
        """ % (REQUEST['L_it_link_url'], url, REQUEST['L_it_link_text'], tekst)
        

     def piltVormis(self, REQUEST):
        "Pildi vorm"
        self.get_lang(('ivatests',), REQUEST)
        return  REQUEST['L_it_picture']+""": <br />
          <input type="file" name="pilt" /><br />
          <input type="checkbox" name="kustutaPilt" /> """+REQUEST['L_it_delete_picture']+"""<br />
        """ + self.piltHTML(REQUEST)
        
     def normPunktidVormis(self, REQUEST):
        "Täispunktide sisestusvorm"
        self.get_lang(('ivatests',), REQUEST)
        arvutus=""
        if not self.kasPunktiArvutus():
          arvutus="<br />"+REQUEST['L_it_no_automatic_point_calculating']
        return "<br />"+REQUEST['L_it_nominal_points']+":<br />"+\
         "<input type='text' name='normPunktid' value='%s' /> %s" % (str(self.annaNormPunktid()), arvutus)
        
        


     def kasPilt(self):
       "Kas pilt olemas"
       if not hasattr(self, "pilt"):
         return 0
       if self.pilt is None:
         return 0
       return 1   
        
     def naitaPilti(self, REQUEST):
       "Pildiväljastus"
       if self.kasPilt():
         REQUEST.RESPONSE.setHeader('content-type', 'image/jpeg')
         return self.pilt
       else:
         return "Pilt puudub"
        
     def vastuseMuutmisVorm(self, REQUEST):
        "Muutmisvormi elemendid vastusepoole andmete näitamiseks, soovitav üle katta, elemendi nimeks vastus"
        return "Vastamiskoht"

     def leivaPuru(self, REQUEST, viimane=0):
        "Teekond üles"
        nimi=self.id
        if viimane:
          tekst=self.id
        else:
          tekst="<a href='"+self.absolute_url()+"'>"+str(self.id)+"</a>"
        return self.aq_parent.leivaPuru(REQUEST)+" &gt; "+tekst

     def muutmisVorm(self, REQUEST, liikumisURL=None):
        "Testi muutmiseks mõeldud leht, üle katta vaid juhul, kui vaja muuta enam kui ühe elemendinimega vastuseosa"
        self.get_lang(('ivatests',), REQUEST)
        liiguvali=""
        if liikumisURL is not None:
          liiguvali="<input type='hidden' name='liikumisURL' value='"+liikumisURL+"' />"
        tulemus=YlTest.leheAlgus(self, REQUEST)+"<h2>"+self.ylesandeNimetus(REQUEST)+"</h2>"\
          "<form action='muutmisLeht' method='POST' enctype='multipart/form-data'>"+liiguvali+\
          self.kirjeldavTekstVormis(REQUEST)+\
          "<table><tr>"+\
          "<td valign='top'>"+self.kysimusVormis(REQUEST)+"</td>"+\
          "<td valign='top'>"+self.vastuseMuutmisVorm(REQUEST)+"</td></tr>"+\
          "</table><br />"+self.viideVormis(REQUEST)+"<br />"+\
          self.piltVormis(REQUEST)+self.normPunktidVormis(REQUEST)+\
          "<br /><input type='submit' value='"+REQUEST['L_it_ex_save']+"' /></form>"
        return tulemus+YlTest.leheLopp(self, REQUEST)
        
     def muutmisLeht(self, REQUEST, kysimus=None, vastus=None, 
         viiteURL=None, viiteTekst=None, pilt=None, 
         kustutaPilt=0, normPunktid=0, liikumisURL='muutmisVorm',
         kirjeldavTekst=''):
        "Muutmisvormi andmete püüdja"
        probleem=""
        if kysimus:
          self.kysimus=kysimus
        try:
          self.vastuseMuutmisLeht(REQUEST, vastus)
        except:
          self.vastuseMuutmisLeht(vastus)
        self.kirjeldavTekst=kirjeldavTekst
        probleem=probleem+self.viiteSalvestusLeht(REQUEST, viiteURL, viiteTekst)
        probleem=probleem+self.pildiSalvestusLeht(pilt, kustutaPilt)
        probleem=probleem+self.seaNormPunktid(REQUEST, normPunktid)
        if probleem:
          return probleem
        REQUEST.RESPONSE.redirect(liikumisURL)
        
        
     def vastuseMuutmisLeht(self, vastus):
        "Leht vastuse muutmiseks, soovitav üle katta"   
        pass
        
     def viiteSalvestusLeht(self, REQUEST, viiteURL, viiteTekst):
        self.get_lang(('ivatests',), REQUEST)
        if (viiteURL is None or viiteURL==""):
           if(viiteTekst is None or viiteTekst==""):
             return ""
           else:
             return REQUEST['L_it_no_link_address']
        if not self.viiteSobivusKontroll(viiteURL):
           return REQUEST['L_it_incorrect_URL']
        if viiteTekst is None or viiteTekst=="":
           viiteTekst=viiteURL
        self.viiteURL=viiteURL
        self.viiteTekst=viiteTekst
        return ""
        
     def pildiSalvestusLeht(self, pilt, kustutaPilt):
        if kustutaPilt:
           self.pilt=None
        if pilt is None:
           return ""
        try:
         if len(pilt.filename)>0:
          self.pilt=pilt.read()
        except:
          pass
        return ""
           
        
     def viiteSobivusKontroll(self, viiteURL):
       return 1   
        
     def vahemikuTabavusSuhe(self, vastus, ala, kesk, yla):
       "Väljastatakse, kui suur osa saadi saadi tabavusmaksimumist"
       vastus=float(vastus)
       ala=float(ala)
       kesk=float(kesk)
       yla=float(yla)
       if ala>yla: return 0
       if kesk<ala: return 0
       if kesk>yla: return 0
       if vastus<ala: return 0
       if vastus>yla: return 0
       if vastus>=ala and vastus<=kesk:
         return (vastus-ala)/(kesk-ala)
       if vastus>=kesk and vastus <= yla:
         return  (yla-vastus)/(yla-kesk)
       return 0
       
     def lineaarProtsentSuhe(self, vastus, oige, protsent):
       """Pakutav vastus võib õige suhtes kuni määratud protsendi jagu
          kõikuda. Täpselt pihta saamisel on suhteks 1.0, muidu kahaneb
          lineaarselt kuni nullini kogu lubatud ulatusest välja nihkudes."""
       try:
         vastus=float(vastus)
         oige=float(oige)
         protsent=float(protsent)
         nihe=oige*protsent/100.0
       except:
         return 0
       return self.vahemikuTabavusSuhe(vastus, oige-nihe, oige, oige+nihe)
          


     def index_html(self, REQUEST):
        "Peegel veebis"
        import YlTest
        return YlTest.leheAlgus(self, REQUEST)+\
         self.kirjeldavTekstHTML(REQUEST)+\
         "<table><tr><td>"+self.esitlusHTML(REQUEST)+"</td>"+\
           "<td>"+self.vaatamineHTML(REQUEST)+"</td></tr></table>"+YlTest.leheLopp(self, REQUEST)
        
     def kustuta(self):
        "Ülesanne kustutatakse"
        self.aq_parent._delObject(self.id)
        
    
     def koopia(self):
        "samade andmetega ülesanne"
        import copy
        return copy.copy(self)
        
          
     def loeTekstistYlesanne(self, reamassiiv):
       "Loeb andmed saadetud tekstist, üle katta"
       
     def kirjutaYlesanneTekstiks(self, testinimi, nr):
       "Väljastab ülesande tekstina, üle katta"
       return ""
          
     def salvestaPakutu(self, andmed):
       "Loob koopia ülesandest koos pakutud vastusega"
       k=self.koopia()
       k.id=self.id
       k.vastusPakutud=1
       k.pakutudAndmed=andmed
       return k
       
Globals.InitializeClass(YlAlus)
Globals.default__class_init__(YlAlus)
