package cn.slimsmart.thrift.demo.pool;

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * 連線池實現
 */
public class ConnectionProviderImpl implements ConnectionProvider, InitializingBean, DisposableBean {

	/** 服務的IP地址 */
	private String serviceIP;
	/** 服務的埠 */
	private int servicePort;
	/** 連線超時配置 */
	private int conTimeOut;
	/** 可以從快取池中分配物件的最大數量 */
	private int maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
	/** 快取池中最大空閒物件數量 */
	private int maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
	/** 快取池中最小空閒物件數量 */
	private int minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
	/** 阻塞的最大數量 */
	private long maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;

	/** 從快取池中分配物件，是否執行PoolableObjectFactory.validateObject方法 */
	private boolean testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW;
	private boolean testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN;
	private boolean testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE;

	/** 物件快取池 */
	private ObjectPool<TTransport> objectPool = null;

	@Override
	public TSocket getConnection() {
		try {
			// 從物件池取物件
			TSocket socket = (TSocket) objectPool.borrowObject();
			return socket;
		} catch (Exception e) {
			throw new RuntimeException("error getConnection()", e);
		}
	}

	@Override
	public void returnCon(TSocket socket) {
		try {
			// 將物件放回物件池
			objectPool.returnObject(socket);
		} catch (Exception e) {
			throw new RuntimeException("error returnCon()", e);
		}
	}

	@Override
	public void destroy() throws Exception {
		try {
			objectPool.close();
		} catch (Exception e) {
			throw new RuntimeException("erorr destroy()", e);
		}
	}

	@SuppressWarnings("deprecation")
	@Override
	public void afterPropertiesSet() throws Exception {
		// 物件池
		objectPool = new GenericObjectPool<TTransport>();
		//
		((GenericObjectPool<TTransport>) objectPool).setMaxActive(maxActive);
		((GenericObjectPool<TTransport>) objectPool).setMaxIdle(maxIdle);
		((GenericObjectPool<TTransport>) objectPool).setMinIdle(minIdle);
		((GenericObjectPool<TTransport>) objectPool).setMaxWait(maxWait);
		((GenericObjectPool<TTransport>) objectPool).setTestOnBorrow(testOnBorrow);
		((GenericObjectPool<TTransport>) objectPool).setTestOnReturn(testOnReturn);
		((GenericObjectPool<TTransport>) objectPool).setTestWhileIdle(testWhileIdle);
		((GenericObjectPool<TTransport>) objectPool).setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);
		// 設定factory
		ThriftPoolableObjectFactory thriftPoolableObjectFactory = new ThriftPoolableObjectFactory(serviceIP, servicePort, conTimeOut);
		objectPool.setFactory(thriftPoolableObjectFactory);
	}

	public String getServiceIP() {
		return serviceIP;
	}

	public void setServiceIP(String serviceIP) {
		this.serviceIP = serviceIP;
	}

	public int getServicePort() {
		return servicePort;
	}

	public void setServicePort(int servicePort) {
		this.servicePort = servicePort;
	}

	public int getConTimeOut() {
		return conTimeOut;
	}

	public void setConTimeOut(int conTimeOut) {
		this.conTimeOut = conTimeOut;
	}

	public int getMaxActive() {
		return maxActive;
	}

	public void setMaxActive(int maxActive) {
		this.maxActive = maxActive;
	}

	public int getMaxIdle() {
		return maxIdle;
	}

	public void setMaxIdle(int maxIdle) {
		this.maxIdle = maxIdle;
	}

	public int getMinIdle() {
		return minIdle;
	}

	public void setMinIdle(int minIdle) {
		this.minIdle = minIdle;
	}

	public long getMaxWait() {
		return maxWait;
	}

	public void setMaxWait(long maxWait) {
		this.maxWait = maxWait;
	}

	public boolean isTestOnBorrow() {
		return testOnBorrow;
	}

	public void setTestOnBorrow(boolean testOnBorrow) {
		this.testOnBorrow = testOnBorrow;
	}

	public boolean isTestOnReturn() {
		return testOnReturn;
	}

	public void setTestOnReturn(boolean testOnReturn) {
		this.testOnReturn = testOnReturn;
	}

	public boolean isTestWhileIdle() {
		return testWhileIdle;
	}

	public void setTestWhileIdle(boolean testWhileIdle) {
		this.testWhileIdle = testWhileIdle;
	}

	public ObjectPool<TTransport> getObjectPool() {
		return objectPool;
	}

	public void setObjectPool(ObjectPool<TTransport> objectPool) {
		this.objectPool = objectPool;
	}
}