#!/usr/bin/python
# -*- coding: Utf-8 -*-

import os
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_animation.animation_base_encodageFiltre import Base_EncodageFiltre
from moteur_modules_animation.mencoder import WidgetMEncoder


# Les widgets des 4 1ères classes apparaissent alternativemement
# selon l'entrée de la boîte de combo sélectionnée (stacked)

class Codecs_SansReglages(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au codecs:
	# Copie (format original) - AVI-RAW Sans Compression - Codec XVID -
	# Qualite SVCD - Qualite DVD - Codec H264 MPEG 4
	# -------------------------------------------------------------------
	def __init__(self):
		QWidget.__init__(self)
		
		# label texte
		txt1=_(u"Réglage automatique pour ce choix")
		label=QLabel("<center>%s</center>" %txt1)
		
		vbox=QVBoxLayout()
		vbox.addWidget(label)
		self.setLayout(vbox)


class Codecs_AvecReglages(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au codecs :
	# DivX4 - Codec Motion JPEG - Codec MPEG1 - Codec MPEG2 - Codec WMV2
	# -------------------------------------------------------------------
	def __init__(self,config,choixCodec):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.choixCodec=choixCodec
		self.idSection = "Animation - Encodage"
		
		# label titre
		txt1=_(u"Réglage de la compression : ")
		label=QLabel("<center><u>%s</u></center>" %txt1)
		
		# boite de spin
		self.spinCompression=QSpinBox()		# self car on va récupérer la variable depuis le moteur
		self.spinCompression.setRange(1,31) # 2 par défaut
		
		# curseur
		self.curseur = QSlider(Qt.Horizontal)
		self.curseur.setRange(1,31)
		
		self.connect(self.spinCompression,SIGNAL("valueChanged(int)"),self.sauverSpin)
		self.connect(self.curseur, SIGNAL("sliderMoved(int)"), self.curseurBouge)
		
		try:
			print self.config.get(self.idSection,self.choixCodec)
			self.spinCompression.setValue(int(self.config.get(self.idSection,self.choixCodec)))
		except:
			print "Pas de paramètre ou mauvais paramètre de configuration pour:\n\
			DivX4, Codec Motion JPEG, Codec MPEG1, Codec MPEG2 ou Codec WMV2"
		
		# label d'info des valeurs de la compression video
		txt1,txt2,txt3=_(u'Entre 1 et 31 -> '),_(u'1: Excellent'),_(u' 31: Mauvais')
		info_compress=QLabel('%s<font color="green">%s</font> -- <font color="red">%s</font>' %(txt1,txt2,txt3), self)
		
		# QWidget qui contiendra les widgets ci-dessus ( -> stacked)
		vbox=QVBoxLayout()
		vbox.addWidget(label)
		hbox=QHBoxLayout()
		hbox.addWidget(self.spinCompression)
		hbox.addWidget(self.curseur)
		hbox.addWidget(info_compress)
		hbox.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(hbox)
		self.setLayout(vbox)
	
	def sauverSpin(self,i):
		"""conserver le spin dans le fichier de configuration et modifie le curseur"""
		print self.choixCodec,i
		# sauver spin
		self.config.set(self.idSection,self.choixCodec,i)
		# sauver curseur
		self.curseur.setValue(i)
	
	def curseurBouge(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinCompression.setValue(i)


class Flash(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au codec : Macromedia Flash Video
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)
		
		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - Encodage"
		
		# label titre
		txt1=_(u"Réglage de la qualité : ")
		label=QLabel("<center><u>%s</u></center>" %txt1)
		
		# boite de spin
		self.spinCompression=QSpinBox()
		self.spinCompression.setRange(10,5000) # 500 par défaut
		
		# curseur
		self.curseur = QSlider(Qt.Horizontal)
		self.curseur.setRange(10,5000)
		
		self.connect(self.spinCompression,SIGNAL("valueChanged(int)"),self.sauverSpin)
		self.connect(self.curseur, SIGNAL("sliderMoved(int)"), self.curseurBouge)
		
		try:
			print self.config.get(self.idSection,"macromediaflashvideo")
			self.spinCompression.setValue(int(self.config.get(self.idSection,"macromediaflashvideo")))
		except:
			print "Pas de paramètres de configuration pour:\n\
			MacromediaFlashVideo"
		
		# Label d'info des valeurs de la compression video pour Macromedia 
		# Flash Video
		txt1,txt2,txt3=_(u'Entre 10 et 5000 -> '),_(u'10: Mauvais'),_(u' 5000: Excellent')
		info_compress=QLabel('%s<font color="red">%s</font> -- <font color="green">%s</font>' %(txt1,txt2,txt3), self)
		
		# QWidget qui contiendra les widgets ci-dessus ( -> stacked)
		vbox=QVBoxLayout()
		vbox.addWidget(label)
		hbox=QHBoxLayout()
		hbox.addWidget(self.spinCompression)
		hbox.addWidget(self.curseur)
		hbox.addWidget(info_compress)
		hbox.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(hbox)
		self.setLayout(vbox)
	
	def sauverSpin(self,i):
		"""conserver le spin dans le fichier de configuration et modifie le curseur"""
		print i
		# sauver spin
		self.config.set(self.idSection,"macromediaflashvideo",i)	#test
		# sauver curseur
		self.curseur.setValue(i)
	
	def curseurBouge(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinCompression.setValue(i)


class OggTheora(QWidget):
	# -------------------------------------------------------------------
	# Widgets associés au codec : Ogg Theora
	# -------------------------------------------------------------------
	def __init__(self,config):
		QWidget.__init__(self)

		self.config=config # récupération des paramètres de configuration
		self.idSection = "Animation - Encodage"
		
		# label titre
		txt1=_(u"Réglage de la qualité : ")
		label=QLabel("<center><u>%s</u></center>" %txt1)
		
		# boite de spin
		self.spinCompression=QSpinBox()
		self.spinCompression.setRange(0,10) # 5 par défaut
		
		# curseur
		self.curseur = QSlider(Qt.Horizontal)
		self.curseur.setRange(0,10)
		
		self.connect(self.spinCompression,SIGNAL("valueChanged(int)"),self.sauverSpin)
		self.connect(self.curseur, SIGNAL("sliderMoved(int)"), self.curseurBouge)
		
		try:
			print self.config.get(self.idSection,"codecoggtheora")
			self.spinCompression.setValue(int(self.config.get(self.idSection,"codecoggtheora")))
		except:
			print "Pas de paramètres de configuration pour:\n\
			Codec Ogg Theora"
		
		# label d'info des valeurs de la compression video pour Ogg Theora
		txt1,txt2,txt3=_(u'Entre 0 et 10 -> '),_(u'0: Mauvais '),_(u'10: Excellent')
		info_compress=QLabel('%s<font color="red">%s</font> -- <font color="green">%s</font>' %(txt1,txt2,txt3), self)
		
		# QWidget qui contiendra les widgets ci-dessus ( -> stacked)
		vbox=QVBoxLayout()
		vbox.addWidget(label)
		hbox=QHBoxLayout()
		hbox.addWidget(self.spinCompression)
		hbox.addWidget(self.curseur)
		hbox.addWidget(info_compress)
		hbox.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(hbox)
		self.setLayout(vbox)
	
	def sauverSpin(self,i):
		"""conserver le spin dans le fichier de configuration et modifie le curseur"""
		print i
		# sauver spin
		self.config.set(self.idSection,"codecoggtheora",i)
		# sauver curseur
		self.curseur.setValue(i)
	
	def curseurBouge(self, i):
		"""Quand on change la position du curseur la valeur du spin est automatiquement modifiée"""
		self.spinCompression.setValue(i)


class Animation_Encodage(Base_EncodageFiltre):
	# -------------------------------------------------------------------
	# Cadre accueillant les widgets de : Animation >> Encodage
	# -------------------------------------------------------------------
	
	def __init__(self, parent):
		
		#=== Variable de configuration ===#
		self.config=parent.config
		
		#=== Identifiant de la classe ===#
		self.idSection = "Animation - Encodage"
		
		# -------------------------------------------------------------------
		# Widgets intégrés à la boîte de groupe "Réglage de sortie de l'encodage".
		# La boîte de combo définie ci-dessus 'sélectionne' ceux qui vont s'afficher
		# -> utilisation d'un stacked
		# -------------------------------------------------------------------
		
		# === Widgets associés au codecs: Copie (format original) - AVI-RAW Sans
		# Compression - Codec XVID - Qualite SVCD - Qualite DVD - Codec H264 MPEG 4
		
		# création de stacked pour les QWidget
		self.stacked=QStackedWidget()
		self.stacked.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
		
		self.itemStacked_sansReglages=Codecs_SansReglages()
		# par défaut
		self.indexStacked_sansReglages=self.stacked.addWidget(self.itemStacked_sansReglages)
		
		
		# === Widgets associés au codecs : # DivX4 - Codec Motion JPEG - Codec MPEG1
		# - Codec MPEG2 - Codec WMV2 
		self.itemStacked_DIVX4=Codecs_AvecReglages(self.config,'codecdivx4')
		self.itemStacked_JPEG=Codecs_AvecReglages(self.config,'codecmotionjpeg')
		self.itemStacked_MPEG1=Codecs_AvecReglages(self.config,'codecmpeg1')
		self.itemStacked_MPEG2=Codecs_AvecReglages(self.config,'codecmpeg2')
		self.itemStacked_WMV2=Codecs_AvecReglages(self.config,'codecwmv2')
		
		self.indexStacked_DIVX4=self.stacked.addWidget(self.itemStacked_DIVX4)
		self.indexStacked_JPEG=self.stacked.addWidget(self.itemStacked_JPEG)
		self.indexStacked_MPEG1=self.stacked.addWidget(self.itemStacked_MPEG1)
		self.indexStacked_MPEG2=self.stacked.addWidget(self.itemStacked_MPEG2)
		self.indexStacked_WMV2=self.stacked.addWidget(self.itemStacked_WMV2)
		
		# === Widgets associés au codec : Macromedia Flash Video
		self.itemStacked_flash=Flash(self.config)
		self.indexStacked_flash=self.stacked.addWidget(self.itemStacked_flash)
		
		# === Widgets associés au codec : Ogg Theora
		self.itemStacked_oggTheora=OggTheora(self.config)
		self.indexStacked_oggTheora=self.stacked.addWidget(self.itemStacked_oggTheora)
		
		#----------------------------------------------------------------------------------
		# Paramètres de la liste de combo: [(identifiant, nom entrée, index du stacked,
		# 	instance stacked, extension fichier sortie, valeur spin à récupérer?),...]
		#----------------------------------------------------------------------------------
		self.listeCombo =	[\
		('avirawsanscompression',_(u'AVI-RAW i420 (sans compression) (.avi)'),	self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'.avi',		0),\
		('qualiteDVD',		_(u'Qualite DVD (.mpg)'),		self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'.mpg',		0),\
		('qualitesvcd',		_(u'Qualite SVCD (.mpg)'),		self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'.mpg',		0),\
		('codecmotionjpeg',	_(u'Codec Motion JPEG (.avi)'),		self.indexStacked_JPEG,\
			self.itemStacked_JPEG,		'.avi',		1),\
		('codecoggtheora',	_(u'Codec OGG THEORA (.ogg)'),		self.indexStacked_oggTheora,\
			self.itemStacked_oggTheora,	'.ogg',		1),\
		('codecmpeg2',		_(u'Codec MPEG 2 (.mpg)'),		self.indexStacked_MPEG2,\
			self.itemStacked_MPEG2,		'.mpg',		1),\
		('codech264mpeg4',	_(u'Codec H264 MPEG 4 (.mp4)'),		self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'.mp4',		0),\
		('codecxvid',		_(u'Codec XVID (.avi)'),		self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'.avi',		0),\
		('codecdivx4',		_(u'Codec DIVX4 (.avi)'),		self.indexStacked_DIVX4,\
			self.itemStacked_DIVX4,		'.avi',		1),\
		('codecmpeg1',		_(u'Codec MPEG 1 (.mpg)'),		self.indexStacked_MPEG1,\
			self.itemStacked_MPEG1,		'.mpg',		1),\
		('codecwmv2',		_(u'Codec WMV2 (.wmv)'),		self.indexStacked_WMV2,\
			self.itemStacked_WMV2,		'.wmv',		1),\
		('macromediaflashvideo',_(u'Macromedia Flash Video (.flv)'),	self.indexStacked_flash,\
			self.itemStacked_flash,		'.flv',		1),\
		('copie',		_(u'Copie (format original)'),		self.indexStacked_sansReglages,\
			self.itemStacked_sansReglages,	'',		0),\
					]
		
		
		#---------------------------
		# Dérivation de la classe
		#---------------------------
		Base_EncodageFiltre.__init__(self, parent)
	
	
	def afficherAide(self):
		""" Boîte de dialogue de l'aide du cadre Animation > Encodage """
		self.base.afficherAide(_(u"Blablablablablablablablablabla ... blablabla ... blablablabla ... blablabla."))
		'''
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla anim_encodage."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()
		'''
		
	
	def appliquer(self, nomSortie=None, ouvert=1):
		"""appel du moteur de ekd -> encodage"""
		
		if not nomSortie:
			cheminFichierEnregistrerVideo=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), os.path.expanduser(self.base.repSortieProv()), _(u"Tous les fichiers *.*")))
		else: # module séquentiel
			cheminFichierEnregistrerVideo=nomSortie
		
		if cheminFichierEnregistrerVideo=="":
			return
		
		# quel est l'index du dernier item sélectionné de la boîte de combo?
		i=self.combo.currentIndex()
		# identifiant du codec actif
		idCodec=str(self.combo.itemData(i).toStringList()[0]) # méthode de QVariant
		
		# récupération du chemin
		chemin=str(self.ligneEditionSource.text())
		
		# pas de spin pour Copie (format original) - AVI-RAW Sans Compression
		# Codec XVID - Qualite SVCD - Qualite DVD - Codec H264 MPEG 4
		spin=None # par défaut
		
		for j in self.listeCombo: # attribution de la valeur du spin s'il existe
			if j[0]==idCodec and j[5]==1:
				spin=str(j[3].spinCompression.value())
		
		print idCodec, chemin, spin, type(spin)
		
		for i in self.listeCombo: # attribution de l'extension
			if i[0]==idCodec:
				cheminFichierEnregistrerVideo+=i[4]
		
		# Cas particulier de la copie où l'on récupére l'extension du fichier d'entrée
		if idCodec=='copie':
			cheminFichierEnregistrerVideo+=os.path.splitext(chemin)[1]
		
		print "\nInfos arguments avant encodage :"
		print 'idCodec :', idCodec, type(idCodec)
		print 'cheminEntre :', chemin, type(chemin)
		print 'cheminFichierEnregistrerVideo :', cheminFichierEnregistrerVideo, type(cheminFichierEnregistrerVideo)
		print 'spin :', spin, type(spin)
		
		# appel du moteur -> animation encodage avec un codec particulier
		try:
			mencoder = WidgetMEncoder(idCodec, chemin, cheminFichierEnregistrerVideo, valeurNum = spin, laisserOuvert=ouvert)
			mencoder.setWindowTitle(_(u"Encodage vidéo"))
			mencoder.exec_()
		except:
			messageErrAnEnc=QMessageBox(self)
			messageErrAnEnc.setText(_(u"A problem was occured."))
			messageErrAnEnc.setWindowTitle(_(u"Error"))
			messageErrAnEnc.setIcon(QMessageBox.Warning)
			messageErrAnEnc.exec_()
			return
		
		#['codecdivx4', 'codecmotionjpeg', 'codecmpeg1', 'codecmpeg2', 'codecwmv2', 'macromediaflashvideo', 'codecoggtheora', 'avirawsanscompression','codecxvid','qualitesvcd', 'qualitedvd','codech264mpeg4']:
		
		# if idCodec!='copie' %%%
		
		self.lstFichiersSortie =  cheminFichierEnregistrerVideo # pour la boite de dialogue de comparaison
		self.radioConvert.setChecked(True)
		self.radioSource.setEnabled(True)
		self.radioConvert.setEnabled(True)
		self.boutCompare.setEnabled(True)
		return cheminFichierEnregistrerVideo # module séquentiel