# -*- coding: utf-8
# $Id$
#
# Copyright 2001, 2002 by IVA Team and contributors
#
# This file is part of IVA.
#
# IVA is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# IVA is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with IVA; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

import AccessControl
import OFS, Globals
import types
from OFS import SimpleItem
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import translate, perm_edit
from input_checks import strip_tags
#from YlTyybid import ValikYlesanne

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

    def punkte(self):
        "Arvestatavate punktide arv"
        if self.kasPunktiArvutus():
            if self.annaOpetajaPunktid() is not None:
                return self.annaOpetajaPunktid()
            return self.automaatPunkte()
        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"
        import re
        try:
            punktid=re.sub(',', '.', punktid)
            self.normPunktid=float(punktid)
            return ""
        except:
            self.normPunktid=0
            return translate(self,'Invalid score',target=self.giveLanguage(REQUEST))
        
    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"):
            return str(self.opetajaKommentaar)
        else:
            return ""
          
    def opetajaKommentaarHTML(self, REQUEST):
        "Kodeeritult"
        return strip_tags(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"
        try:
            if not self.kasLubatudLahendada(REQUEST):
                return ":-("
        except AttributeError:
            pass
        return strip_tags(self.kysimus)
        
    def viideHTML(self, REQUEST):
        "Vajutatav viide HTML-kodeeritult"
        try:
            if not self.kasLubatudLahendada(REQUEST):
                return ":-("
        except AttributeError:
            pass
        try:
            if self.viiteURL=="" or self.viiteTekst=="":
                return ""
            return "<br /><a href='"+self.viiteURL+"'>"+strip_tags(self.viiteTekst)+"</a>"
        except:
            return ""
  
    security.declareProtected(perm_edit, 'getDescription')
    def getDescription(self,REQUEST):
        """ doc """
        REQUEST.RESPONSE.setHeader('Content-Type', 'text/html')
        tekst = self.kirjeldavTekst+" "+self.kysimus
        return tekst
          
    def annaKirjeldavTekst(self, REQUEST):
        "Kirjeldav tekst"
        try:
            if not self.kasLubatudLahendada(REQUEST):
                return ":-("
        except AttributeError:
            pass
        REQUEST.RESPONSE.setHeader('Content-type', 'text/html; charset=UTF-8')
        if self.kysimus:
            self.kirjeldavTekst += self.kysimus
            self.kysimus = ""
        return self.kirjeldavTekst+"  "+self.kysimus
         
    def kirjeldavTekstHTML(self, REQUEST):
        "Kirjeldav tekst kodeeritult"
        if not self.kasLubatudLahendada(REQUEST):
            return ":-("
        return strip_tags(self.annaKirjeldavTekst(REQUEST))
       
    def seaKirjeldavTekst(self, REQUEST, tekst):
        "Teksti seadmine"
        self.kirjeldavTekst=tekst
          
    def esitlusHTML(self, REQUEST):
        """Küsimus koos ilustustega"""
        try:
            if not self.kasLubatudLahendada(REQUEST):
                return ""
        except AttributeError:
            pass
        tulemus=""
        if self.annaKirjeldavTekst(REQUEST)!="":
            tulemus=tulemus+self.annaKirjeldavTekst(REQUEST)+"<br />"
        return tulemus+self.kysimusHTML(REQUEST)+self.viideHTML(REQUEST)

    def _getQuestionHTML(self):
         """ get question and describing text """
         if self.kysimus:
             self.kirjeldavTekst += self.kysimus
             self.kysimus = ""
         res = self.kirjeldavTekst+"  "+self.kysimus
         res += strip_tags(self.kysimus)

         if self.viiteURL or self.viiteTekst:
             res += "<br /><a href='"+self.viiteURL+"'>"+strip_tags(self.viiteTekst)+"</a>"
         return res

    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"
        if not self.kasLubatudLahendada(REQUEST):
            return ":-("
        tekst='L_it_describing_text'+":<br />\n<textarea name='"+elemendiNimi+"'>"+self.annaKirjeldavTekst(REQUEST)+"</textarea>"
        return tekst

    def kysimusVormis(self, REQUEST, elemendiNimi="kysimus"):
        if not self.kasLubatudLahendada(REQUEST):
            return ":-("
        return 'L_it_ex_question'+""":<br /><input type="text" name="%s" value="%s" />"""  % (elemendiNimi, self.kysimusHTML(REQUEST))
        
    def viideVormis(self, REQUEST):
        "Viite vorm"
        if not self.kasLubatudLahendada(REQUEST):
            return ":-("
        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>
        
        """ % (translate(self, 'L_it_link_url', target=self.giveLanguage(REQUEST)), url, translate(self, 'L_it_link_text', target=self.giveLanguage(REQUEST)), tekst)
        
    def normPunktidVormis(self, REQUEST):
        "Täispunktide sisestusvorm"
        arvutus=""
        if not self.kasPunktiArvutus():
            arvutus="<br />"+translate(self, 'n/a', target=self.giveLanguage(REQUEST))
        return "<br />"+translate(self, 'Maximum number of points for this question', target=self.giveLanguage(REQUEST))+":<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 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 muutmisLeht(self, REQUEST, kysimus="", vastus=None, 
        viiteURL=None, viiteTekst=None, pilt=None, 
        kustutaPilt=0, normPunktid=0, liikumisURL='muutmisVorm',
        kirjeldavTekst='', keyword=(), title="", kupu=''):
        """ Muutmisvormi andmete püüdja """
        probleem=""
        self.kysimus=kysimus
        #return "pikkus: "+str(len(kirjeldavTekst.strip()))
        #if len(kirjeldavTekst.strip())<5:
        if len(kupu)<5:
            probleem+=translate(self, 'You have not entered question!', target=self.giveLanguage(REQUEST))+"<br />"
        import re
        tmp = re.search('<body[^>]*>(.*?)</body>', kupu).group()
        tmp = re.sub('<body>', '', tmp)
        tmp = re.sub('</body>', '', tmp)
        tmp = re.sub('target="_self"', 'target="_blank"', tmp)
        kirjeldavTekst = tmp
        probleem+=self.vastuseMuutmisLeht(REQUEST, vastus)
        #self.seaKirjeldavTekst(kirjeldavTekst)
        self.kirjeldavTekst=kirjeldavTekst
        self.meta.keywords=[]
        for k in keyword:
            if k.strip():
                if not k in self.meta.keywords:
                    self.meta.keywords.append(k)
        self.meta.title=title
        self.meta.ex_changed=1
        self.meta.uname=str(REQUEST.AUTHENTICATED_USER)
        probleem=probleem+self.viiteSalvestusLeht(REQUEST, viiteURL, viiteTekst)
        probleem=probleem+self.pildiSalvestusLeht(pilt, kustutaPilt)
        probleem=probleem+self.seaNormPunktid(REQUEST, normPunktid)
        if probleem:
            return self.message_dialog(self, REQUEST, 
                    title='Error',
                    message=probleem,
                    action=self.absolute_url()+"/kupuform"
                    )
        return REQUEST.RESPONSE.redirect('../ylesandedMuutmisTabelina')
        
        
    def vastuseMuutmisLeht(self, REQUEST=None, vastus=''):
        "Leht vastuse muutmiseks, soovitav üle katta"   
        return ""
        
    def viiteSalvestusLeht(self, REQUEST, viiteURL, viiteTekst):
        if (viiteURL is None or viiteURL==""):
            if(viiteTekst is None or viiteTekst==""):
                return ""
            else:
                return 'Address missing'
        if not self.viiteSobivusKontroll(viiteURL):
            return 'Invalid 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"
        if not self.kasLubatudLahendada(REQUEST):
            return ""
        return self.defaultRender(page=self.kirjeldavTekstHTML(REQUEST)+\
         "<table><tr><td>"+self.esitlusHTML(REQUEST)+"</td>"+\
           "<td>"+self.vaatamineHTML(REQUEST)+"</td></tr></table>")
        
    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

    def lisaMeta(self, REQUEST):
        "Lisatakse ülesandele metaandmestik. Täidetakse võimaluse korral testist ja kursusest võetud andmetega."
        if hasattr(self, 'metaandmed'):
            return self.metaandmed
        import YlMeta
        from YlMeta import YlMeta
        meta=YlMeta()
        self._setObject('meta', meta)
        return self.meta
       
    def lisaPilt(self, REQUEST, pilt, pos, raam):
        "Ãlesande külg salvestatakse pilt"
        if not hasattr(self, 'pildid'):
            self.pildid=[]
        if len(pilt.filename)>0:
            self.pildid.append(pilt.read())
            self.pildid=self.pildid
        return """
         <html><body>
           <script>
             aken=opener.document.getElementById('irm').contentWindow;
             see="%s";
             aken.focus();
             aken.document.execCommand('insertimage',false,see);
             plt=(document.selection)?aken.document.selection.createRange()(0):aken.getSelection().getRangeAt(0).commonAncestorContainer.childNodes.item(0);
             plt.setAttribute('align',"%s");
             plt.setAttribute('border',"%s");
           </script>
         </body></html>
        """ %  (self.id+"/kysiPilt?pildinr="+str(len(self.pildid)-1), pos, raam)
       
       
    def kysiPilt(self, REQUEST, pildinr):
        "VÃljastatakse soovitud jarjekrranumbriga pilt"
        if not hasattr(self, 'pildid'):
            self.pildid=[]
        if int(pildinr)>=len(self.pildid):
            return "pole sellist pilti"
        REQUEST.RESPONSE.setHeader('Content-type', 'image/jpeg')
        return self.pildid[int(pildinr)]
       
Globals.InitializeClass(YlAlus)
Globals.default__class_init__(YlAlus)