#!/usr/bin/env python
# -*- coding: iso-8859-15 -*-

# Utilisé par /var/www/impression/analyse.py
# /usr/lib/cups/backend/devis et /usr/lib/cups/backend/laserjet
# Écrit initial par Benoit
# modifié par Brice DUBOST et Benoit

import locale
locale.setlocale(locale.LC_ALL, 'fr_FR')

import commands, os, string, sys
import tempfile # non utilisé en ce moment

sys.path.append('/usr/scripts/gestion')
from config import impression


class cout:
    """Classe pour le calcul du cout d'une impression et de sa mise en page"""
    #en centimes
    c_total=0
    #en euros
    c_total_euros=0
    total_noir=0
    total_couleur=0
    faces=1
    pages=1
    nb_copie=1
    taille="NON_VALIDE"
    erreur=""
    recto_v="None"
    media=""

    def __init__(self, fichierps, media="", mode_couleur="Couleur", recto_v="None", taille="A4", nb_copie=1):
        """ * fichierps est le fichier PostScript (ou pdf) à analyser
        * media vaut transparent le cas écheant (dans ce cas taille=A4)
        * mode_couleur = Couleur pour traiter en couleur
        * recto_v = Recto si l'on ne desire pas un recto-verso
        * taille vaut A3 ou A4 selon le bac choisi
        * nb_copie est le nombre de copies désirées
        Le PostScript a toujours priorité sur ces parametres
        """

        # Pour la couleur, je n'ai pas trouve de methode valables tout le temps
        # Le plus simple reste donc de voir s'il y a 0% de couleur dans le ps.

        self.nb_copie=nb_copie
        # on compte le nb de copies et on enlève les balises pour ne pas recalculer
        nb_copie_ps=0
        original=open(fichierps)
        fichier='/tmp/couts_temp'
        try:
            fic = open(fichier,'w')
        except:
            os.remove(fichier)
            fic = open(fichier,'w')
