#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import os
import re
import subprocess
from moteur_modules_common.EkdProcess import EkdProcess
from moteur_modules_common.EkdConfig import EkdConfig
 
if os.name == 'nt' :
        cheminFFmpeg = u"{0}ffmpeg.exe".format(EkdConfig.urlFFmpeg)
else :
        cheminFFmpeg = u"{0}ffmpeg".format(EkdConfig.urlFFmpeg)
        
        
class FFmpegCPU(object):
        """ Classe pour mettre en place l'utilisation des coeurs (cpu), c'est à dire le 
        multiprocessing pour les différents traitements avec FFmpeg et Mencoder (les 
        calculs impactés par FFmpeg et Mencoder). En fait le calcul peut se faire en 
        répartissant la charge  de calcul sur les différents coeurs """
        
        def __init__(self):
                try:
                        import multiprocessing
                        self.nbre_cpu = multiprocessing.cpu_count()
                        
                except:
                        # Sous Windows
                        if os.name == 'nt': self.nbre_cpu = str(os.environ['NUMBER_OF_PROCESSORS'])
                        # Là spécifiquement sous GNU/Linux (Posix)
                        else: self.nbre_cpu = str(os.sysconf('SC_NPROCESSORS_ONLN'))
 
 
class FFmpegFormat(object):
        """ Classe pour déterminer les formats chargés dans la config de FFmpeg. Cette
        classe est particulièrement faite pour émettre un boîte de dialogue d'erreur
        (dans le transcodage vidéo) si l'utilisateur essaie de faire le traitement
        vers le WebM (car les anciennes versions de FFmpeg ne le prennent pas en charge """
        
        def __init__(self, format_entree):
                # Initialisation
                self.format_entree = format_entree
                
                if os.name == 'nt':
                        # Processus avec subprocess
                        process = EkdProcess([cheminFFmpeg, u'-formats'], output=subprocess.PIPE)
                        '''
                        # Liste avec itération pour passer en revue la sortie du process
                        # A voir ici pour l'itération:
                        # http://stackoverflow.com/questions/2804543/read-subprocess-stdout-line-by-line
                        liste1 = [ligne1 for ligne1 in iter(process.stdout.readline,'')]
                        # Vérification si le format est bien présent dans la config de FFmpeg
                        liste2 = [ligne3 for ligne2 in liste1 for ligne3 in ligne2.split(' ') if ligne3 == format_entree]
                        # Attribution des drapeaux selon les cas (0: Faux, 1: Vrai).
                        # Pour le webm (qui n'est pas pris en charge par la version 
                        # de FFmpeg sous (K)ubuntu LTS 10.04) ce sera Faux donc 0.
                        if liste2 == []: self.vrai_faux = 0
                        elif liste2[0] == format_entree: self.vrai_faux = 1
                        '''
                        # En utilisant communicate
                        com = process.communicate()
                        # com est sous forme de tuple
                        liste1 = [ligne1 for ligne1 in com]
                        # Vérification si le format est bien présent dans la config de FFmpeg
                        liste2 = [ligne2.split(' ') for ligne2 in liste1 if ligne2 != None]
                        liste3 = [ligne3 for ligne3 in liste2[0] if ligne3 == format_entree]
                        # Attribution des drapeaux selon les cas (0: Faux, 1: Vrai).
                        # Pour le webm (qui n'est pas pris en charge par la version 
                        # de FFmpeg sous (K)ubuntu LTS 10.04) ce sera Faux donc 0.
                        if liste3 == []: self.vrai_faux = 0
                        elif liste3[0] == format_entree: self.vrai_faux = 1
                        
                else:
                        # --------------------------------------------------------- #
                        # Utilisation et adaptation du code présent dans le fichier:
                        # moteur_modules_common/EkdVerifAppliManquante.py
                        # --------------------------------------------------------- #
                        commande = unicode(cheminFFmpeg) + u' -formats'
                        process = EkdProcess(commande)
                        # Le résultat de res_temp_2 est récupéré dans stdout (uniquement)
                        res_temp = process.communicate()[0]
                        # Sortie commande placée dans une liste
                        res = [res_temp]
                        # Le format/codec est recherché (WebM pour l'instant)
                        format_ffmpeg = [format_entree]
                        # Liste pour le data
                        liste_data = []
                        # Liste des formats sélectionnés
                        for parc_res in res:
                                for parc_cfe in format_ffmpeg:
                                        # Expression régulière pour trouver les occurrences 
                                        # commençant par la lettre E (donc E pour Encode)
                                        # Equivalent de la commande: ffmpeg -formats | grep -wE codec
                                        trouver = re.compile('(E.*?.' + parc_cfe + ')')
                                        liste_data.append(trouver.findall(parc_res))
                        # Split des données. Affiche par exemple pour le WebM: [['E', 'webm']]
                        lsplit = [parc_data_2.split(" ") for parc_data_1 in liste_data for parc_data_2 in parc_data_1] 
                        # On enlève certaines parties qui encombrent
                        encombre = ['(', '', 'E', 'S', 'EV', 'ED', 'EVSD', 'ES', 'D', 'A', 'System', 'format']
                        rem_temp = [x for y in lsplit for x in y if x not in encombre and x[0] != encombre[0]]
                        # Vérification
                        rem = [ligne for ligne in rem_temp if ligne == format_entree]
                        # Attribution des drapeaux selon les cas (0: Faux, 1: Vrai).
                        # Pour le webm (qui n'est pas pris en charge par la version 
                        # de FFmpeg sous (K)ubuntu LTS 10.04) ce sera Faux donc 0.
                        if rem == []: self.vrai_faux = 0
                        elif rem[0] == format_entree: self.vrai_faux = 1
 
        def __str__(self): 
                """ Attribution/retour de la valeur """
                # Méthode trouvée ici:
                # http://stackoverflow.com/questions/2491819/python-init-how-to-return-a-value
                return str(self.vrai_faux)
                
 
'''
class FFmpegFilters(object):
        """ Classe pour déterminer si cette version de FFmpeg comporte des filtres (délivrés 
        par la syntaxe ffmpeg -filters) et qui correspond à des versions très récentes (en 
        ce 13/08/11)de FFmpeg. """
        
        def __init__(self): 
                process = EkdProcess([cheminFFmpeg,u'-filters'], output=subprocess.PIPE)
                liste1 = [ligne1 for ligne1 in iter(process.stdout.readline,'')]
                liste2 = [ligne3 for ligne2 in liste1 for ligne3 in ligne2.split(' ') if ligne3 == 'pad']
                if liste2 == []: self.nouveau_ffmpeg = 0
                elif liste2[0] == 'pad': self.nouveau_ffmpeg = 1
'''