package com.iplatform.gather.cache;

import com.walker.connector.Address;

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

/**
 * 缓存使用的'存储对象'定义
 * @author shikeying
 * @date 2015年12月29日
 *
 */
public class StoreObject {

	private static final Boolean DUMMY = new Boolean(true);
	
//	private String id;
	
	/* 通过address缓存数据库信息 */
	private final Map<Address, DbCache> dbMap = new ConcurrentHashMap<Address, DbCache>();
	
	/* 通过MetaDbId缓存数据库信息 */
	private final Map<Long, DbCache> dbMetaIdMap = new ConcurrentHashMap<Long, DbCache>();
	
	/**
	 * 返回当前存储正在使用的数据库信息
	 * @return
	 */
	public Address getUsingAddress(){
		for(Map.Entry<Address, DbCache> entry : dbMap.entrySet()){
			if(entry.getValue().isUsing()){
				return entry.getKey();
			}
		}
		return null;
	}
	
	/**
	 * 返回给定的数据库中，元数据记录了有多少表
	 * @param address
	 * @return
	 */
	public int getTableSize(Address address){
		int i = 0;
		Address a = null;
		for(Map.Entry<Address, DbCache> entry : dbMap.entrySet()){
			a = entry.getKey();
			if(a.equals(address)){
				i = i + entry.getValue().getTableSize();
			}
		}
		return i;
	}
	
	/**
	 * 返回当前存储项目中，在给定主机上有几个数据库
	 * @param address
	 * @return
	 */
	public int getDatabaseSize(Address address){
		int i = 0;
		Address a = null;
		for(Map.Entry<Address, DbCache> entry : dbMap.entrySet()){
			a = entry.getKey();
			if(a.getUrl().equals(address.getUrl()) && a.getPort() == address.getPort()){
				i++;
			}
		}
		return i;
	}
	
	/**
	 * 根据输入的数据库地址信息，找到对应的metaDbId
	 * @param address
	 * @return
	 */
	public Long getMetaDbId(Address address){
		DbCache d = dbMap.get(address);
		if(d == null){
			return null;
		}
		for(Map.Entry<Long, DbCache> entry : dbMetaIdMap.entrySet()){
			if(entry.getValue().equals(d)){
				return entry.getKey();
			}
		}
		return null;
	}
	
	/**
	 * 根据元数据中数据库ID，查找缓存的数据库基本信息
	 * @param dbId
	 * @return
	 */
	public Address getDbCache(long dbId){
		DbCache db = dbMetaIdMap.get(dbId);
		if(db == null){
			return null;
		}
		Address address = new Address();
		address.setUrl(db.getIp());
		address.setPort(db.getPort());
		address.setService(db.getDatabaseName());
//		address.setAuthentication(db.get);
		return address;
		
	}
	
	public void addDb(Address address, long metaDbId){
		// 添加新数据库时，先把其他数据库设置为'不可用'状态
		DbCache d = dbMap.get(address);
		for(DbCache dc : dbMap.values()){
			dc.setUsing(false);
		}
		
		if(d == null){
			d = new DbCache();
			d.setDatabaseName(address.getServiceName());
			d.setIp(address.getUrl());
			d.setPort(address.getPort());
			d.setMetaDbId(metaDbId);
//			d.setUsing(address.isUsing());
			dbMap.put(address, d);
			dbMetaIdMap.put(metaDbId, d);
		} else {
			// 如果已经缓存，不再添加
		}
		d.setUsing(true); // 新创建的库，肯定正在被使用
	}
	
	public void removeDb(Address address){
		dbMap.remove(address);
	}
	
	/**
	 * 该方法允许通过表<code>dc_meta_table</code>中，通过db_id字段作为查询条件来找到dbCache对象，<br>
	 * 然后通过该对象来添加其表信息。</p>
	 * 此方法在系统缓存对象中调用：<code>DcMetaCacheProvider</code>
	 * @param dbId
	 * @param tableName
	 */
	public void addTable(long dbId, String tableName){
		DbCache d = dbMetaIdMap.get(dbId);
		if(d == null){
			throw new IllegalArgumentException("存储缓存中，未找到数据库信息。dbId = " + dbId + ", tableName = " + tableName);
		}
		d.addTable(tableName);
	}
	public void addTable(Address address, String tableName){
		DbCache d = dbMap.get(address);
		if(d == null){
			throw new IllegalArgumentException("存储缓存中，未找到数据库信息。address = " + address + ", tableName = " + tableName);
		}
		d.addTable(tableName);
	}
	
	public void removeTable(Address address, String tableName){
		DbCache d = dbMap.get(address);
		if(d == null){
			throw new IllegalArgumentException("存储缓存中，未找到数据库信息。address = " + address + ", tableName = " + tableName);
		}
		d.removeTable(tableName);
	}
	
	public boolean isExistDatabase(Address address){
		return dbMap.get(address) != null;
	}
	
	public boolean isExistTable(String storeId, Address address, String tableName){
		DbCache d = dbMap.get(address);
		if(d == null){
			throw new IllegalArgumentException("存储缓存中，未找到数据库信息。address = " + address + ", tableName = " + tableName);
		}
		return d.isExistTable(tableName);
	}
	
	private class DbCache{
		private String databaseName;
		private String ip;
		private int port = 0;
		
		private long metaDbId; // 元数据：数据库ID
		
		private ConcurrentHashMap<String, Boolean> tables = new ConcurrentHashMap<String, Boolean>();

		private boolean using = false;
		
		public boolean isUsing() {
			return using;
		}

		public void setUsing(boolean using) {
			this.using = using;
		}

//		public long getMetaDbId() {
//			return metaDbId;
//		}

		public void setMetaDbId(long metaDbId) {
			this.metaDbId = metaDbId;
		}

		public String getDatabaseName() {
			return databaseName;
		}

		public void setDatabaseName(String databaseName) {
			this.databaseName = databaseName;
		}

		public String getIp() {
			return ip;
		}

		public void setIp(String ip) {
			this.ip = ip;
		}

		public int getPort() {
			return port;
		}

		public void setPort(int port) {
			this.port = port;
		}

		public void addTable(String tableName){
			tables.putIfAbsent(tableName, DUMMY);
		}
		
		public void removeTable(String tableName){
			tables.remove(tableName);
		}
		
		public int getTableSize(){
			return tables.size();
		}
		
		public boolean isExistTable(String tableName){
			return tables.get(tableName) != null;
		}
		
		@Override
		public boolean equals(Object obj){
			if(obj != null && obj instanceof DbCache){
				DbCache d = (DbCache)obj;
				if(d.metaDbId == this.metaDbId){
					return true;
				}
			}
			return false;
		}
		
		private int hashCode = 0;
		
		@Override
		public int hashCode(){
			if(hashCode == 0){
				hashCode = new Long(this.metaDbId).hashCode();
			}
			return hashCode;
		}
	}
	
}