#!/usr/bin/env python

import logging
import threading
import cups
import sys
#import cupspk
from gettext import gettext as _
import gobject
import gtk
import os
import tempfile
import time
_logger = logging.getLogger('print-activity:printscript')


class serverConnection:
    
    def __init__ (self, host=None, port=None, encryption=None, lock=False):
        
        if host != None:
            cups.setServer (host)
        if port != None:
            cups.setPort (port)
        if encryption != None:
            cups.setEncryption (encryption)    
  

        self._use_password = ''
        self._use_user = cups.getUser ()
        self._server = cups.getServer ()
        self._port = cups.getPort()
        self._encryption = cups.getEncryption ()
        if self._connect () == 1:
           sys.exit()  
        self._prompt_allowed = True
        self._operation_stack = []
        self._lock = lock
        self._gui_event = threading.Event ()
        self.jobid = []
        print self._server

    def _connect (self,):
        cups.setUser (self._use_user)
        create_object = cups.Connection
        try:
            self._connection = create_object (host=self._server,
                                                port=self._port,
                                                encryption=self._encryption)
        except RuntimeError:
            _logger.debug("check if cups server is functioning properly")
            print ('hey i messed up')
            return 1  

    def _getTitle(self,_filepath):
          title = os.path.split(_filepath)[1].rsplit('.',1)[0]
          return title
  
    def _getPrintersList (self,):
        _dictPrinters = self._connection.getPrinters ()
        _thePrinters = self._dictPrinters.keys()
        return self._thePrinters

    def _getPrinterURI (self, name):
        _dictPrinters = self._connection.getPrinters ()
        _printerURI = self._dictPrinters[name]['device-uri']
        return self._printerURI
        
    def _getDefaultPrinter (self,):
        _defaultPrinter = self._connection.getDefault ()
        return self._defaultPrinter

    def _setPrintDevice (self, device = None, uri = None ):
        if device != None:
            self._ourDevice = device
        else: 
            self._ourDevice = _getDefaultPrinter () 
                 
        if uri != None:
            self._ourURI = _getPrinterURI (self._ourDevice)
        
        setPrinterDevice (self, self._ourDevice, self._ourURI)   
        
  
    def _printPDF (self, _printer, _filename, _title = None):
    
        if _title == None:
            _title = self._getTitle(_filename)
          
# we require our script to not look up the editable names of the printing devices,
# but look up the unchangeable URI of the printer, so we do this:        

        theprinters = self._getPrintersList ()
        self._location = ''
        for printer in theprinters:
           if self._getPrinterURI(printer) == u'cups-pdf:/':
               _printer = printer 
               break 
# Now we have the printer at hand
#lets open the config files and check the paths, and if user Directories are enabled
#Check for the paths, if a default $USER path exists, skip the condition and just use
#that if not go to user.dir, and also, that particular definition does not exist, use
#home dir, as it defaults to that 

               print _printer 
               f = open('/etc/cups/cups-pdf.conf', 'r')
               for line in f:
                   if line[0:3] == 'Out':
                       folder = self._location = line[4:].rsplit('\n',1)[0]
                       folder = folder.strip(' $ { } ')
                       
                       if self._location.find('${USER}') == -1:           #Special Fedora case
                           desktop = os.getenv("HOME")+'/.config/user-dirs.dirs'
                           print desktop
                           try:
                               f1 = open(desktop, 'r')
                           except IOError:

                                _logger.debug("$DESKTOP isn't defined, so going to home directory")
                                self._location = os.getenv("HOME") 
                                f1.close() 
                           else:
                               self._location = os.getenv("HOME") 
                               for line in f1:
                                   print line[0:15]     
                                   if line[0:15] == 'XDG_'+folder+'_DIR':
                                       self._location = line[15:].rsplit('\n',1)[0].strip('= "')
                                       self._location = self._location.replace('$HOME',os.getenv("HOME"))
                                       break     
                                         
                                          
                               f1.close()
                               print self._location 
                                 
                       else:        
                           self._location = self._location.replace('${USER}', os.getenv("USER"))
                       break #break to end 2nd for loop
           f.close() 
           print _printer 
           print _filename
           print _title
           self._connection.printFile (_printer, _filename, _title, {})
           break            # break to end 1st for loop
        return self._location+'/'+_title+'.pdf'

    def _printtoPrinter (self,_filename, _title=None):
        if _title == None:
            _title = self._getTitle(_filename)
        printer = self._getDefaultPrinter()
        if self._getPrinterURI(printer) != u'cups-pdf:/':
            self._connection.printFile (printer, _filename, _title, {})
            return True
        return False
    def _selectDefaultPrinter (self,_printer):
        self._connection.setDefault(_printer)

    def _getLiveJobQueue (self,noOfJobs=None):
        if noOfJobs == None:
            limit = -1
        else:
            limit = noOfJobs
        return self._connection.getJobs('not-completed', True, limit, -1)
    
    def _getCompletedJobQueue (self, noOfJobs = None):
        if noOfJobs == None:
            limit = -1
        else:
            limit = noOfJobs
        return self._connection.getJobs('completed', True, limit, -1)
           
    def _clearJobQueue (self,):
        printers = self._getPrintersList()
        for printer in printers:
            printeruri = self._getPrinterURI(printer)
            self._connection.cancelAllJobs(printeruri,False,True)
        return True

    def _clearPrinterQueue(self,printer):
        printeruri = self._getPrinterURI(printer)
        self._connection.cancelAllJobs(printeruri,False,True)

    def _cancelAJob(self,jobid):
       self._connection.cancelJob(jobid)
       return True
   












#hello = serverConnection()
#hello._printPDF('Cups-PDF','/home/iwikiwi/hello.odt','lolmax')