package servlets;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

import com.sas.services.information.RepositoryInterface;
import com.sas.services.information.metadata.PathUrl;
import com.sas.services.session.SessionContextInterface;
import com.sas.services.session.SessionServiceInterface;
import com.sas.services.storedprocess.ExecutionException;
import com.sas.services.storedprocess.ExecutionInterface;
import com.sas.services.storedprocess.StoredProcessInterface;
import com.sas.services.storedprocess.StoredProcessServiceInterface;
import com.sas.services.user.UserContextInterface;
import com.sas.services.user.UserServiceInterface;
import com.sas.services.webapp.ServicesFacade;

public class StreamStoredProcess extends HttpServlet {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		// first, check to see if we are attempting to replay an image
		// if the stored process creates binary images, it will call back to
		// this servlet again using a image link in the generated html output

		String replayParam = request.getParameter("_program");
		if (null != replayParam && replayParam.equals("replay")) {
			replayImage(request, response);
		} else {
			// if not replaying, then we execute the stored process

			// we hardcode the paramters here, you may set these values by
			// any method you choose
			String repository = "Foundation";
			String storedProcess = "/Samples/Stored Processes/Sample: Shoe Sales by Region";
			String username = "username";
			String password = "password";
			String domain = "DefaultAuth";

			executeStoredProcess(request, response, repository, storedProcess,
					username, password, domain);
		}

	}

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doPost(request, response);
	}

	private void executeStoredProcess(HttpServletRequest request,
			HttpServletResponse response, String repository, String program,
			String username, String password, String domain)
			throws ServletException, IOException {

		HttpSession session = request.getSession();
		PrintWriter out = response.getWriter();
		response.setContentType("text/html");

		ExecutionInterface spExecution = null;
		try {

			UserServiceInterface userService = ServicesFacade.getUserService();
			UserContextInterface userContext = userService.newUser(username,
					password, domain);

			SessionServiceInterface sessionService = ServicesFacade
					.getSessionService();

			SessionContextInterface sessionContext = sessionService
					.newSessionContext(userContext); // (6) Get repository
			RepositoryInterface repos = userContext.getRepository("Foundation");
			if (repos == null) {
				out.println("Foundation repository not found.");
				return;
			}

			// (7) Find program in repository (use metadata
			// StoredProcessInterface)
			PathUrl path = new PathUrl("sbip://" + repository + program
					+ "(StoredProcess)");

			com.sas.services.storedprocess.metadata.StoredProcessInterface metadata = (com.sas.services.storedprocess.metadata.StoredProcessInterface) repos
					.getObjectByPath(path);

			if (metadata == null) {
				out.println("Program not found: " + program);
				return;
			}

			// (8) Get stored process service
			StoredProcessServiceInterface spService = ServicesFacade
					.getStoredProcessService();

			// (9) Make stored process object (use storedprocess
			// StoredProcessInterface)
			com.sas.services.storedprocess.StoredProcessInterface storedProcess = spService
					.newStoredProcess(sessionContext, metadata);

			session.setAttribute("SESSIONCONTEXT",
					(SessionContextInterface) sessionContext);
			session.setAttribute("SPSERVICE",
					(StoredProcessServiceInterface) spService);
			session.setAttribute("BINDER", new CustomBindingListener(
					sessionContext));

			HashMap paramMap = new HashMap();
			// We must set the url value back to the location of this servlet so
			// that the images may be replayed
			paramMap.put("_URL", request.getRequestURI());
			storedProcess.setParameterValues(paramMap);

			// (10) Run stored process
			spExecution = storedProcess.execute(false, null, false, null);

			// (11) Display results
			if (storedProcess.getResultType() == com.sas.services.storedprocess.StoredProcessInterface.RESULT_TYPE_STREAM) {

				// Set up reader
				String encoding = null;
				BufferedReader spStream;

				com.sas.io.InputStreamHeaderInterface header = spExecution
						.getInputStreamHeader("_WEBOUT");

				if (header != null)
					encoding = header.getCharacterEncoding();

				if (encoding != null) {
					spStream = new BufferedReader(new InputStreamReader(
							spExecution.getInputStream("_WEBOUT"), encoding));
				} else {
					spStream = new BufferedReader(new InputStreamReader(
							spExecution.getInputStream("_WEBOUT")));
				}

				// Get data and copy to out
				String line;
				while ((line = spStream.readLine()) != null) {
					out.println(line);
				}
			}

			// (12) Wait for completion
			int returnCode = spExecution.waitForCompletion();

			// (13) See if execute had an error
			if (returnCode == ExecutionInterface.STATUS_EXCEPTION_OCCURRED
					|| returnCode == ExecutionInterface.STATUS_SAS_EXCEPTION_OCCURRED) {
				ExecutionException[] errors = spExecution.getExceptions();
				out.println("Error executing stored process. ");

				for (int i = 0; i < errors.length; i++) {
					out.println(errors[i].getLocalizedMessage());
				}

				return;
			}

			// (14) Check SAS return code
			int sasrc = spExecution.getSASConditionCode();
			if (sasrc != 0 && sasrc != 4) {
				out.println("Error in SAS program. Return code:" + sasrc);
			}

			// (15) Print SAS log
			String log = spExecution.readSASLog(
					ExecutionInterface.LOG_FORMAT_HTML,
					ExecutionInterface.LOG_ALL_LINES);
			out.println(log);

		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			if (spExecution == null) {
				System.out
						.println("Unable to terminate stored process, spExecution = null");
				return;
			}
			try {
				spExecution.waitForCompletion();
				spExecution.destroy();
			} catch (Exception e) {
				System.out
						.println("Unable to destroy stored process execution");
				e.printStackTrace();
				return;
			}
		}

	}

	private void replayImage(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		ExecutionInterface spExecution = null;
		try {

			HttpSession session = request.getSession();
			// Get session context
			SessionContextInterface sessionContext = (SessionContextInterface) session
					.getAttribute("SESSIONCONTEXT");

			// Get stored process service
			StoredProcessServiceInterface spService = (StoredProcessServiceInterface) session
					.getAttribute("SPSERVICE");

			if (sessionContext == null || spService == null) {
				System.out.println("Missing session values");
				return;
			}

			// Create replay object
			com.sas.services.storedprocess.StoredProcessInterface storedProcess = spService
					.newStoredProcess(sessionContext,
							StoredProcessInterface.SERVER_TYPE_STOREDPROCESS,
							StoredProcessInterface.RESULT_TYPE_STREAM);
			storedProcess.setSourceFromFile("", "replay");
			storedProcess.setName("Replay");
			storedProcess.addInputStream("_WEBOUT");

			// Get URL parameters
			String program = null;
			String sessionval = null;
			HashMap paramMap = new HashMap();
			Enumeration params = request.getParameterNames();
			while (params.hasMoreElements()) {
				String key = (String) params.nextElement();
				String values[] = (String[]) request.getParameterValues(key);
				if (key.equalsIgnoreCase("_program"))
					program = values[0];
				if (key.equalsIgnoreCase("_sessionid"))
					sessionval = values[0];
				paramMap.put(key, values);
			}
			if (program == null || !program.equalsIgnoreCase("replay")) {
				System.out
						.println("The parameter _PROGRAM must be set to replay");
				return;
			}

			// Set stored process parameters
			storedProcess.setParameterValues(paramMap);

			// Run stored process
			try {
				spExecution = storedProcess.execute(false, null, false,
						sessionval);
			} catch (Exception e) {
				System.out.println("Error replaying images: "
						+ e.getLocalizedMessage());
				return;
			}

			// Handle results
			if (storedProcess.getResultType() == StoredProcessInterface.RESULT_TYPE_STREAM) {

				// Get header
				com.sas.io.InputStreamHeaderInterface header = spExecution
						.getInputStreamHeader("_WEBOUT");
				if (header != null) {
					Map headerlines = header.getHeaders();
					if (headerlines != null) {
						Iterator it = headerlines.keySet().iterator();
						while (it.hasNext()) {
							String key = it.next().toString();
							response.addHeader(key, (String) headerlines
									.get(key));
						}
					}
				}
				// Get data
				BufferedInputStream inData = new BufferedInputStream(
						spExecution.getInputStream("_WEBOUT"));
				BufferedOutputStream outData = new BufferedOutputStream(
						response.getOutputStream());
				byte[] buffer = new byte[4096];
				int n;
				while ((n = inData.read(buffer, 0, buffer.length)) > 0) {
					outData.write(buffer, 0, n);
				}
				outData.flush();
			}

		} catch (Exception e) {
			throw new RuntimeException(e);

		} finally {
			if (spExecution == null) {
				System.out
						.println("Unable to terminate stored process, spExecution = null");
				return;
			}
			try {
				spExecution.waitForCompletion();
				spExecution.destroy();
			} catch (Exception e) {
				System.out
						.println("Unable to destroy stored process execution");
				e.printStackTrace();
				return;
			}
		}

	}

	// Used to save/delete the session
	// this is necessary in order to call back and replay images
	private class CustomBindingListener implements HttpSessionBindingListener {
		private SessionContextInterface sessionContext = null;

		private Object lock;

		public CustomBindingListener(SessionContextInterface sessionContext) {
			try {
				this.sessionContext = sessionContext;
				this.lock = sessionContext
						.lock("com.sas.services.storedprocess.webapp");
			} catch (Exception e) {
			}
		}

		public void valueBound(HttpSessionBindingEvent event) {
		}

		public void valueUnbound(HttpSessionBindingEvent event) {
			try {
				if (sessionContext != null) {
					sessionContext.unlock(lock);
					sessionContext.destroy();
				}
			} catch (Exception e) {
			}
		}
	}
}