package com.walker.store.strategy;

import com.walker.connector.Address;
import com.walker.store.MetaDataEngine;
import com.walker.store.Repository;
import com.walker.store.StoreStrategy;
import com.walker.store.repo.DatabaseRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 基于数据库的存储策略实现
 * @author shikeying
 * @date 2015年12月16日
 *
 */
public abstract class DatabaseStoreStrategy implements StoreStrategy {

	protected transient final Logger logger = LoggerFactory.getLogger(getClass());
	
	protected DatabaseRepository repository = null;
	
	private MetaDataEngine metaDataEngine = null;
	
	private String storeId;
	
	private List<Address> defineAddressList = null;
	private int defineAddressSize = 0; // 定义的存储资源库中包含的地址数量
	
	protected String defineDbName = null; // 采集时定义的数据库名字
	
	public String getStoreId() {
		return storeId;
	}

	public void setStoreId(String storeId) {
		this.storeId = storeId;
	}

	@Override
	public MetaDataEngine getMetaDataEngine() {
		return metaDataEngine;
	}

	@Override
	public void setMetaDataEngine(MetaDataEngine metaDataEngine) {
		this.metaDataEngine = metaDataEngine;
	}

	/**
	 * 事先根据配置，设置需要的资源库，后续策略实现需要该数据。</p>
	 * 最初设想自动创建数据库，但感觉实际操作中风险过大，还是提前准备好。
	 * @param repository
	 */
	@Override
	public void setRepository(Repository repository) {
		if(repository != null && repository instanceof DatabaseRepository){
			this.repository = (DatabaseRepository)repository;
			defineAddressList = this.repository.getAddressList();
			if(defineAddressList != null){
				this.defineAddressSize = defineAddressList.size();
			}
			defineDbName = repository.getDefineName();
			logger.debug("设置了资源库：" + defineDbName);
			return;
		}
		throw new IllegalArgumentException("设置资源库对象出错：可能为空或者类型不匹配：" + repository);
	}
	
	@Override
	public List<Address> getDefineAddressList(){
//		return repository.getAddressList();
		return defineAddressList;
	}
	
	@Override
	public int getDefineAddressSize(){
		return this.defineAddressSize;
	}
	
	/**
	 * 获得经过策略挑选的数据库信息，如果业务只配置了一个则无需计算
	 * @param parameter 业务传递的参数
	 * @return
	 */
	public synchronized Address getDatabaseAddress(Object parameter){
		if(repository == null){
			throw new IllegalArgumentException("repository is required!");
		}
		List<Address> addresses = repository.getAddressList();
		if(addresses == null || addresses.size() == 0){
			throw new IllegalArgumentException("repository对象中未配置数据库信息!");
		}
		
		return this.doQueryAddress(this.storeId, addresses, parameter);
	}
	
	/**
	 * 获得策略计算的表名
	 * @param address 选择的数据库地址信息
	 * @param srcTable 业务提供的表名
	 * @param parameter 业务传递的参数
	 * @return
	 */
	public String getTableName(Address address, String srcTable, Object parameter){
//		if(address == null){
//			throw new IllegalArgumentException("计算表名策略中，未发现数据库地址信息，address = null!");
//		}
		return this.doQueryTableName(address, srcTable, parameter);
	} 
	
	/**
	 * 查询需要使用的数据库信息，由子类实现。如果就提供了一个库，则该方法不会被调用。
	 * @param addresses
	 * @param parameter
	 * @return
	 */
	protected abstract Address doQueryAddress(String storeId, List<Address> addresses, Object parameter);
	
	/**
	 * 查询需要使用的表名字，由子类实现具体选择表名的过程。
	 * @param address
	 * @param parameter
	 * @return
	 */
	protected abstract String doQueryTableName(Address address, String srcTable, Object parameter);
}