package com.qxueyou.scc.msg.service.impl;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
import org.springframework.stereotype.Service;

import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.service.ICacheService;
import com.qxueyou.scc.msg.model.MsgChatroomMsg;
import com.qxueyou.scc.msg.service.IChatroomMsgService;

@Service
public class ChatroomMessageBean implements IChatroomMsgService {

	@Autowired
	ICacheService redis;

	private static final int PAGE_SIZE = 20;

	private static final String CACHEKEY_MSG_QUEUE = "msg_chatroom_msg_"; // 实时消息队列
	private static final String CACHEKEY_MESSAGE_A_COUNT = "msg_chatroom_message_count_"; // A类消息总数
	private static final String CACHEKEY_MESSAGE_HISTORY = "msg_chatroom_msg_history_"; //历史消息
	
	private static final String CACHEKEY_ONLINE_COUNT = "msg_chatroom_online_count_"; // 在线人数
	private static final String CACHEKEY_PRAISE_COUNT = "msg_chatroom_praise_count_"; // 点赞数
	private static final String CACHEKEY_LOTTERY_COUNT = "msg_chatroom_lottery_count_"; // 签到数
	private static final String CACHEKEY_VIEW_COUNT = "msg_chatroom_view_count_"; // 浏览数
	private static final String CACHEKEY_LOTTERY_RESULT_COUNT = "msg_chatroom_lottery_result_count_"; //中奖结果
	private static final String CACHEKEY_REWARD_COUNT = "msg_chatroom_reward_count_"; //打赏次数
	private static final String CACHEKEY_CONSULT_COUNT = "msg_chatroom_consult_count_"; //咨询次数
	private static final String CACHEKEY_REWARD_AMOUNT = "msg_chatroom_reward_amount_"; //打赏金额

	/**
	 * 发送消息
	 */

	@Override
	public Result doSendMessage(String chatroomId, String senderId,
			String imgPath, String alias, String content, Integer type, String userType) {

		MsgChatroomMsg mes = new MsgChatroomMsg();
		mes.setMsgId(redis.incr("ChatroomMsgId"));
		mes.setChatroomId(chatroomId);
		mes.setSenderId(senderId);
		mes.setContent(content);
		mes.setType(type);
		mes.setAlias(alias);
		mes.setUserType(userType);
		mes.setImgPath(imgPath);
		mes.setCreateTime(new Date());

		//缓存消息
		this.msgCache(chatroomId, mes);
		this.msgTypeCountCache(chatroomId, type);
		                    
		return new Result(true, null, mes);

	}
	
	/**
	 * 聊天消息剪切，
	 * 
	 * @param chatroomId
	 */
	@Deprecated
	private void msgListTrim(String key, String chatroomId){
		List<MsgChatroomMsg> mesList = redis.lstRange(key, 0l, -1l);
		if(mesList != null && !mesList.isEmpty()){
			if(mesList.size() <= PAGE_SIZE){
				return;
			}
			long index = 0;
			long time = System.currentTimeMillis();
			for(MsgChatroomMsg msg : mesList){
				if(time - msg.getCreateTime().getTime()<= 10000){
					break;
				}
				index ++;
			}
			//保留20条
			redis.lstTrim(key, mesList.size() - index <= 20?mesList.size()-20:index, -1l);
		}
	}
	
	/**
	 * 缓存消息
	 * 
	 * @param chatroomId
	 * @param mes
	 */
	private void msgCache(String chatroomId, MsgChatroomMsg mes){
		String key = CACHEKEY_MSG_QUEUE + chatroomId;		
		
		//先获取10秒内的数据
//		this.msgListTrim(key, chatroomId);
//		List<MsgChatroomMsg> mesList = redis.lstRange(key, 0l, -1l);
		
		//获取PAGE_SIZE条以内的消息
		List<MsgChatroomMsg> mesList= redis.lstRange(key, 0l, PAGE_SIZE);
		
		//最近20消息过滤重复的点赞，进入，退出
		if((MsgChatroomMsg.TYPE_PRAISE == mes.getType() || MsgChatroomMsg.TYPE_ENTER == mes.getType() || MsgChatroomMsg.TYPE_EXIT == mes.getType())
				&& mesList.contains(mes)){
			return;
		}
		redis.lstRightPush(key, mes);
		redis.expire(key, 360, TimeUnit.DAYS);
	}
	
