package org.xvsm.remote.tcp;
   
   import java.io.IOException;
   import java.io.OutputStreamWriter;
   import java.net.ServerSocket;
   import java.net.Socket;
   import java.net.SocketException;
   import java.net.URI;
   import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  import org.xvsm.core.AtomicEntry;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.internal.ContainerManager;
  import org.xvsm.internal.EventProcessingPool;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.tasks.OperationTask;
  import org.xvsm.internal.tasks.OperationTaskType;
  import org.xvsm.internal.tasks.Task;
  import org.xvsm.remote.interfaces.IMarshaller;
  import org.xvsm.remote.interfaces.ITransportListener;
  import org.xvsm.remote.interfaces.ITransportSender;
  import org.xvsm.selectors.FifoSelector;
  import org.xvsm.selectors.Selector;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class WebAccess implements ITransportListener<byte[]>,
  		IMarshaller<byte[]>, ITransportSender<byte[]> {
  
  	// /***
  	// * The Logger.
  	// */
  	// private static Logger logger = Logger.getLogger(WebAccess.class);
  
  	/***
  	 * The maximal amount of Threads in the TcpListenerPool.
  	 */
  	private static final int MAX_THREADS = 5; // TODO: Get MAX_THREADS from
  
  	// Configuration.
  
  	/***
  	 * The ServerSocket of the TcpTransportListener.
  	 */
  	private ServerSocket ssocket;
  
  	/***
  	 * Indicates if the TcpTransportListener is running or not.
  	 */
  	private boolean running = false;
  
  	/***
  	 * The URI where the listener should listen.
  	 */
  	private URI inboundURI;
  
  	/***
  	 * The ExecutorService to execute the TcpListenerThreads.
  	 */
  	private ExecutorService service = Executors.newFixedThreadPool(MAX_THREADS);
  
  	/***
  	 * Default Constructor.
  	 */
  	public WebAccess() {
  
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	// @Override
  	public void setURI(URI nuri) {
  		this.inboundURI = nuri;
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	// @Override
  	public void run() {
  		Thread.currentThread().setName(this.getClass().getName());
  		this.running = true;
  		try {
  			ssocket = new ServerSocket(inboundURI.getPort());
  			while (this.running) {
  				this.service.execute(new HttpListenerThread(ssocket.accept()));
  			}
  
  		} catch (SocketException e) {
 			// Is thrown when the socket gets closed -> ignore
 
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void stop() {
 		try {
 			this.running = false;
 			this.ssocket.close();
 
 		} catch (IOException e) {
 			throw new FatalException(e);
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void setMarshaller(IMarshaller<byte[]> m) {
 
 	}
 
 	/***
 	 * 
 	 * @author Christian Schreiber, Michael Proestler
 	 * 
 	 */
 	class HttpListenerThread implements Runnable {
 
 		/***
 		 * The Socket over which the communication takes place.
 		 */
 		private Socket socket;
 
 		/***
 		 * Default Constructor.
 		 * 
 		 * @param socket
 		 *            The socket over which the communication takes place.
 		 */
 		public HttpListenerThread(Socket socket) {
 			this.socket = socket;
 		}
 
 		/***
 		 * {@inheritDoc}
 		 */
 		// @Override
 		@SuppressWarnings("unchecked")
 		public void run() {
 			Thread.currentThread().setName(this.getClass().getName());
 			// TODO: implement functionality
 			try {
 
 				List<ContainerRef> crefs = ContainerManager.getInstance()
 						.getAllContainer(null);
 				OutputStreamWriter writer = new OutputStreamWriter(socket
 						.getOutputStream());
 				writer.write("<h1>Welcome MozartSpaces</h1>");
 				writer
 						.write("<h4><br>Status: <font color=\"green\">Core running</font></h4>");
 				writer.write("<h4>Following container exist:</h4>");
 				for (ContainerRef cref : crefs) {
 					writer.write(cref.getId() + "<br>");
 				}
 
 				ContainerRef recent = ContainerManager.getInstance()
 						.getContainer(null, "Logger");
 
 				if (recent != null) {
 					writer.write("<h4>Recent Actions:</h4>");
 					List<Selector> selectors = new ArrayList<Selector>();
 					selectors.add(new FifoSelector(Selector.CNT_ALL));
 					OperationTask task = new OperationTask(
 							OperationTaskType.READ, null, recent, null,
 							selectors, ICapi.INFINITE_TIMEOUT);
 					EventProcessingPool.getInstance().execute(task);
 					List<Entry> entries = (List<Entry>) task.readResult();
 					for (Entry e : entries) {
 						try {
 							String s = new String();
 							Tuple t = (Tuple) e;
 							s += "Operation: "
 									+ ((AtomicEntry) t.getEntryAt(0))
 											.getValue() + " ";
 							s += "Type: "
 									+ ((AtomicEntry) t.getEntryAt(1))
 											.getValueClass().getSimpleName()
 									+ " ";
 							s += "Value: "
 									+ ((AtomicEntry) t.getEntryAt(1))
 											.getValue();
 
 							writer.write(s + "<br>");
 						} catch (ClassCastException e1) {
 							// ignore
 						}
 					}
 
 				}
 				writer.flush();
 				socket.close();
 
 			} catch (Exception e) {
 				// TODO Auto-generated catch block
 
 			}
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void send(URI uri, Task t) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public Task unmarshall(byte[] x) {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public byte[] marshall(Task y) {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	// @Override
 	public URI getUri() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void sendRequest(URI uri, Task t) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void sendResponse(URI uri, Task t) {
 		// TODO Auto-generated method stub
 
 	}
 }