/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package sk.baka.ambient.commons;
  
  import java.io.BufferedInputStream;
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.InetAddress;
  import java.net.ServerSocket;
  import java.net.Socket;
  import java.net.SocketException;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.ThreadFactory;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import javax.net.ServerSocketFactory;
  
  import android.util.Log;
  
  /***
   * A server which listens on given port and executes tasks when the connection
   * is established. The server is stopped by default.
   * 
   * @author Martin Vysny
   */
  public abstract class SocketServer implements ThreadFactory, Closeable {
  	private ExecutorService executor = null;
  	private ServerSocket serverSocket = null;
  	private final ReadWriteLock serverStateLock = new ReentrantReadWriteLock();
  
  	/***
  	 * Checks if the server is started.
  	 * 
  	 * @return <code>true</code> if the server is started, <code>false</code>
  	 *         otherwise.
  	 */
  	public final boolean isStarted() {
  		serverStateLock.readLock().lock();
  		try {
  			return executor != null;
  		} finally {
  			serverStateLock.readLock().unlock();
  		}
  	}
  
  	/***
  	 * Starts the server. Does nothing if the server is started.
  	 * 
  	 * @param port
  	 *            the port to listen on.
  	 * @param bindTo
  	 *            listen on this interface. See
  	 *            {@link ServerSocketFactory#createServerSocket(int, int, InetAddress)}
  	 *            for details.
  	 * @throws IOException
  	 *             if server failed to start.
  	 */
  	public final void start(final int port, final InetAddress bindTo)
  			throws IOException {
  		serverStateLock.writeLock().lock();
  		try {
  			if (isStarted()) {
  				return;
  			}
  			executor = Executors.newCachedThreadPool(this);
  			serverSocket = ServerSocketFactory.getDefault().createServerSocket(
  					port, 0, bindTo);
  			executor.execute(new Server());
  		} finally {
  			serverStateLock.writeLock().unlock();
  		}
  	}
  
  	/***
  	 * Stops the server. Does nothing if the server is not started.
  	 */
  	public final void stop() {
  		serverStateLock.writeLock().lock();
 		try {
 			if (!isStarted()) {
 				return;
 			}
 			MiscUtils.closeQuietly(serverSocket);
 			onStopping();
 			serverSocket = null;
 			executor.shutdownNow();
 			executor = null;
 		} finally {
 			serverStateLock.writeLock().unlock();
 		}
 	}
 
 	/***
 	 * Invoked when the server is being stopped.
 	 */
 	protected void onStopping() {
 		// by default do nothing
 	}
 
 	public void close() {
 		stop();
 	}
 
 	private final AtomicInteger threadId = new AtomicInteger();
 
 	public final Thread newThread(Runnable r) {
 		final Thread result = new Thread(r, getClass().getSimpleName() + "-t-"
 				+ threadId.getAndIncrement());
 		result.setPriority(Thread.MIN_PRIORITY);
 		result.setDaemon(true);
 		return result;
 	}
 
 	/***
 	 * Handles a request. The communication is already opened and provided.
 	 * Implementor executes in a new thread. Implementor should periodically
 	 * check for {@link Thread#isInterrupted()}, terminating ASAP when
 	 * interrupted.
 	 * 
 	 * @param socket
 	 *            the socket for this request.
 	 * @param in
 	 *            opened read pipe from the socket.
 	 * @param out
 	 *            opened write pipe to the socket.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 * @throws ServerHttpException
 	 *             if HTTP error occurs. This error is written as a HTTP
 	 *             response. If you decide to throw this error then make sure
 	 *             that nothing was written yet to <code>out</code>.
 	 * @throws InterruptedException
 	 *             if interrupted.
 	 */
 	protected abstract void handleRequest(final Socket socket,
 			final InputStream in, final OutputStream out) throws IOException,
 			ServerHttpException, InterruptedException;
 
 	/***
 	 * Waits for a connection and starts the transfer.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private final class Server implements Runnable {
 		public void run() {
 			try {
 				final Socket socket = serverSocket.accept();
 				// connection accepted. Spawn new listener and start transfer
 				try {
 					serverStateLock.readLock().lock();
 					try {
 						if (executor == null) {
 							return;
 						}
 						executor.execute(new Server());
 					} finally {
 						serverStateLock.readLock().unlock();
 					}
 					handleRequest(socket);
 				} finally {
 					MiscUtils.closeQuietly(socket);
 				}
 			} catch (final SocketException e) {
 				// this happens when the server is stopped.
 			} catch (final Exception e) {
 				if (!Thread.currentThread().isInterrupted()) {
 					Log.e(SocketServer.class.getSimpleName(),
 							"Error while handling request", e);
 				}
 			}
 		}
 	}
 
 	private void handleRequest(Socket socket) throws IOException,
 			InterruptedException {
 		final InputStream in = new BufferedInputStream(socket.getInputStream());
 		final OutputStream out = socket.getOutputStream();
 		try {
 			handleRequest(socket, in, out);
 		} catch (ServerHttpException ex) {
 			Log.e(SocketServer.class.getSimpleName(), "HTTP error", ex);
 			ex.writeResponse((byte) 0, out);
 		} finally {
 			MiscUtils.closeQuietly(out);
 			MiscUtils.closeQuietly(in);
 		}
 	}
 }