# -*- coding: utf-8 -*-

# Copyright 2009 Manik Bhattacharjee (manik-listes at altern.org)
#
# This file is part of PyVote.
#
# PyVote 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 3 of the License, or
# (at your option) any later version.
#
# PyVote 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 PyVote.  If not, see <http://www.gnu.org/licenses/>.


#
# Crée une fenetre de dialogue permettant de voter pour le Vote par assentiment
# Ce programme n'est pas appelé directement en pratique, mais il est appelé par le 
#    programme de vote principal
#
import sys, PyQt4
from PyQt4 import QtGui, QtCore
from VoteAssentimentUI import Ui_VoteAssentiment
from ScrutinIO import Scrutin, Votes, Registre
from candidatNoteWidgetUI import Ui_candidatNoteWidget

class CandidatNoteItem(QtGui.QWidget):
    def  __init__(self):
        QtGui.QWidget.__init__(self)
        #QtGui.QListWidgetItem.__init__(self, parentlist)

        # Configure l'interface utilisateur à partir du fichier généré par Qt4 Designer
        self.ui = Ui_candidatNoteWidget()
        self.ui.setupUi(self)

    def setValues(self, name, mini, maxi, defaut):
      self.ui.candidatLabel.setText(name)
      self.ui.noteSpin.setRange(mini, maxi)
      self.ui.noteSpin.setValue(defaut)

    def setValue(self, val):
      self.ui.noteSpin.setValue(int(val))


    def getValue( self ):
      return self.ui.noteSpin.value()

    def getName( self ):
      return unicode(self.ui.candidatLabel.text())


class VoteAssentimentDialog(QtGui.QDialog):
    def __init__(self, scrutin):
        QtGui.QDialog.__init__(self)

        # Configure l'interface utilisateur à partir du fichier généré par Qt4 Designer
        self.ui = Ui_VoteAssentiment()
        self.ui.setupUi(self)

        self.scrutin = scrutin
        self.mini = scrutin["Parametres Scrutin"]["Note minimale"]
        self.maxi = scrutin["Parametres Scrutin"]["Note maximale"]
        self.defaut = scrutin["Parametres Scrutin"]["Note par defaut"]
        self.ui.instructionLabel.setText(u"Notez chaque candidat en fonction de vos préférences (très défavorable : "\
                                        + str(self.mini) + u", très favorable : "+ str(self.maxi) + u", note neutre : "+str(self.defaut))
        # Construire la liste de widgets CandidatNoteItem pour noter les candidats (avec valeur min, max et defaut des spinbox)
        self.initVote()

        # Connecte les boutons aux fonctions associées.
        #self.connect(self.ui.voterBouton, QtCore.SIGNAL("clicked()"), self.voter)



    # Quand l'utilisateur ferme la fenetre, demander une confirmation : plus que ça, il faut demander un code administrateur
    def closeEvent(self, event):
        reply = QtGui.QMessageBox.question(self, 'Message',"Voulez-vous vraiment quitter ?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
        if reply == QtGui.QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()


    def initVote( self ):
        self.scrutin["Candidats"].sort()
        self.notes=[]
        for candidat in self.scrutin["Candidats"]:
           item = CandidatNoteItem()
           self.notes.append(item)
           self.ui.candidatLayout.addWidget(item)
           item.setValues(candidat, self.mini, self.maxi, self.defaut)
        self.ui.candidatLayout.addStretch()


    def resetVote( self ):
       for item in self.notes:
          item.setValue(self.scrutin["Parametres Scrutin"]["Note par defaut"])


    # Renvoie une table de hachage contenant le vote
    def getVoteHash( self ):
            vHash = {}
            for item in self.notes:
              vHash[item.getName()] = item.getValue()
            return vHash


    # Validation du vote en cours
    def validateVote( self, electeurs, dejavotes ):
      if not(unicode(self.ui.electeurEdit.text()) in electeurs):
        self.erreur(u"L'identifiant de l'électeur est incorrect !")
        return False
      elif unicode(self.ui.electeurEdit.text()) in dejavotes:
        self.erreur(u"Vous avez déjà voté !\nVote refusé !")
        return False
      else:
        return True


    # Renvoie l'électeur courant
    def getVotant( self ):
      return unicode(self.ui.electeurEdit.text())


    # Fonction pour afficher une erreur
    def erreur( self, message ):
        QtGui.QMessageBox.warning(self, "Scrutin", message)


if __name__ == "__main__":
   app = QtGui.QApplication(sys.argv)
   window = VoteAssentimentDialog()

   window.show()
   sys.exit(app.exec_())