/**
* TCNJ Computer Science Research Group - Clay Project
* Fall 2001
*
* Filename:   JDBCConnectionPool.java
* Version:    2001111800
* Last Change Made:	11-18-01
* Last Change Made By:    Michael Hulme
* CurrentStatus:          freshly cooked
*
* @author locasto2@tcnj.edu
* @author hulme2@tcnj.edu
*/


package edu.tcnj.cs.clay.util;

import java.util.*;
import java.sql.*;

public class JDBCConnectionPool implements Runnable {


	public static final int DEFAULT_MIN_CONNECTIONS = 5;
	public static final int DEFAULT_MAX_CONNECTIONS = 20;
	public static final int DEFAULT_CONNECTION_INCREMENT = 5;

	private Vector available;
	private Vector busy;

	private String driverName;
	private String connectionURL;
	private String username;
	private String password;
	private int minConn;
	private int maxConn;

	private JDBCConnectionPool(){
	}

	public JDBCConnectionPool( String driverName, String url, String username,
							   String password, String minConn, String maxConn ){

			this.driverName = driverName;
			connectionURL = url;
			this.username = username;
			this.password = password;

			try{

				this.minConn = Integer.parseInt( minConn );
				this.maxConn = Integer.parseInt( maxConn );

				this.minConn = Math.abs( this.minConn );
				this.maxConn = Math.abs( this.maxConn );

			}catch( NumberFormatException nfe ){

				minConn = DEFAULT_MIN_CONNECTIONS;
				minConn = DEFAULT_MIN_CONNECTIONS;

			}


			available = new Vector( maxConn );
			busy = new Vector( maxConn );



	}

public synchronized Connection getConnection() throws SQLException {
	if (!available.isEmpty()) {
		Connection existingconnection = (Connection)available.lastElement();
		
		int lastindex = available.size() - 1;
		available.removeElementAt(lastindex);
	
		if (existingconnection.isClosed()) {
			notifyAll();
			return(getConnection());
		} else {
			busy.addElement(existingconnection);
			if (maxconnections%DEFAULT_CONNECTION_INCREMENT==1) addMaxConnections();
			return(existingconnection);
		}
	} else {

		if ((totalConnections() < maxconnections) && !connectionpending) {
			makeBackgroundConnection();
		} else if (!waitIfBusy) {
			throw new SQLException("Connection limit reached");
		}


		try {
			wait();
		} catch (InterruptedException ie) {
			System.out.println(ie.getMessage());
		}
		
		return (getConnection());

	}

}

private void addMaxConnections() {
	maxconnections+=DEFAULT_CONNECTION_INCREMENT;
	Vector temp = new Vector(maxconnections);
	for (int i = 0; i<available.size(); i++) {
		temp.add(available.elementAt(i));
	}
	available = temp.clone();
}

private void subMaxConnections() {
	if (maxconnections>DEFAULT_CONNECTION_INCREMENT) {
		maxconnections-=DEFAULT_CONNECTION_INCREMENT;
		Vector temp = new Vector(maxconnections);
		for (int i = 0; i<available.size(); i++) {
			temp.add(available.elementAt(i));
		}
		available = temp.clone();
	}
}

private void makeBackgroundConnection() {
	
	connectionpending = true;

	try {
		Thread connectthread = new Thread(this);
		connectthread.start();
	} catch (OutOfMemoryError oome) {
		System.out.println(oome.getMessage());
	}

}

public void run() {

	do {
		try {
			Connection connection = makeNewConnection();
			synchronized(this) {
				available.addElement(connection);
				connectionpending = false;	
				notifyAll();	
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	} while (true);
}

private Connection makeNewConnection() throws SQLException {

	try {
		Class.forName(driver);
		Connection connection = DriverManager.getConnection(url, username, password);
		return connection;
	} catch (ClassNotFoundException cnfe) {
		System.out.println(cnfe.getMessage());
	}
	
}

public synchronized void free(Connection connection) {
	
	busy.removeElement(connection);
	available.addElement(connection);
	if (maxconnections%DEFAULT_CONNECTION_INCREMENT==1) subMaxConnections();
	notifyAll();

}

public synchronized int totalConnections() {
	return (available.size() + busy.size());
}

private void closeConnections (Vector connections) {
	try {
		for (int i=0; i<connections.size(); i++) {
			Connection connection = (Connection)connections.elementAt(i);
			if (!connection.isClosed()) {
				connection.close();
			}
		}
	} catch ( SQLException sqle ) {
		System.out.println(sqle.getMessage());
	}

}




}