package com.iplatform.gather.support;

import com.walker.connector.Address;
import com.walker.db.DatabaseException;
import com.walker.db.TableInfo;
import com.walker.store.AbstractMetaDataEngine;
import com.walker.store.Repository;
import com.walker.store.repo.AbstractRepository;
import com.walker.store.repo.DatabaseRepository;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 测试元数据引擎
 * @author shikeying
 * @date 2015年12月17日
 *
 */
public class TestMetaDataEngine extends AbstractMetaDataEngine {

//	protected transient final Log logger = LogFactory.getLog(getClass());
	
	// key = storeId
	private final Map<String, Repository> cached = new ConcurrentHashMap<String, Repository>(2);
	
	// key = storeId
	private final Map<String, List<String>> tableCache = new ConcurrentHashMap<String, List<String>>();
	
	private final ConcurrentHashMap<String, Address> usingAddress = new ConcurrentHashMap<String, Address>();
	
	@Override
	public void saveNewAddress(String storeId, Address address) throws DatabaseException {
		AbstractRepository repo = (AbstractRepository)cached.get(storeId);
		if(repo == null){
			repo = new DatabaseRepository();
			repo.setId(storeId);
			cached.put(storeId, repo);
		}
		repo.addAddress(address);
		logger.debug("---- 缓存更新后，数据库： " + repo.getAddressList());
		
		// 同时，更新记录，对于当前存储，那个库正在被使用
		usingAddress.put(storeId, address);
		logger.debug("usingAddress.size = " + usingAddress.size());
	}

	@Override
	public void saveNewTable(String storeId, Address addr, String destTableName) throws DatabaseException {
		List<String> list = tableCache.get(storeId);
		if(list == null){
			list = new ArrayList<String>();
			tableCache.put(storeId, list);
		}
		if(!list.contains(destTableName)){
			list.add(destTableName);
		}
	}

	@Override
	public synchronized int getTableSize(Address address) {
		// 测试，查找数据库中的元数据
		return this.getDatabaseMetaEngine().getTableSize(address);
	}

	@Override
	public int getDatabaseSize(Address address) {
		return 1;
	}

	@Override
	public boolean isExistDatabase(String storeId, Address address) {
		List<Address> list = null;
		for(Repository repo : cached.values()){
			list = repo.getAddressList();
			for(Address addr : list){
				logger.debug("+++++++++ 要比较的地址：" + addr + ", 源地址：" + address);
				if(addr.equals(address)){
					return true;
				}
			}
		}
		return false;
	}

	@Override
	public boolean isExistTable(String storeId, Address address, String tableName) {
		List<String> list = tableCache.get(storeId);
		if(list == null){
			list = new ArrayList<String>();
			tableCache.put(storeId, list);
		}
		return list.contains(tableName);
	}

	@Override
	public Address getUsingAddress(String storeId) {
		logger.debug("====== usingAddress: " + usingAddress.size());
		for(Address a : usingAddress.values()){
			logger.debug("2-- " + a);
		}
		return usingAddress.get(storeId);
	}

	@Override
	public List<String> getFields(Address address, String tableName) {
		return this.getDatabaseMetaEngine().getFields(address, tableName);
	}

	@Override
	public Map<String, TableInfo> getTableRows(String storeId, long metaDbId, List<String> tableNameList) {
		return null;
	}

}