package net.curisit.securis;

import java.net.URI;
import java.util.Properties;

import javax.inject.Inject;
import javax.inject.Named;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import net.curisit.securis.ioc.RequestsModule;
import net.curisit.securis.ioc.SecurisModule;

import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.server.handler.ResourceHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.util.resource.Resource;
import org.jboss.resteasy.plugins.guice.GuiceResteasyBootstrapServletContextListener;
import org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.name.Names;
import com.google.inject.persist.PersistFilter;
import com.google.inject.persist.jpa.JpaPersistModule;

public class MainApp {

	private static final Logger log = LoggerFactory.getLogger(MainApp.class);

	private static Server server;
	private static Injector injector = null;

	@Inject
	@Named("base-uri")
	private URI uri;

	public static void main(String[] args) throws Exception {
		log.info("SeCuris init...");

		SecurisModule securisModule = new SecurisModule();
		JpaPersistModule jpaPersistModule = new JpaPersistModule("localdb");
		Properties props = new Properties();
		props.put("javax.persistence.jdbc.password", securisModule.getPassword());
		props.put("javax.persistence.jdbc.url", securisModule.getUrl(securisModule.getAppDir()));
		log.info("BD Url: {} {}", securisModule.getUrl(securisModule.getAppDir()), securisModule.getPassword());
		jpaPersistModule.properties(props);

		injector = Guice.createInjector(securisModule, new RequestsModule(), jpaPersistModule);
		// injector.getInstance(JpaInitializer.class);

		startServer(injector.getInstance(Key.get(URI.class, Names.named("base-uri"))));
		while (true) {
			Thread.currentThread().sleep(100);
		}
	}

	private static void startServer(URI uri) throws Exception {
		System.out.println("Starting jetty...");

		server = new Server(9997);
		ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
		context.setContextPath("/");
		context.addEventListener(injector.getInstance(GuiceResteasyBootstrapServletContextListener.class));

		context.setInitParameter("resteasy.role.based.security", "true");
		context.setInitParameter("resteasy.providers", DefaultExceptionHandler.class.getName());
		context.addFilter(new FilterHolder(injector.getInstance(AuthFilter.class)), "/*", null);
		context.addFilter(new FilterHolder(injector.getInstance(PersistFilter.class)), "/*", null);
		ServletHolder sh = new ServletHolder(HttpServletDispatcher.class);
		sh.setName("resteasy");
		context.addServlet(sh, "/*");

		ResourceHandler staticResources = new ResourceHandler();
		staticResources.setBaseResource(Resource.newResource(MainApp.class.getResource("/static").toURI()));
		staticResources.setWelcomeFiles(new String[]
			{ "/login.html" });
		context.setHandler(staticResources);

		// ErrorPageErrorHandler errorHandler = new ErrorPageErrorHandler();
		// context.setErrorHandler(errorHandler);
		// errorHandler.addErrorPage(HttpResponseCodes.SC_FORBIDDEN, "/login");
		// errorHandler.addErrorPage(HttpResponseCodes.SC_NOT_FOUND, "/");
		// errorHandler.addErrorPage(javax.ws.rs.NotFoundException.class, "/");
		// errorHandler.addErrorPage(javax.ws.rs.ForbiddenException.class, "/");
		// errorHandler.addErrorPage(javax.ws.rs.ForbiddenException.class.getCanonicalName(), "/");
		// errorHandler.addErrorPage(ErrorPageErrorHandler.GLOBAL_ERROR_PAGE, "/");
		context.setWelcomeFiles(new String[]
			{ "/index" });
		log.info("Error Handlers: " + context.getErrorHandler());
		ContextHandlerCollection contexts = new ContextHandlerCollection();

		contexts.setHandlers(new Handler[]
			{ staticResources, context });
		// server.setHandler(contexts);

		server.setHandler(context);
		server.start();
		server.join();
		log.info("Started server in: http://127.0.0.1:9997/");
	}

	@Provider
	public static class DefaultExceptionHandler implements ExceptionMapper<Exception> {

		public DefaultExceptionHandler() {
			log.info("Creating DefaultExceptionHandler ");
		}

		@Override
		public Response toResponse(Exception e) {
			// log.info("Creating DefaultExceptionHandler ");
			e.printStackTrace();
			// For simplicity I am preparing error xml by hand.
			// Ideally we should create an ErrorResponse class to hold the error info.
			StringBuilder response = new StringBuilder("<response>");
			response.append("<status>ERROR</status>");
			response.append("<message>" + e.getMessage() + "</message>");
			response.append("</response>");
			return Response.serverError().entity(response.toString()).type(MediaType.APPLICATION_XML).build();
		}
	}

}