	/**
	 * 计数器
	 * 
	 * @param chatroomId
	 * @param type
	 */
	private void msgTypeCountCache(String chatroomId, Integer type){
		if(type == MsgChatroomMsg.TYPE_ENTER){//在线人数加一
			redis.incr(CACHEKEY_ONLINE_COUNT + chatroomId);
			redis.expire(CACHEKEY_ONLINE_COUNT + chatroomId, 360, TimeUnit.DAYS);
		}
		if(type == MsgChatroomMsg.TYPE_ENTER || type == MsgChatroomMsg.TYPE_PRAISE || type == MsgChatroomMsg.TYPE_LOTTERY 
				|| type == MsgChatroomMsg.TYPE_REWARD || type == MsgChatroomMsg.TYPE_CONSULT || type == MsgChatroomMsg.TYPE_LOTTERY_RESULT){
			redis.incr(this.getKey(chatroomId, type));
			redis.expire(this.getKey(chatroomId, type),  360, TimeUnit.DAYS);
		}else if(type == MsgChatroomMsg.TYPE_EXIT){//在线人数减一
			String key = CACHEKEY_ONLINE_COUNT + chatroomId;
			Long value = redis.getIncrValue(key);
			if(value.compareTo(0l)>0){
				redis.decr(key);
			}
			redis.expire(key,  360, TimeUnit.DAYS);
		}else if(type == MsgChatroomMsg.TYPE_NORMAL || type == MsgChatroomMsg.TYPE_LOTTERY_RESULT){//A类消息计数器
			redis.incr(CACHEKEY_MESSAGE_A_COUNT + chatroomId);
			redis.expire(CACHEKEY_MESSAGE_A_COUNT + chatroomId,  360, TimeUnit.DAYS);
		}
	}
	
	//获取缓存key值
	private String getKey(String chatroomId, Integer type){
		String key = "";
		switch(type){
			case MsgChatroomMsg.TYPE_PRAISE:
				key = CACHEKEY_PRAISE_COUNT + chatroomId;
				break;
			case MsgChatroomMsg.TYPE_LOTTERY:
				key = CACHEKEY_LOTTERY_COUNT + chatroomId;
				break;
			case MsgChatroomMsg.TYPE_ENTER:
				key = CACHEKEY_VIEW_COUNT + chatroomId;
				break;
			case MsgChatroomMsg.TYPE_REWARD:
				key = CACHEKEY_REWARD_COUNT + chatroomId;
				break;
			case MsgChatroomMsg.TYPE_CONSULT:
				key = CACHEKEY_CONSULT_COUNT + chatroomId;
				break;
			case MsgChatroomMsg.TYPE_LOTTERY_RESULT:
				key = CACHEKEY_LOTTERY_RESULT_COUNT + chatroomId;
				break;
			default:
				key = "";
		}
		return key;
	}

	/**
	 * 轮询
	 * 
	 * @param chatroomId
	 * @throws Exception
	 */
	@Override
	public Result latestMsg(String chatroomId) {
		List<MsgChatroomMsg> mesList = redis.lstRange(CACHEKEY_MSG_QUEUE + chatroomId, 0l, -1l);
		
		//奖金总数
		Long rewardAmount = redis.getIncrValue(CACHEKEY_REWARD_AMOUNT + chatroomId);
		
		Map<String, Object> data = new HashMap<String, Object>();
		//统计数据
		Map<String,Long> statistics = this.reStatistics(chatroomId);
		Integer maxPage = this.getMaxPage(chatroomId, String.valueOf(statistics.get("historyMsgCount")));
		data.put("maxPage", maxPage);
		data.put("currentPage", maxPage);
		data.put("onlineCount", statistics.get("onlineCount"));
		data.put("praiseCount", statistics.get("praiseCount"));
		data.put("viewCount", statistics.get("viewCount"));
		data.put("lotteryCount", statistics.get("lotteryCount"));
		data.put("rewardCount", statistics.get("rewardCount"));
		data.put("consultCount", statistics.get("consultCount"));
		data.put("rewardAmount", rewardAmount);
		data.put("dataList", mesList);
		data.put("serverTime", new Date());
		return new Result(true, null, data);
	}
	
	/**
	 * 获取浏览人次
	 * @param chatroomId
	 * @throws Exception
	 */
	@Override
	public Long getViewCount(String chatroomId){
		return redis.getIncrValue(CACHEKEY_VIEW_COUNT + chatroomId);
	}
	