#        fic = tempfile.NamedTemporaryFile()
        ligne = original.readline()
        while ligne:
            if ligne.startswith('%%BeginFeature: *PageSize'):
                taille=ligne.split(' ')[-1].replace('\n','')
            if ligne.startswith('%%BeginFeature: *Duplex'):
                recto_v=ligne.split(' ')[-1].replace('\n','')
            if ligne.find('%RBIBeginNonPPDFeature: *NumCopies') != -1:
                nb_copie_ps=int(ligne.split(' ')[-1])
                while ligne.find('%RBIEndNonPPDFeature') == -1:
                    ligne = original.readline()
                ligne = original.readline()
            fic.write(ligne)
            ligne = original.readline()
        fic.close()
        original.close()
        
        # Le PS a priorité
        if nb_copie_ps:
            self.nb_copie=nb_copie_ps

        if taille=="A4" or taille=="A3":
            self.taille=taille
        else: # taille invalide
            self.erreur="Erreur : Taille invalide"
            return

        if recto_v == "None" or recto_v == "Recto":
            recto_v="Recto"
        else:
            recto_v="Recto-verso"

        self.recto_v=recto_v
        
        if (mode_couleur == "Couleur"):
            device = "png16m"
        else:
            device = "pnggray"

        if (self.taille == "A3"):
            # Une feuille A3 couvre 2 fois plus de surface que A4
            c_taille = impression.c_a3
            cout_coul = 2*impression.c_coul
            cout_noir = 2*impression.c_noir
        else:
            cout_coul = impression.c_coul
            cout_noir = impression.c_noir
            if (media == "transparent"):
                c_taille = impression.c_trans
                self.media="transparent"
            else:
                c_taille = impression.c_a4

        # Vérification du format de fichier.
        try:
            en_tete=open(fichier).read(4)
        except:
            self.erreur="Le fichier ne peut etre ouvert"
            return
        # On vérifie que ce que l'on nous a envoyé est bien un PS ou un PDF
        if en_tete!='%!PS' and en_tete!='%PDF':
            self.erreur="Format de fichier non supporte"
            return

        (status,rep) = commands.getstatusoutput("nice -n 10 gs -sDEVICE=%s -r100 -dBATCH -dNOPAUSE -dSAFER -dPARANOIDSAFER -dGraphicsAlphaBits=4 -dTextAlphaBits=4 -dMaxBitmap=50000000 -sOutputFile='%s' -q '%s'" % (device, fichier+"%d.png", fichier) )
        if (status != 0):
            self.erreur="ERREUR : Ghostscript : Fichier Postscript invalide.\n"
            self.erreur="Le message d'erreur est le suivant :\n"
            self.erreur+= rep
            # On détaille l'erreur dans le mail et 
            # il faut stopper l'impression.
            return

        # On a plus besoin du fichier temp, donc on le supprime.
        os.remove(fichier)
        
        if not os.system("ls '%s'*.png > /dev/null" % (fichier)):
            if (mode_couleur == "Couleur"):
                remplissage = [0, 0, 0, 0, 0] # C, M, J, N, nombre de pages
                for file in string.split(commands.getoutput("ls '%s'*.png" % (fichier)),"\n"):
                    resultats = commands.getoutput("/usr/scripts/impression/percentcolour '%s'" % (file) )
                    l_resultats = string.split(resultats,":")
                    for i in [0, 1, 2, 3]:
                        remplissage[i] += float(l_resultats[i])*float(l_resultats[4])
                    remplissage[4] += float(l_resultats[4])
                    os.system("rm -f '%s'" % (file))
                self.total_noir = remplissage[3]
                self.total_couleur = sum(remplissage[0:3])
                self.faces = int(remplissage[4])
                if (recto_v == "Recto"):
                    self.pages = self.faces # nb de pages par copies
                else:
                    self.pages = int(self.faces/2.+0.5)
                if self.total_couleur > 0:
                    self.c_total = c_taille*self.pages+(impression.c_tambour_coul+impression.c_tambour_noir)*self.faces+cout_noir*self.total_noir+cout_coul*self.total_couleur
                else: # Pas de couleur
                    self.c_total = c_taille*self.pages+impression.c_tambour_noir*self.faces+cout_noir*self.total_noir
            else: # Utile pour la page web
                remplissage = [0, 0] # Noir, nombre de pages 
                for file in string.split(commands.getoutput("ls '%s'*.png" % (fichier)),"\n"):
                    resultats = commands.getoutput("/usr/scripts/impression/percentblack '%s'" % (file))
                    l_resultats = string.split(resultats,":")
                    remplissage[0] += float(l_resultats[0])*float(l_resultats[1])
                    remplissage[1] += float(l_resultats[1])
                    os.system("rm -f '%s'" % (file))
                self.total_noir = remplissage[0]
                self.faces = int(remplissage[1])
                if (recto_v == "Recto"):
                    self.pages = self.faces # nb de pages par copies
                else:
                    self.pages = int(self.faces/2.+0.5)
                self.c_total = c_taille*self.pages+impression.c_tambour_noir*self.faces+cout_noir*self.total_noir
            self.c_total = int(self.nb_copie*self.c_total+impression.fact+0.5) # arrondi et facture
            self.c_total_euros=float(self.c_total)/100
            os.system("rm -f '%s'*.png" %(fichier))
        else:
            self.erreur=u"ERREUR : Fichier Postscript invalide. Aucun png n'a été créé\n"



    def remplis_template(self,template):
        """Cette fonction rempli le template avec les bonnes valeurs"""
        if (self.c_total < 100):
            str_cout = "%s centimes d'euros" % (self.c_total)
        else :
            str_cout = "%s euros" % (self.c_total/100.)

        if self.taille=="NON_VALIDE":
            taille=u"Le format de papier que vous avez demandé n'est pas valide"
        else:
            if self.media=="transparent":
                taille="transparent A4"
            else:
                taille=self.taille
        try:
            return template % { 'prix' : str_cout }
        except:
            return template % { 'noir' : self.total_noir, 'couleur' : self.total_couleur, 'faces' : self.faces, 'pages' : self.pages, 'copies' : self.nb_copie, 'taille' : taille, 'prix' : str_cout}


    def html_cout(self):
        """Renvoie le cout formaté en html"""
        # Format du PS (parfois different de celui choisi)
        # Utile pour deboguage, sera supprime apres
        template = """<b>Résultats : </b>
        <ul><li><b>Taille de l'impression</b> : %(taille)s </li>
        <li><b>Pour une copie :</b>
            <ul><li>Noir : %(noir)s unités </li>
            <li>Couleur : %(couleur)s unités </li>
            <li>Nombre de faces : %(faces)s </li>
            <li>Nombre de pages : %(pages)s </li></ul></li>
        <li><b>Nombre de copies</b> : %(copies)s </li></ul>
        <br>
        <font size="3"><b>Prix total : %(prix)s </b></font>
        </p>\n"""
        
        if not self.erreur:
            return self.remplis_template(template)
        else:
            return self.erreur


    def send_mail(self, Dest , sujet, template):
        """Cette fonction envoie le mail template correctement rempli
        provenant de l'imprimante avec comme serveur
        SMTP localhost
        Arguments : 
            Dest : destinataire
            sujet : sujet du mail
            template : le corps du mail
        Pour le remplissage du template voir source pour le moment"""

        if not self.erreur:
            mail=self.remplis_template(template)
        else:
            sujet="Erreur " + sujet
            mail=self.erreur + "\n\n-- \nL'imprimante\n"

        #l'envoi
        self.send_email("Imprimante <%(From)s>" % { 'From' : impression.From_imprimante}, Dest , sujet, mail)


    def send_email(self, sender, recipient, subject, body):
        """Send an email.

        All arguments should be Unicode strings (plain ASCII works as well).

        Only the real name part of sender and recipient addresses may contain
        non-ASCII characters.

        The email will be properly MIME encoded and delivered though SMTP to
        localhost port 25.  This is easy to change if you want something different.

        The charset of the email will be the first one out of US-ASCII, ISO-8859-1
        and UTF-8 that can represent all the characters occurring in the email.
        """
        from smtplib import SMTP
        from email.MIMEText import MIMEText
        from email.Header import Header
        from email.Utils import parseaddr, formataddr

        # Header class is smart enough to try US-ASCII, then the charset we
        # provide, then fall back to UTF-8.
        header_charset = 'ISO-8859-1'

        # We must choose the body charset manually
        for body_charset in 'US-ASCII', 'ISO-8859-1', 'UTF-8':
            try:
                body.encode(body_charset)
            except UnicodeError:
                pass
            else:
                break

        # Split real name (which is optional) and email address parts
        sender_name, sender_addr = parseaddr(sender)
        recipient_name, recipient_addr = parseaddr(recipient)

        # We must always pass Unicode strings to Header, otherwise it will
        # use RFC 2047 encoding even on plain ASCII strings.
        sender_name = str(Header(unicode(sender_name), header_charset))
        recipient_name = str(Header(unicode(recipient_name), header_charset))

        # Make sure email addresses do not contain non-ASCII characters
        sender_addr = sender_addr.encode('ascii')
        recipient_addr = recipient_addr.encode('ascii')

        # Create the message ('plain' stands for Content-Type: text/plain)
        msg = MIMEText(body.encode(body_charset), 'plain', body_charset)
        msg['From'] = formataddr((sender_name, sender_addr))
        msg['To'] = formataddr((recipient_name, recipient_addr))
        msg['Subject'] = Header(unicode(subject), header_charset)

        # Send the message via SMTP to localhost:25
        smtp = SMTP("localhost")
        smtp.sendmail(sender, recipient, msg.as_string())
        smtp.quit()