package project.item.internal;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import kernel.cache.RedisLocalCache;
import kernel.util.StringUtils;
import kernel.web.ApplicationUtil;
import project.item.ItemRedisKeys;
import project.item.ItemService;
import project.item.model.Item;
import project.item.model.ItemLever;
import project.redis.RedisHandler;

@SuppressWarnings("unchecked")
public class ItemServiceImpl implements ItemService {

	private RedisHandler redisHandler;
	
	private RedisLocalCache redisLocalCache;

	@Override
	public Item cacheBySymbol(String symbol, boolean localcache) {
		Item item = null;
		if (localcache) {
			item = (Item) redisLocalCache.get(ItemRedisKeys.ITEM_SYMBOL + symbol);
		} else {
			item = (Item) redisHandler.get(ItemRedisKeys.ITEM_SYMBOL + symbol);
		}

		return item;
	}
	
	@Override
	public List<Item> cacheGetAll() {
		List<Item> list = new ArrayList<Item>();
		Map<String, Item> cache = (ConcurrentHashMap<String, Item>) redisHandler.get(ItemRedisKeys.ITEM_MAP);
		if (null == cache || cache.values().size() <= 0) {
			return list;
		}
		for (Item item : cache.values()) {
			list.add(item);
		}
		return list;
	}

	public List<Item> cacheGetByMarket(String symbol) {
		List<Item> cacheGetAll = cacheGetAll();
		if (StringUtils.isNullOrEmpty(symbol)) {
			return cacheGetAll;
		}
		List<Item> result = new ArrayList<Item>();
		for (Item item : cacheGetAll) {
			if (symbol.equals(item.getSymbol()))
				result.add(item);
		}
		return result;
	}

	@Override
	public void update(Item entity) {
		if(null==entity) return;
		ApplicationUtil.executeUpdate(entity, "WHERE UUID=?", new Object[] {entity.getId()});
		redisHandler.setSync(ItemRedisKeys.ITEM_SYMBOL + entity.getSymbol(), entity);
		redisLocalCache.put(ItemRedisKeys.ITEM_SYMBOLDATA + entity.getSymbol_data(), entity);
	}
	
	@Override
	public Item cacheBySymbolData(String symbol_data) {
		Item item = (Item) redisLocalCache.get(ItemRedisKeys.ITEM_SYMBOLDATA + symbol_data);
		if (item == null) {
			Map<String, Item> cache = (ConcurrentHashMap<String, Item>) redisHandler.get(ItemRedisKeys.ITEM_MAP);
			for (String key : cache.keySet()) {
				Item item_cache = cache.get(key);
				if (item_cache.getSymbol_data().equals(symbol_data)) {
					redisLocalCache.put(ItemRedisKeys.ITEM_SYMBOLDATA + symbol_data, item_cache);
					return item_cache;
				}
			}
		}
		return item;
	}
	
	@Override
	public HashMap<String,Item> cacheBySymbolDatas(Set<String> symbol_datas) {
		if(null==symbol_datas || symbol_datas.isEmpty()) return null;
		Set<String> symbolDataSet=symbol_datas.stream().map(ele->ItemRedisKeys.ITEM_SYMBOLDATA+ele).collect(Collectors.toSet());
		
		HashMap<String,Item> filterMap=new HashMap<String,Item>();
		HashMap<String,Item> redisMap=redisLocalCache.getMap(symbolDataSet);
		if(redisMap.containsValue(null)) {
			Map<String, Item> redisCache=(ConcurrentHashMap<String, Item>) redisHandler.get(ItemRedisKeys.ITEM_MAP);
			Map<String, Item> transferMap=redisCache.values().stream().collect(Collectors.toMap(item->item.getSymbol_data(),item->item,(oldVal,newVal)->newVal));
			for(Map.Entry<String,Item> entry:redisMap.entrySet()) {
				if(null!=entry.getValue()) continue;
				String prefixSymbolData=entry.getKey();
				String symbolData=prefixSymbolData.substring(ItemRedisKeys.ITEM_SYMBOLDATA.length());
				Item cacheItem=transferMap.get(symbolData);
				if(null==cacheItem) continue;
				redisLocalCache.put(prefixSymbolData, cacheItem);
				filterMap.put(symbolData, cacheItem);
			}
		}
		
		return filterMap;
	}

	@Override
	public void add(Item entity) {
		if(null==entity) return;
		if(null==entity.getId()) entity.setId(ApplicationUtil.getCurrentTimeUUID());
		
		ApplicationUtil.executeInsert(entity);
		redisHandler.setSync(ItemRedisKeys.ITEM_SYMBOL + entity.getSymbol(), entity);
		
		//同时添加到map
		Map<String, Item> cache = (ConcurrentHashMap<String, Item>) redisHandler.get(ItemRedisKeys.ITEM_MAP);
		if(null == cache) cache = new ConcurrentHashMap<String, Item>();
		
		cache.put(entity.getSymbol(), entity);
		redisHandler.setSync(ItemRedisKeys.ITEM_MAP, cache);
	}

	@Override
	public List<ItemLever> findLever(String item_id) {
		Map<String, ItemLever> map = (Map<String, ItemLever>)redisHandler.get(ItemRedisKeys.ITEM_LEVER_ID + item_id);
		if (map != null) {
			List<ItemLever> list = new ArrayList<ItemLever>(map.values());
			Collections.sort(list, new Comparator<ItemLever>() {//按倍率排序
				@Override
				public int compare(ItemLever arg0, ItemLever arg1) {
					return new Double(arg0.getLever_rate()).compareTo(arg1.getLever_rate());
				}
			});
			return list;
		}
		return new ArrayList<ItemLever>();
	}
	
	/**
	 * 获取所有币种名称
	 */
	@Override
	public List<String> cacheGetAllSymbol() {
		List<Item> cacheGetAll = cacheGetAll();
		List<String> data = new ArrayList<String>();
		for (Item item : cacheGetAll) {
			data.add(item.getSymbol());
		}
		return data;
	}

	public void setRedisHandler(RedisHandler redisHandler) {
		this.redisHandler = redisHandler;
	}

	public void setRedisLocalCache(RedisLocalCache redisLocalCache) {
		this.redisLocalCache = redisLocalCache;
	}
}