package specular.net;

import java.io.*;
import java.net.*;
import java.util.*;

/**
 *	SocketPool.java
 * 	Jeon HongSeong
 * 	2001.07.04
 */
public final class SocketPool 
{
	//Singleton
	private static SocketPool instance;
	
	private ArrayList free;
	private ArrayList used;
	private int count;
	
	//Configuration variable
	private static String HOST;
	private static int PORT;
	private static int MAX_COUNT;
	private static int INITIAL_COUNT;
	private static int TIMEOUT;
	private static boolean BLOCK;
	
	static {
		loadConf();		
		try {
			instance = new SocketPool();
		} catch(IOException e) {
			e.printStackTrace();	
		}
	}
	
	//Constructor
	private SocketPool() throws IOException {
		free = new ArrayList();
		used = new ArrayList();
		while(count<INITIAL_COUNT) {
			addSocket();
		}
	}
	
	public static SocketPool getInstance() 
		throws IOException 
	{
	if(instance==null) {
	  synchronized (SocketPool.class) {
	        if(instance==null) {
		instance = new SocketPool();	
	}	
	}	
	}
		
		return instance;
	} 
	
	//Loading the configuration from pool.properties file.
	private static void loadConf() {
		ResourceBundle rb = ResourceBundle.getBundle("pool") ;
		HOST = rb.getString("host");
		PORT = Integer.parseInt(rb.getString("port"));
		MAX_COUNT = Integer.parseInt(rb.getString("maxCons"));
		INITIAL_COUNT = Integer.parseInt(rb.getString("initialCons"));	
		String timeout = rb.getString("timeout");
		String block = rb.getString("block");
		if(block!=null) {
			BLOCK = Boolean.getBoolean(block);
			TIMEOUT = Integer.parseInt(timeout);
		}
		System.out.println("Socket Pooling Configuration ****************");
		System.out.println("Host : "+HOST);
		System.out.println("Port : "+PORT);
		System.out.println("Max_Count : "+MAX_COUNT);
		System.out.println("Min_Count : "+INITIAL_COUNT);
		System.out.println("BLOCK : "+BLOCK);
		System.out.println("TIMEOUT : "+TIMEOUT);
		System.out.println("---------------------------------------------");	
	}
	
	public Socket getSocket() 
		throws IOException 
	{
		return getSocket(BLOCK,TIMEOUT);	
	}
	
public synchronized Socket getSocket(boolean block, long timeout) 
throws IOException 
{
if(free.isEmpty()) {
	if(count<MAX_COUNT) {
		addSocket();	
	} else if(block) {
		try {
			synchronized(this) {
				wait(timeout);	
			}
		} catch(InterruptedException e) {
			e.printStackTrace();	
		}
		if(free.isEmpty()) {
			if(count<MAX_COUNT) {
			  addSocket();	
			} else {
			  throw new IOException("Timeout waiting "+
				for a socket to be released.");
			}	
		} 
	} else {
		throw new IOException("Maximum number "+
		of allowed Sockets reached");
	}			
}
Socket sck=null;
synchronized(used) {
	sck = (Socket)free.remove(free.size()-1);
	used.add(sck);
}
return sck;
}
	
public synchronized void release(Socket sck) 
	throws IOException 
{
	if(used.contains(sck)) {
		int idx = used.indexOf(sck);
		used.remove(idx);
		free.add(sck);	
	} else {
		throw new IOException("Socket " + sck +
				 " did not come from this SocketPool");
	}
	notify();		
}
	
public synchronized void closeAll() 
	throws IOException 
{
	for(int i=0;i<free.size();i++) {
		Socket sck = (Socket)free.remove(i);
		try {
			sck.close();
		} catch(IOException e) {
			System.out.println(e.toString());	
		}	
	}
	
	for(int i=0;i<used.size();i++) {
		used.remove(i);	
	}
}

private void addSocket() 
	throws IOException 
{
	Socket sck = new Socket(HOST,PORT);
	free.add(sck);
	count++;	
}
}

            
host=127.0.0.1
port=8080
maxCons=100
initialCons=10
block=true
timeout=500