package acl2s.uilib.session;
	
	import static acl2s.uilib.session.ISessionStatusListener.BUSY_SESSION;
	import static acl2s.uilib.session.ISessionStatusListener.ERROR_SESSION;
	import static acl2s.uilib.session.ISessionStatusListener.NO_SESSION;
	import static acl2s.uilib.session.ISessionStatusListener.READY_CMD_SESSION;
	import static acl2s.uilib.session.ISessionStatusListener.READY_MISC_SESSION;
	import static acl2s.uilib.session.ISessionStatusListener.STARTING_SESSION;
	
	import java.io.File;
	import java.io.IOException;
	import java.util.HashSet;
	import java.util.List;
	
	import org.peterd.util.BoundedBlockingQueue;
	import org.peterd.util.Pingable;
	
	import acl2s.lib.parse.CanonicalParseContext;
	import acl2s.lib.parse.ILispUnparsable;
	import acl2s.lib.parse.IParseContext;
	import acl2s.lib.parse.ParseException;
	import acl2s.lib.parse.StringParser;
	import acl2s.lib.parse.obj.LispObject;
	import acl2s.lib.session.IEnvInfo;
	import acl2s.lib.session.IResultInfo;
	import acl2s.lib.session.IStatusInfo;
	import acl2s.lib.session.InteractiveSession;
	import acl2s.lib.session.MyInteractiveSessionConfig;
	import acl2s.lib.session.SessionBusyException;
	import acl2s.lib.session.SessionDeadException;
	import acl2s.lib.session.SessionNotBusyException;
	import acl2s.lib.session.SessionStateException;
	import acl2s.uilib_driver.Acl2sTargetedOperationException;
	import acl2s.uilib_driver.IAcl2sGraphics;
	import acl2s.uilib_driver.IAcl2sGraphicsFactory;
	import acl2s.uilib_driver.IAcl2sUiLibDriver;
	import acl2s.uilib_driver.IAcl2sUiLibErrorHandler;
	import acl2s.uilib_driver.IAcl2sUiLibThreadManager;
	
	public class InteractiveSessionManager implements Pingable {
		static final boolean SNIP_STARTUP = true;  // for debugging
		
		protected final IAcl2sUiLibDriver driver;
		protected final IAcl2sUiLibThreadManager threadmgr;
		protected final IAcl2sUiLibErrorHandler errorHandler;
		protected final IAcl2sGraphicsFactory graphicsFactory;
		protected final ISessionClient client;
		protected final HashSet<ISessionStatusListener> listeners = new HashSet<ISessionStatusListener>(); 
		protected ISessionModel model;
		protected InteractiveSession session = null;
		protected boolean sessionReady = false;
		protected SessionThread thread = null;
		
		protected int status = 0;
		protected Exception exception = null; // non-null iff status is error
			
		public InteractiveSessionManager(IAcl2sUiLibDriver d, ISessionClient c, ISessionModel m) {
			client = c;
			model = m;
			driver = d;
			threadmgr = d.getThreadManager();
			errorHandler = d.getErrorHandler();
			graphicsFactory = d.getGraphicsFactory();
		}
		
	
		public synchronized int getStatus() {
			return status;
		}
	
		public boolean isAlive() {
			return getStatus() != NO_SESSION;
		}
	
		public synchronized Exception getError() {
			if (status == ERROR_SESSION) {
				assert exception != null;
				return exception;
			} else {
				assert exception == null;
				return null;
			}
		}
		
		public long getSecret() {
			if (session != null)
				return session.getSecret();
			else
				return 0;
		}
		
		
		public synchronized IEnvInfo getCurrentEnv() throws SessionBusyException, SessionDeadException {
			if (session != null) {
				IEnvInfo e = session.getEnvInfo();
				if (e == null) {
					throw new SessionBusyException();
				} else {
					return e;
				}
			} else {
				throw new SessionDeadException();
			}
		}
	
		public synchronized void updateModelEnv() throws SessionBusyException, SessionDeadException {
			if (session != null) {
				IEnvInfo e = session.getEnvInfo();
				if (e == null) {
					throw new SessionBusyException();
				} else {
					model.updateLastEnv(e);
				}
			} else {
				throw new SessionDeadException();
			}
		}
		
		/* Internal stuff called from either thread. */
		protected void updateStatus() {
			boolean asyncUpdate = false;
			synchronized (this) {
				int x;
					if (session == null) {
						x = NO_SESSION;
					} else if (!sessionReady) {
						x = STARTING_SESSION;
					} else if (thread.waiting) {
						if (thread.cmdInput) {
							x = READY_CMD_SESSION;
						} else {
							x = READY_MISC_SESSION;
						}
					} else {
						x = BUSY_SESSION;
					}
				if (x != status) {
					status = x;
					if (threadmgr.inEventThread()) {
						for (ISessionStatusListener l : listeners) {
							l.sessionStatusChanged(status);
						}
					} else {
						asyncUpdate = true;
					}
				}
			}
			if (asyncUpdate) {
				threadmgr.asyncExec(new Runnable() {
					public void run() {
						synchronized (InteractiveSessionManager.this) {
							for (ISessionStatusListener l : listeners) {
								l.sessionStatusChanged(status);
							}
						}
					}
				});
			}
		}
	
		
		
		
		/* These are always called from event thread. */
		public void addSessionStatusListener(ISessionStatusListener l) {
			listeners.add(l);
			l.sessionStatusChanged(getStatus());
		}
		
		public void removeSessionStatusListener(ISessionStatusListener l) {
			listeners.remove(l);
		}
		
		public synchronized void startNewSession(ISessionModel toModel, MyInteractiveSessionConfig config) throws IllegalStateException {
			assert threadmgr.inEventThread();
			if (session != null) {
				if (session.isAlive()) {
					throw new IllegalStateException();
				}
			}
			sessionReady = false;
			File dir = client.getDesiredCBD(); //safe since already in event thread
			session = new InteractiveSession(driver,config,dir);
			model = toModel;
			model.newSession();
			thread = new SessionThread(session,toModel);
			updateStatus();
			thread.start();
		}	
		
		public synchronized void endSession() throws SessionStateException, IllegalStateException {
			if (session == null) throw new IllegalStateException();
			if (!thread.waiting) throw new SessionBusyException();
			thread.noMoreInput();
			thread = null;
			session.close();
			session = null;
			updateStatus();
		}
		
		public synchronized void killSession() {
			if (session == null) return;
			thread.noMoreInput();
			thread = null;
			session.forkKill();
			session = null;
			updateStatus();
		}
	
		public synchronized void interruptSession() throws SessionDeadException {
			try {
				if (session == null) throw new SessionDeadException();
				session.interrupt();
				ping();
			} catch (SessionNotBusyException e) {
				// ignore
			} finally {
				updateStatus();
			}
		}
	
		public synchronized void scheduleAbort() throws SessionDeadException {
			if (thread == null) throw new SessionDeadException();

			thread.doAbort = true;
			
			ping();
		}
	
		public synchronized void dispose() {
			if (thread != null) {
				thread.noMoreInput();
				thread = null;
			}
			if (session != null) {
				session.dispose();
				session = null;
			}
			model = null;
		}	
		
		/* null means i won't be able to answer that question without a restart.
		 * SessionStateException means you caught me at the wrong time.  */
		public IResultInfo systemCmd(String cmd) throws SessionStateException {
			synchronized (this) {
				if (session == null) return null;
				try {
					IResultInfo r;
					do r = session.systemCmd(cmd);
					while (r.wasInterrupted());
					return r;
				} catch (SessionDeadException e) {
					killSession();
					return null;
				}
			}
		}
		
		public IResultInfo systemCmd2(String cmd) throws SessionStateException, SessionDeadException {
			IResultInfo foo = systemCmd(cmd);
			if (foo == null) {
				throw new SessionDeadException();
			} else {
				return foo;
			}
		}
		
		
		protected class SessionThread extends Thread {
			InteractiveSession ses;
			ISessionModel modl;
			StringBuffer snippedStartup;
			boolean flushed;
			boolean acl2WasStarted = false;
			IAcl2sGraphics graphics = null;
			
			public SessionThread(InteractiveSession s, ISessionModel to) {
				ses = s;
				modl = to;
			}
	
			public void run() {
				boolean startupProblem = false;
				try {
					threadmgr.addShutdownHook(ses.getKiller());
					ses.beginInit();
					threadmgr.syncExec(new Runnable() {
						public void run() {
							modl.appendOutputLine("Executing " + ses.getCmdLine()[0] + '\n');
							modl.appendOutputLine("Starting ACL2 in mode \"" + ses.getConfig().getDescriptionName() + "\"\n");
						}});
					snippedStartup = new StringBuffer();
					doStartupOutputAndPrompt();
					if (ses.getStatusInfo().wasInterrupted()) {
						throw new SessionDeadException();
					}
					synchronized (InteractiveSessionManager.this) {
						if (session == ses) {
							sessionReady = true;
						}
					}
					snippedStartup = null;
					
					updateStatus();
	
					// after startup
					for (;;) {
						synchronized (InteractiveSessionManager.this) { if (session != ses) break; }
						
						getNextInput();
						
						synchronized (InteractiveSessionManager.this) { if (session != ses) break; }
						
						if (in instanceof IInputInfo) { // cmd input
							IInputInfo f = (IInputInfo) in;
							nextInput(f);
							ses.userCmd(f.getACL2Input());
						} else if (in instanceof String) { // misc input
							break; // shouldn't happen here
						} else { // quit 
							if (quit) {
								ses.kill();
								break;
							}
							// else, interrupted => more output
						}
						
						doOutputAndPrompt();
					}
				} catch (SessionStateException sbe) {
					errorHandler.error("Error in ACL2 session thread.", sbe);
				} catch (IOException e) {
					startupProblem = true;
					errorHandler.warning("Error while creating ACL2 session.", e);
				} catch (SessionDeadException e) {
					String msg = "ACL2 died unexpectedly.";
					synchronized (InteractiveSessionManager.this) {
						if (session != ses) return;
						if (!sessionReady) {
							msg += " This could be caused by an incompatible/non-existant ACL2 version.";
							startupProblem = true;
						} else if (ses.getStatusInfo().wasInterrupted()) {
							if (File.separatorChar == '\\') {
								msg += " This could be caused by this build of ACL2" +
								"\nnot properly handling interruption requests (which has been fixed in" +
								"\nacl2_image 3.3.0.1; check for ACL2s updates), or this could just be the" +
								"\nunreliability of ACL2 in Windows.  Fortunately, \"Restart session\" should" +
								"\nautomatically reprocess everything to return you to the state you were in." +
								"";
							}
						}
					}
					errorHandler.warning(msg, e);
					modlOutput.enqueue("\n\n");
					modlOutput.enqueue(msg);
				} finally {
					
					synchronized (InteractiveSessionManager.this) {
						if (session == ses) {
							session = null;
						}
						if (thread == Thread.currentThread()) {
							thread = null;
						}
						updateStatus();
					}
					ses.kill();
					threadmgr.removeShutdownHook(ses.getKiller());
					if (startupProblem) {
						if (snippedStartup != null) {
							modlOutput.enqueue("\n========== previously hidden output (for debugging purposes): ==========\n");
							modlOutput.enqueue(snippedStartup.toString());
							threadmgr.asyncExec(modlOutputUpdaterStarter);
						}
						if (!acl2WasStarted) {
							errorHandler.needsImage(ses.getConfig());
						} else if (snippedStartup != null) {
							if (snippedStartup.indexOf("\"Recertify ACL2s system books\"") >= 0) {
								errorHandler.needsHooksCertification(ses.getConfig());
							} else if (snippedStartup.indexOf("This ACL2 image is older") >= 0) {
								errorHandler.needsImage(ses.getConfig());
							}
						}
					}
				}
			}
	
			private void nextInput(final IInputInfo i) {
				threadmgr.syncExec(new Runnable() {
					public void run() {
						if (quit) return;
						modl.nextInput(i);
					}});
			}
			
			private void doStartupOutputAndPrompt() throws SessionStateException, SessionDeadException {
				flushed = false;
				doStartupOutputUntilPrompt();
				if (ses.getEnvInfo() == null) {
					//ses.kill(); // will happen
					throw new SessionDeadException();
				}
				if (!modlOutput.isEmpty()) {
					threadmgr.syncExec(modlOutputSyncUpdater);
				}
				doPrompt();
			}
	
			private void doOutputAndPrompt() throws SessionStateException, SessionDeadException {
				flushed = false;
				doOutputUntilPrompt();
				if (!modlOutput.isEmpty()) {
					threadmgr.syncExec(modlOutputSyncUpdater);
				}
				doPrompt();
			}
	
			private void doPrompt() throws SessionStateException, SessionDeadException {
				final IStatusInfo info = ses.getStatusInfo();
				final IEnvInfo env = ses.getEnvInfo();
				if (!quit) {
					threadmgr.syncExec(new Runnable() {
						public void run() {
							int idx = modl.finishOutput(info,env);
							if (!env.inWormhole()) {
								int i = idx;
								while (i > 0 && modl.getEnv(i).inWormhole()) i--;
								client.commandCompleted(modl.getInput(i),info,i);
							}
						}});
				}
			}
			
			private void doStartupOutputUntilPrompt() throws SessionDeadException, SessionStateException {
				String line;
				for (;;) {
					line = ses.readLineUntilPrompt();
					if (line == null) {
						return;
					} else {
						asyncModlAppend(line);
						if (line.indexOf("ACL2 Version ") >= 0) {
							break;
						}
					}
				}
				for (;;) {
					line = ses.readLineUntilPrompt();
					if (line == null) {
						return;
					} else {
						asyncModlAppend(line);
						if (line.indexOf("General Public License") >= 0) {
							break;
						}
					}
				}
				acl2WasStarted = true;
				asyncModlAppend("\n For ACL2 (theorem prover) help, refer to\n   " +
						ses.getConfig().getBaseConfig().getDocBaseURL() + "acl2-doc.html\n" +
						" For ACL2s (interface) help, refer to\n   " +
						ses.getConfig().getBaseConfig().getACL2sDocURL() + "\n" +
						driver.getExtraInstructionOutput() +
						"\n");
				for (;;) {
					if (SNIP_STARTUP) {
						for (;;) {
							line = ses.readLineUntilPrompt();
							if (line == null) {
								return;
							} else {
								if (snippedStartup != null) {
									snippedStartup.append(line);
								}
								if (line.endsWith("${NoMoReSnIp}$\n")) {
									break;
								}
							}
						}
					}
					for (;;) {
						line = ses.readLineUntilPrompt();
						if (line == null) {
							return;
						} else {
							if (SNIP_STARTUP && line.endsWith("${SnIpMeHeRe}$\n")) {
								if (snippedStartup != null) {
									snippedStartup.append(line);
								}
								break;
							}
							asyncModlAppend(line);
						}
					}
				}
			}
			
			private transient StringBuffer graphicsStuff = new StringBuffer();
			
			private void openGraphics() {
				if (graphics == null && graphicsFactory != null) {
					graphics = graphicsFactory.createGraphics(new Pingable[] { InteractiveSessionManager.this },
							                                  new File[] { client.getDesiredCBD() });
				}
			}
			
			private void disposeGraphics() {
				if (graphics != null) {
					final IAcl2sGraphics oldGraphics = graphics;
					graphics = null;
					threadmgr.asyncExec(new Runnable() {
						public void run() {
							oldGraphics.dispose();
						}					
					});
				}
			}
			
			// non-null => incomplete stuff (null line)
			private String doGraphicsOp() throws SessionDeadException, SessionStateException {
				graphicsStuff.setLength(0);
				for (;;) {
					String line = ses.readLineUntilPrompt();
					if (line == null) {
						// must have been interrupted
						// hmm.
						return graphicsStuff.toString();
					} else {
						if (line.endsWith(END_GRAPHICS_OP)) {
							int len = line.length();
							line = line.substring(0, len - END_GRAPHICS_OP_LEN);
							graphicsStuff.append(line);
							break;
						} else {
							graphicsStuff.append(line);
						}
					}
				}
				openGraphics();
				if (graphics != null) {
					try {
						final LispObject[] ops = LispObject.parseAll(new StringParser(CanonicalParseContext.instance, graphicsStuff));
						threadmgr.asyncExec(new Runnable() {
							public void run() {
								for (LispObject op : ops) {
									try {
										graphics.processTargetedOperation(op);
									} catch (Acl2sTargetedOperationException e) {
										IEnvInfo env = modl.getEnv(modl.countCompletedCmds());
										IParseContext pc;
										if (env != null) {
											pc = env.getParseContext();
										} else {
											pc = null;
										}
										modl.appendOutputLine("ACL2s Error: While processing graphics operation,\n\t" +
												op.toString(pc) + "\nthe following error was reported:\n\t" + e.toString() + "\n");
									}
								}
							}
						});
					} catch (ParseException e) {
						errorHandler.error("Bad graphics output read (ignored)", e);
					}
				}
				return null;
			}
			
			// non-null => incomplete stuff (null line)
			private String doGraphicsEvent() throws SessionDeadException, SessionStateException {
				graphicsStuff.setLength(0);
				openGraphics();
				for (;;) {
					String line = ses.readLineUntilPrompt();
					if (line == null) {
						// Read-object
						
						if (ses.interrupted() || ses.getEnvInfo() != null) {
							return graphicsStuff.toString();
						}
						
						if (graphics != null) {
							getNextGraphicsEvent();
							if (in == null) {
								if (ses.interrupted() || ses.getEnvInfo() != null) {
									return graphicsStuff.toString();
								}
								ses.miscInput("()");
							} else {
								ses.miscInput(((ILispUnparsable)in).toString(null));
							}
						} else {
							ses.miscInput("()"); // send nil if no graphics
						}
						
					} else if (line.endsWith(END_GRAPHICS_EVENT)) {
						return null;
					} else {
						graphicsStuff.append(line);
					}
				}
			}
			
			private void doOutputUntilPrompt() throws SessionDeadException, SessionStateException {
				try {
					for (;;) {
						String line = ses.readLineUntilPrompt();
						if (line == null) {
							if (checkPrompt()) {
								return;
							}
						} else {
							if (line.endsWith("$\n")) {
								if (line.endsWith(BEGIN_GRAPHICS_OP)) {
									int len = line.length();
									line = line.substring(0, len - BEGIN_GRAPHICS_OP_LEN);
									String leftovers = doGraphicsOp();
									if (leftovers != null) {
										line = line.concat(leftovers);
									}
								} else if (line.endsWith(BEGIN_GRAPHICS_EVENT)) {
									int len = line.length();
									line = line.substring(0, len - BEGIN_GRAPHICS_EVENT_LEN);
									String leftovers = doGraphicsEvent();
									if (leftovers != null) {
										line = line.concat(leftovers);
									}
								}
							}
							if (line.length() > 0) {
								asyncModlAppend(line);
							}
						}
					}
				} finally {
					disposeGraphics();
				}
			}
			
			private boolean checkPrompt() throws SessionDeadException, SessionStateException {
				if (ses.getEnvInfo() == null) {
					getNextInput();
					if (in instanceof IInputInfo) { // cmd input
						return true; // shouldn't happen here
					} else if (in instanceof String) { // misc input
						// TODO: special support for misc input?
						final String m = (String) in;
						ses.miscInput(m);
						threadmgr.syncExec(new Runnable() {
							public void run() {
								if (quit) return;
								modl.appendOutputLine(m + '\n');
							}});
						return false;
					} else { 
						if (quit) {
							ses.kill();
							return true;
						} else {
							//interrupted => more output
							return false;
						}
					}
				} else {
					return true;
				}
			}
			
			private void asyncModlAppend(final String s) {
				if (modlOutput.maybeEnqueue(s)) {
					// enqueued
					if (modlOutput.size() == 1) {
						// was empty & now not empty
						threadmgr.asyncExec(modlOutputUpdaterStarter);
					}
				} else {
					threadmgr.syncExec(new Runnable() {
						public void run() {
							List<String> ss = modlOutput.maybeDequeueAll();
							if (ss.size() > 0) {
								modl.appendOutputLines(ss);
								//System.out.println("Flush!");
							}
							modlOutput.enqueue(s);
							flushed = true;
						}
					});
				}
			}
			
			final BoundedBlockingQueue<String> modlOutput = new BoundedBlockingQueue<String>(100);
			final Runnable modlOutputUpdaterStarter = new Runnable() {
				public void run() {
					if (quit) return;
					threadmgr.delayedExec(modlOutputAsyncUpdater, 150, true);
				}
			};
	
			final Runnable modlOutputAsyncUpdater = new Runnable() {
				public void run() {
					if (quit) return;
					if (flushed) {
						flushed = false;
						threadmgr.delayedExec(modlOutputAsyncUpdater, 150, true);
					} else {
						List<String> ss = modlOutput.maybeDequeueAll();
						if (ss.size() > 0) {
							modl.appendOutputLines(ss);
							//System.out.println("Update!");
						}
					}
				}
			};
	
			final Runnable modlOutputSyncUpdater = new Runnable() {
				public void run() {
					List<String> ss = modlOutput.maybeDequeueAll();
					if (ss.size() > 0) {
						modl.appendOutputLines(ss);
						//System.out.println("SyncUpdate!");
					}
				}
			};
	
			
			/* stuff that communicates with session manager */
			boolean cmdInput = false;
			boolean waiting = false;
			
			Object in = null;
			
			boolean quit = false;
			boolean doAbort = false;
			
			void getNextInput() throws SessionDeadException {

				synchronized (InteractiveSessionManager.this) {
					if (waiting) throw new IllegalStateException("Multiple threads trying to get session input!");
					in = null;
					if (!ses.isAlive()) throw new SessionDeadException();
					if (quit) return;
					waiting = true;
					IEnvInfo env = ses.getEnvInfo();
					cmdInput = env != null;
					for (;;) {
						if (!ses.isAlive()) throw new SessionDeadException();
						if (env == null && ses.interrupted()) break;

						if (doAbort && env != null) { 

							doAbort = false;
							if (env.getLdLevel() > 1) {
								in = AbortInput.instance;
								break;
							}
						}
						final boolean clientRead = env != null && !env.inWormhole();
						threadmgr.asyncExec(new Runnable() {
							public void run() {
								synchronized (InteractiveSessionManager.this) {
									if (clientRead) {
										if (in != null) { InteractiveSessionManager.this.notifyAll(); return; }
										in = client.nextInputOption();
										if (in != null) { InteractiveSessionManager.this.notifyAll(); return; }
									}
									updateStatus();
								}
							}
						});
						//if (in != null) break;
						try {
							InteractiveSessionManager.this.wait();
						} catch (InterruptedException e) { }
						if (in != null) break;
						if (quit) { in = null; break; }
					}
					waiting = false;
					updateStatus();
				}
			}
			
			void getNextGraphicsEvent() throws SessionDeadException {
				synchronized (InteractiveSessionManager.this) {
					if (waiting) throw new IllegalStateException("Multiple threads trying to get session input!");
					in = null;
					waiting = true;
					for (;;) {
						if (quit || ses.getEnvInfo() != null) break;
						if (!ses.isAlive()) throw new SessionDeadException();
						if (ses.interrupted()) break;
						
						in = graphics.maybePopNextEvent();
						
						if (in != null) break;
						try {
							InteractiveSessionManager.this.wait();
						} catch (InterruptedException e) { }
					}
					waiting = false;
					updateStatus();
				}
			}
			
			// these are called already synchronized on InteractiveSessionManager.this
			void noMoreInput() {
				quit = true;
				InteractiveSessionManager.this.notifyAll();
			}
			
			void ping() {
				InteractiveSessionManager.this.notifyAll();
			}
			
			void submitCmdInput(IInputInfo cmd) throws SessionStateException, SessionDeadException {
				if (!waiting) throw new SessionBusyException();
				if (quit) throw new SessionDeadException();
				if (in != null) throw new SessionBusyException();
				if (!cmdInput) throw new SessionStateException();
				in = cmd;
				InteractiveSessionManager.this.notifyAll();
			}
			
			void submitMiscInput(String misc) throws SessionStateException, SessionDeadException {
				if (!waiting) throw new SessionBusyException();
				if (quit) throw new SessionDeadException();
				if (in != null) throw new SessionBusyException();
				if (cmdInput) throw new SessionStateException();
				in = misc;
				InteractiveSessionManager.this.notifyAll();
			}
		}
		
		
		synchronized SessionThread getThread() {
			return thread;
		}
			
		public synchronized void ping() {
			if (thread != null) {
				thread.ping();
			} 
			/* else {  // simulate UNDO and REDO even with no session
				IInputInfo in = client.nextInputOption();
				if (in instanceof UndoInput) { // undo or redo
					final UndoInput undo = (UndoInput) in;
					
					IEnvInfo env1 = model.getEnv(model.countCompletedCmds());
					int superLen = env1.getSuperDoneSize() + env1.getSuperUndoneSize();
					IEnvInfo env2 = undo.getUndoneTargetEnv(superLen);
					
					try {
						model.nextInput(undo);
						final int idx = model.finishOutput(undo, env2);
						client.commandCompleted(undo,undo,idx);
					} catch (IllegalStateException ise) {
						// ignore
					}
				}
			} */
		}
	
		public synchronized void submitCmdInput(IInputInfo cmdIn) throws SessionStateException, SessionDeadException {
			try {
				if (thread != null) {
					thread.submitCmdInput(cmdIn);
				} else {
					throw new SessionDeadException();
				}
			} finally {
				updateStatus();
			}
		}
		
		public synchronized void submitMiscInput(String miscIn) throws SessionStateException, SessionDeadException {
			try {
				if (thread != null) {
					thread.submitMiscInput(miscIn);
				} else {
					throw new SessionDeadException();
				}
			} finally {
				updateStatus();
			}
		}
		
		public synchronized void noMoreInput() {
			if (thread != null) {
				thread.noMoreInput();
			}
		}
	
	
	/*
		public Runnable blockingInputSubmitter(final IInputInfo input) {
			return new Runnable() {
				public void run() {
					synchronized (A2sSessionManager.this) {
						while (status == BUSY_SESSION && thread != null && !thread.waiting) {
							try {
								A2sSessionManager.this.wait();
							} catch (InterruptedException e) {
							}
						}
						if (status == READY_SESSION) {
							try {
								submitMiscInput(input);
							} catch (SessionBusyException e) {
								// impossible
							} catch (SessionDeadException e) {
								// impossible
							}
						}
					}
				}
			};
		}
	*/
	
		static final String BEGIN_GRAPHICS_OP = "$GrApHiCs-Op{$\n";
		static final int BEGIN_GRAPHICS_OP_LEN = BEGIN_GRAPHICS_OP.length();
		static final String END_GRAPHICS_OP = "$GrApHiCs-Op}$\n";
		static final int END_GRAPHICS_OP_LEN = END_GRAPHICS_OP.length();
		static final String BEGIN_GRAPHICS_EVENT = "$GrApHiCs-EvEnT{$\n";
		static final int BEGIN_GRAPHICS_EVENT_LEN = BEGIN_GRAPHICS_EVENT.length();
		static final String END_GRAPHICS_EVENT = "$GrApHiCs-EvEnT}$\n";
		static final int END_GRAPHICS_EVENT_LEN = END_GRAPHICS_EVENT.length();
		
	}