import os
import sys
import time

from PyQt4.QtCore import *
from sface.config import config
from sface.xmlrpcwindow import XmlrpcTracker

def find_executable(exec_name):
    """find the given executable in $PATH"""
    paths = os.getenv("PATH").split(':')
    for p in paths:
        exec_path = os.path.join(p, exec_name)
        if os.path.exists(exec_path):
            return exec_path
    return None


class SfiProcess(QObject):
    def __init__(self, parent=None):
        QObject.__init__(self, parent)

        env = QProcess.systemEnvironment()
        env << "PYTHONPATH=%s" % ":".join(sys.path)
        self.process = QProcess()
        self.process.setEnvironment(env)
        self.connect(self.process, SIGNAL("finished(int, QProcess::ExitStatus)"),
                     self.processFinished)

        self.xmlrpctracker = XmlrpcTracker()

        # holds aggregate output from processStandardOutput(); used by xmlrpc
        # tracker.
        self.output = ""

        self.connect(self.process, SIGNAL("readyReadStandardOutput()"),
                     self.processStandardOutput)
        self.connect(self.process, SIGNAL("readyReadStandardError()"),
                     self.processStandardError)

    def __init_command(self, args):
        self.args = QStringList()
        if config.debug:
            # this shows xmlrpc conversation, see sfi.py docs.
            self.args << QString('-D')
        for arg in args:
            self.args << QString(arg)

        self.exe = find_executable("sfi.py")
        if not self.exe:
            print "FATAL.. Could not locate binary sfi.py - not much we can do without that"

    def isRunning(self):
        return self.process.state() != QProcess.NotRunning

    def processStandardOutput(self):
        output = self.process.readAllStandardOutput()
        self.output = self.output + output
        if config.debug:
            print output

    def processStandardError(self):
        print self.process.readAllStandardError()

    def processFinished(self):
        if self.process.exitStatus() == QProcess.CrashExit:
            print self.readOutput()
            print "Process exited with errors:",
            err = self.process.error()
            if err == QProcess.FailedToStart:
                print "FailedToStart"
            elif err == QProcess.Crashed:
                print "Crashed"
            elif err == QProcess.Timedout:
                print "Timedout"
            elif err == QProcess.WriteError:
                print "WriteError"
            elif err == QProcess.ReadError:
                print "ReadError"
            elif err == QProcess.UnknownError:
                print "UnknownError"
        self.trace_end()
        self.emit(SIGNAL("finished()"))

    def __getRSpec(self, mgr):
        slice = config.getSlice()
        # Write RSpec to file for testing.
        filename = os.path.expanduser("~/.sfi/" + slice + ".rspec")
        try:
            os.remove(filename)
        except:
            pass
        args = ["-u", config.getUser(), "-a", config.getAuthority(), 
                "-r", config.getRegistry(), "-s", mgr, "resources", 
                "-o", filename, slice]

        self.__init_command(args)
        self.start()
        return filename

    def getRSpecFromSM(self):
        return self.__getRSpec(config.getSlicemgr())

#    def getRSpecFromAM(self):
#        return self.__getRSpec(config.getAggmgr())

    def getRecord(self, hrn, filename=None):
        args = ["-u", config.getUser(), "-a", config.getAuthority(),
                "-r", config.getRegistry(), "-s", config.getSlicemgr(), "show", hrn]
        if filename:
            args.append("-o")
            args.append(filename)
        self.__init_command(args)
        self.start()

    def applyRSpec(self, rspec):
        filename = config.getSliceRSpecFile() + "_new"
        rspec.save(filename)
        args = ["-u", config.getUser(), "-a", config.getAuthority(),
                "-r", config.getRegistry(), "-s", config.getSlicemgr(), "create",
                config.getSlice(), filename]
        self.__init_command(args)
        self.start()
        return filename

    def updateRecord(self, filename):
        args = ["-u", config.getUser(), "-a", config.getAuthority(),
                "-r", config.getRegistry(), "-s", config.getSlicemgr(), "update", filename]
        self.__init_command(args)
        self.start()

    def renewSlivers(self, expiration):
        args = ["-u", config.getUser(), "-a", config.getAuthority(),
                "-r", config.getRegistry(), "-s", config.getSlicemgr(), "renew",
                config.getSlice(), expiration]
        self.__init_command(args)
        self.start()

    def start(self):
        self.output = ""
        self.trace_command()
        self.process.start(self.exe, self.args)

    def readOutput(self):
        if self.process.state() == QProcess.NotRunning:
            return self.process.readAll()

    def trace_command (self):
        if config.verbose:
            self._trace=time.time()
            command = "%s %s" % (self.exe, self.args.join(" "))
            print time.strftime('%H:%M:%S'),'Invoking',command

    def trace_end (self):
        if config.verbose:
#            command = "%s %s" % (self.exe, self.args.join(" "))
            print time.strftime('%H:%M:%S'),"Done [%.3f s]"%(time.time()-self._trace)
        if config.debug:
            self.xmlrpctracker.getAndPrint(self.output)