"""Extension to execute a script in a separate process

David Scherer <dscherer@cmu.edu>

  The ExecBinding module, a replacement for ScriptBinding, executes
  programs in a separate process.  Unlike previous versions, this version
  communicates with the user process via an RPC protocol (see the 'protocol'
  module).  The user program is loaded by the 'loader' and 'Remote'
  modules.  Its standard output and input are directed back to the
  ExecBinding class through the RPC mechanism and implemented here.

  A "stop program" command is provided and bound to control-break.  Closing
  the output window also stops the running program.
"""

import sys
import os
import imp
import OutputWindow
import protocol
import spawn
import traceback
import tempfile

# Find Python and the loader.  This should be done as early in execution
#   as possible, because if the current directory or sys.path is changed
#   it may no longer be possible to get correct paths for these things.

pyth_exe = spawn.hardpath( sys.executable )
load_py  = spawn.hardpath( imp.find_module("loader")[1] )

# The following mechanism matches loaders up with ExecBindings that are
#    trying to load something.

waiting_for_loader = []

def loader_connect(client, addr):
    if waiting_for_loader:
        a = waiting_for_loader.pop(0)
        try:
            return a.connect(client, addr)
        except:
            return loader_connect(client,addr)

protocol.publish('ExecBinding', loader_connect)

class ExecBinding:
    keydefs = {
        '<<run-complete-script>>': ['<F5>'],
        '<<stop-execution>>': ['<Cancel>'],   #'<Control-c>'
    }
    
    menudefs = [
        ('run', [None,
                  ('Run program', '<<run-complete-script>>'),
                  ('Stop program', '<<stop-execution>>'),
                 ]
        ),
    ]

    delegate = 1

    def __init__(self, editwin):
        self.editwin = editwin
        self.client = None
        self.temp = []

        if not hasattr(editwin, 'source_window'):
            self.delegate = 0
            self.output = OutputWindow.OnDemandOutputWindow(editwin.flist)
            self.output.close_hook = self.stopProgram
            self.output.source_window = editwin
        else:
            if (self.editwin.source_window and
                self.editwin.source_window.extensions.has_key('ExecBinding') and
                not self.editwin.source_window.extensions['ExecBinding'].delegate):
                    delegate = self.editwin.source_window.extensions['ExecBinding']
                    self.run_complete_script_event = delegate.run_complete_script_event
                    self.stop_execution_event = delegate.stop_execution_event

    def __del__(self):
        self.stopProgram()

    def stop_execution_event(self, event):
        if self.client:
            self.stopProgram()
            self.write('\nProgram stopped.\n','stderr')

    def run_complete_script_event(self, event):
        filename = self.getfilename()
        if not filename: return
        filename = os.path.abspath(filename)

        self.stopProgram()

        self.commands = [ ('run', filename) ]
        waiting_for_loader.append(self)
        spawn.spawn( pyth_exe, load_py )

    def connect(self, client, addr):
        # Called by loader_connect() above.  It is remotely possible that
        #   we get connected to two loaders if the user is running the
        #   program repeatedly in a short span of time.  In this case, we
        #   simply return None, refusing to connect and letting the redundant
        #   loader die.
        if self.client: return None

        self.client = client
        client.set_close_hook( self.connect_lost )

        title = self.editwin.short_title()
        if title:
            self.output.set_title(title + " Output")
        else:
            self.output.set_title("Output")
        self.output.write('\n',"stderr")
        self.output.scroll_clear()

        return self

    def connect_lost(self):
        # Called by the client's close hook when the loader closes its
        #   socket.

        # We print a disconnect message only if the output window is already
        #   open.
        if self.output.owin and self.output.owin.text:
            self.output.owin.interrupt()
            self.output.write("\nProgram disconnected.\n","stderr")

        for t in self.temp:
            try:
                os.remove(t)
            except:
                pass
        self.temp = []
        self.client = None

    def get_command(self):
        # Called by Remote to find out what it should be executing.
        # Later this will be used to implement debugging, interactivity, etc.
        if self.commands:
            return self.commands.pop(0)
        return ('finish',)

    def program_exception(self, type, value, tb, first, last):
        if type == SystemExit: return 0

        for i in range(len(tb)):
            filename, lineno, name, line = tb[i]
            if filename in self.temp:
                filename = 'Untitled'
            tb[i] = filename, lineno, name, line

        list = traceback.format_list(tb[first:last])
        exc = traceback.format_exception_only( type, value )

        self.write('Traceback (innermost last)\n', 'stderr')
        for i in (list+exc):
            self.write(i, 'stderr')

        self.commands = []
        return 1

    def write(self, text, tag):
        self.output.write(text,tag)

    def readline(self):
        return self.output.readline()

    def stopProgram(self):
        if self.client:
          self.client.close()
          self.client = None

    def getfilename(self):
        # Save all files which have been named, because they might be modules
        for edit in self.editwin.flist.inversedict.keys():
            if edit.io and edit.io.filename and not edit.get_saved():
                edit.io.save(None)

        # Experimental: execute unnamed buffer
        if not self.editwin.io.filename:
            filename = os.path.normcase(os.path.abspath(tempfile.mktemp()))
            self.temp.append(filename)
            if self.editwin.io.writefile(filename):
                return filename

        # If the file isn't save, we save it.  If it doesn't have a filename,
        #   the user will be prompted.
        if self.editwin.io and not self.editwin.get_saved():
            self.editwin.io.save(None)

        # If the file *still* isn't saved, we give up.
        if not self.editwin.get_saved():
            return

        return self.editwin.io.filename