package acl2s.lib.session;
	
	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStreamWriter;
	import java.io.Writer;
	import java.util.LinkedList;
	
	import org.peterd.util.ExceptionHandler;
	import org.peterd.util.Misc;
	import org.peterd.util.io.AsyncLineReader;
	import org.peterd.util.io.AsyncWriter;
	import org.peterd.util.process.KillableProcess;
	
	public class BatchSession {
		protected final BatchSessionConfig config;
		protected final File workingDir;
	
		protected KillableProcess proc;
		protected AsyncWriter acl2Input;
		protected OutputHandler outputHandler;
		protected long secret;
		protected String[] cmdLine;
	
		public BatchSession(BatchSessionConfig config, File workingDir) {
			proc = null;
			this.config = config;
			this.workingDir = workingDir;
		}
	
		public synchronized void init() throws IOException, IllegalStateException {

			if (proc != null)  throw new IllegalStateException();
			cmdLine = config.getBaseConfig().getCmdLine();
			proc = KillableProcess.exec(cmdLine, workingDir, config.getBaseConfig(), true);
			acl2Input = new AsyncWriter(new OutputStreamWriter(proc.getStdin())).fork();

			secret = Misc.random.nextLong() & 0xfffffffffffffffL;
	
			// All input

			String[] input = config.getStartup(secret);
			if (input != null) {
				for (int i = 0; i < input.length; i++) {
					acl2Input.write(input[i]);
				}
			}
			acl2Input.close(); // after all input, of course
			notifyAll();
		}
	
		public class OutputHandler extends Thread {
			protected final Writer dst;
			
			// access must be lock-protected
			protected ExceptionHandler<IOException> ioeh;
			protected IOException ioe = null;
			protected boolean snip = true;
			protected StringBuilder snippedOutput = null;
			protected LinkedList<Runnable> postEOFhooks = new LinkedList<Runnable>();
			
			OutputHandler(Writer dst) {
				if (!(dst instanceof BufferedWriter)) {
					dst = new BufferedWriter(dst);
				}
				this.dst = dst;
			}
			
			public Writer getDst() {
				return dst;
			}
			
			public synchronized void setExceptionHandler(ExceptionHandler<IOException> ioeh) {
				this.ioeh = ioeh;
			}
	
			public synchronized void setSnipEnabled(boolean snip) {
				this.snip = snip;
			}
			
			public synchronized void setSnipCaptureEnabled(boolean snipCapture) {
				if (snipCapture && snippedOutput == null) {
					snippedOutput = new StringBuilder();
				} else if (snippedOutput != null) {
					snippedOutput = null;
				}
			}
			
			public synchronized String getSnippedOutput() {
				if (snippedOutput == null) throw new IllegalStateException();
				return snippedOutput.toString();
			}
			
			public synchronized IOException getIOException() {
				return ioe;
			}
			
			void handleIOException(IOException ioe) {
				if (ioe == null) return;
				ExceptionHandler<IOException> h;
				synchronized (this) {
					this.ioe = ioe;
					h = ioeh;
				}
				if (h != null) {
					h.handleException(ioe);
				}
			}
			
			synchronized void handleSnippedOutputLine(String line) {
				if (snippedOutput != null) {
					snippedOutput.append(line);
					snippedOutput.append('\n');
				}
			}
			
			public synchronized void appendCloseOnEOFhook() {
				appendPostEOFhook(new Runnable() {
					public void run() {
						try {
							dst.close();
						} catch (IOException ioe) {
							handleIOException(ioe);
						}
					}
				});
			}
			
			public synchronized void appendPostEOFhook(Runnable r) {
				if (postEOFhooks == null) throw new IllegalStateException();
				postEOFhooks.addLast(r);
			}
			
			protected AsyncLineReader in = null; // only accessed by this thread
			public void run() {
				try {
					KillableProcess p; 
					synchronized (BatchSession.this) {
						while (proc == null) {
							try {
								BatchSession.this.wait();
							} catch (InterruptedException e) {
								// ignore
							}
						}
						p = proc;
					}
					in = new AsyncLineReader(new InputStreamReader(p.getStdout())).fork();
					boolean snip;
					synchronized (this) {
						snip = this.snip;
					}
					if (snip) {
						goWithSnip();
					} else {
						goNoSnip();
					}
					synchronized (BatchSession.this) {
						updateAlive();
						p = proc;
					}
					dst.write("//end of output\n");
					if (p != null) {
						p.waitFor2();
						synchronized (BatchSession.this) {
							proc = null; // make sure :)
						}
					}
					dst.write("//session terminated\n");
				} catch (IOException ioe) {
					handleIOException(ioe);
					kill();
				}
				
				LinkedList<Runnable> hooks;
				synchronized (this) {
					hooks = postEOFhooks;
					postEOFhooks = null;
				}
				for (Runnable r : hooks) {
					try {
						r.run();
					} catch (Throwable t) {
						// ignore
					}
				}
			}
			
			String readLine() throws IOException {
				try {
					// return a line if available
					String maybeLine = in.maybeReadLine();
					if (maybeLine != null) return maybeLine;
					// otherwise, flush output and wait (or return null)
					dst.flush();
					return in.readLine2();
				} catch (IOException ioe) {
					if (isAlive()) {
						dst.write("Error reading ACL2 output: " + ioe.getMessage());
						kill();
					}
					return null;
				}
			}
			
			public void goWithSnip() throws IOException {
				String line;
				for (;;) {
					line = readLine();
					if (line == null) return;
					dst.write(line);
					dst.write(newline);
					if (line.indexOf("ACL2 Version ") >= 0) {
						break;
					}
				}
				for (;;) {
					line = readLine();
					if (line == null) return;
					dst.write(line);
					dst.write(newline);
					if (line.length() < 2) {
						break;
					}
				}
				for (;;) {
					for (;;) {
						line = readLine();
						if (line == null) return;
						handleSnippedOutputLine(line);
						if (line.endsWith("${NoMoReSnIp}$")) {
							break;
						}
					}
					for (;;) {
						line = readLine();
						if (line == null) return;
						if (line.endsWith("${SnIpMeHeRe}$")) {
							handleSnippedOutputLine(line);
							break;
						}
						dst.write(line);
						dst.write(newline);
					}
				}
			}
	
			public void goNoSnip() throws IOException {
				String line;
				for (;;) {
					line = readLine();
					if (line == null) return;
					dst.write(line);
					dst.write(newline);
				}
			}
		}
		
		public synchronized OutputHandler createOutputHandler(Writer dst) {
			if (outputHandler != null) throw new IllegalStateException();
			outputHandler = new OutputHandler(dst);
			return outputHandler;
		}
		
		
		
		static final String newline = "\n";
		
		public void dispose() {
			kill();
		}
		
		public synchronized boolean isAlive() {
			updateAlive();
			return proc != null;
		}
		
		synchronized void updateAlive() {
			if (proc != null && !proc.isAlive()) {
				proc = null;
				notifyAll();
			}
		}
		
		public synchronized void kill() {
			if (proc != null) {
				proc.kill();
				proc = null;
			}
		}
		

		public long getSecret() { return secret; }
	
		public String[] getCmdLine() {
			return cmdLine;
		}
		
		public ISessionConfig getConfig() {
			return config;
		}
	
		public synchronized InputStream getRawOutput() throws IllegalStateException {
			if (outputHandler != null) throw new IllegalStateException();
			return proc.getStdout();
		}
	}