	/**
	 * 重新统计数据，读取数据库
	 * 
	 * @param type
	 * @param statistics
	 * @return
	 */
	private Map<String,Long> reStatistics(String chatroomId){
		Long msgCount = nul2Zero(redis.getIncrValue(CACHEKEY_MESSAGE_A_COUNT + chatroomId));
		Long onlineCount = nul2Zero(redis.getIncrValue(CACHEKEY_ONLINE_COUNT + chatroomId));
		Long praiseCount = nul2Zero(redis.getIncrValue(CACHEKEY_PRAISE_COUNT + chatroomId));
		Long lotteryCount = nul2Zero(redis.getIncrValue(CACHEKEY_LOTTERY_COUNT + chatroomId));
		Long viewCount = nul2Zero(redis.getIncrValue(CACHEKEY_VIEW_COUNT + chatroomId));
		Long rewardCount = nul2Zero(redis.getIncrValue(CACHEKEY_REWARD_COUNT + chatroomId));
		Long lotteryResultCount = nul2Zero(redis.getIncrValue(CACHEKEY_LOTTERY_RESULT_COUNT + chatroomId));
		Long consultCount = nul2Zero(redis.getIncrValue(CACHEKEY_CONSULT_COUNT + chatroomId));
		
		Map<String, Long> result = new HashMap<>();
		result.put("msgCount", msgCount);
		//历史消息数量，正常消息、中奖消息，打赏消息
		result.put("historyMsgCount", msgCount+lotteryResultCount+rewardCount);
		result.put("onlineCount", onlineCount);
		result.put("praiseCount", praiseCount);
		result.put("lotteryCount", lotteryCount);
		result.put("viewCount", viewCount);
		result.put("rewardCount", rewardCount);
		result.put("consultCount", consultCount);
		return result;
	}
	
	private Long nul2Zero(Long value) {
		if(value==null) {
			return  0l;
		}
		return value;
	}
	
	/**
	 * 按页获取历史消息
	 */
	@Override
	public Result getHistoryMes(String chatroomId, Integer pageNo)
			{
		//统计数据
		List<MsgChatroomMsg> mesList = redis.lstRange(CACHEKEY_MSG_QUEUE + chatroomId, 0l, -1l);
		Map<String,Long> statistics = this.reStatistics(chatroomId);
		Integer maxPage = getMaxPage(chatroomId, String.valueOf(statistics.get("historyMsgCount")+mesList.size()));
		String key = CACHEKEY_MESSAGE_HISTORY + chatroomId+ "_" + pageNo;
		if (StringUtils.isEmpty(chatroomId) || pageNo == null
				|| pageNo > maxPage) {
			return new Result(false, "参数错误");
		}
		List<MsgChatroomMsg> msgList = redis.lstAll(key);
		msgList = this.distinct(msgList, chatroomId);
		Map<String, Object> data = new HashMap<>();
		data.put("currentPage", pageNo);
		data.put("maxPage", maxPage);
		data.put("dataList", msgList);
		return new Result(true, null, data);
	}
	
	/**
	 * 去除重复消息
	 * 
	 * @return
	 */
	private List<MsgChatroomMsg> distinct(List<MsgChatroomMsg> historyMsgList, String chatroomId){
		List<MsgChatroomMsg> lastMsgList = redis.lstRange(CACHEKEY_MSG_QUEUE + chatroomId, 0l, -1l);
		if(historyMsgList != null && !historyMsgList.isEmpty() && lastMsgList != null && !lastMsgList.isEmpty()){
			for(int i=historyMsgList.size()-1;i>= 0;i--){
				MsgChatroomMsg historyMsgChatroomMsg = historyMsgList.get(i);
				for(MsgChatroomMsg lastMsgChatroomMsg : lastMsgList){
					if(historyMsgChatroomMsg.getMsgId().equals(lastMsgChatroomMsg.getMsgId())){
						historyMsgList.remove(i);
						break;
					}
				}
			}
		}
		return historyMsgList;
	}


	/**
	 * 获取A类消息最大页码
	 * 
	 * @param chatroomId
	 * @return
	 */
	public Integer getMaxPage(String chatroomId, String msgCount) {
		Integer count = Integer.valueOf(msgCount);
		int maxPage = count % PAGE_SIZE == 0 ? count / PAGE_SIZE : count
				/ PAGE_SIZE + 1;
		return maxPage;
	}

}