package com.java110.rule.dao.impl;

import com.java110.common.constant.RuleDomain;
import com.java110.common.util.SerializeUtil;
import com.java110.core.base.dao.BaseServiceDao;
import com.java110.entity.rule.Rule;
import com.java110.entity.rule.RuleCondCfg;
import com.java110.entity.rule.RuleEntrance;
import com.java110.rule.dao.IRuleDao;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;

import java.util.*;

/**
 * Created by wuxw on 2017/7/23.
 */

@Service("ruleDaoImpl")
@Transactional
public class RuleDaoImpl extends BaseServiceDao implements IRuleDao {


    @Override
    public List<Map<String, String>> executeSql(String sql) throws Exception {
        return sqlSessionTemplate.selectList("ruleDaoImpl.executeSql",sql);
    }

    /**
     *
     * @param transactionId
     * @param paramIn
     * @param procName
     * @return
     * @throws Exception
     */
    @Override
    public String executeProc(String transactionId, String paramIn, String procName) throws Exception {

        Map<String,String> paramInMap = new HashMap<String,String>();
        paramInMap.put("transactionId",transactionId);

        paramInMap.put("procName",procName);

        paramInMap.put("paramIn",paramIn);

        long updateFlag = sqlSessionTemplate.update("ruleDaoImpl.executeProc",paramInMap);

        if (updateFlag > 0){
            return paramInMap.get("paramOut");
        }
        return null;
    }

    /**
     * 查询 rule_entrance表信息
     *
     * 这里逻辑，首先从ehCache 中获取数据，如果没有缓存，则校验redis中是否存在，如果不存在从数据库中查询，然后保存至redis中，
     * 自动缓存到ehcache 中（默认是10分钟）
     * @return
     * @throws Exception
     */
    @Override
    @Cacheable(key=RuleDomain.REDIS_KEY_RULE_ENTRANCE)
    public Map<String, RuleEntrance> getRuleEntranceMap() throws Exception {

        Jedis jedis = jedisPool.getResource();

        Map map = new HashMap();

        List<RuleEntrance> list = null;

        if(jedis.exists(RuleDomain.REDIS_KEY_RULE_ENTRANCE.getBytes())){
            list =  SerializeUtil.unserializeList(jedis.get(RuleDomain.REDIS_KEY_RULE_ENTRANCE.getBytes()),RuleEntrance.class);
        }else{
            list = sqlSessionTemplate.selectList("ruleDaoImpl.getRuleEntranceMap");
            //将 数据缓存至redis中

            jedis.set(RuleDomain.REDIS_KEY_RULE_ENTRANCE.getBytes(),SerializeUtil.serializeList(list));
        }

        if (null != list && !list.isEmpty()) {
            RuleEntrance ruleEntrance = null;
            for (int ruleEntranceIndex = 0;ruleEntranceIndex< list.size();ruleEntranceIndex++) {
                ruleEntrance =  list.get(ruleEntranceIndex);
                map.put(String.valueOf(ruleEntranceIndex), ruleEntrance);
            }
        }
        return map;
    }

    /**
     * 初始化业务规则分组和编码映射关联关系信息
     * @return
     * @throws Exception
     */
    @Override
    @Cacheable(key=RuleDomain.REDIS_KEY_RULE_GROUP)
    public List getRuleGroupRelaList() throws Exception {
        List saopRuleGroupRelaList = new ArrayList();

        Jedis jedis = jedisPool.getResource();

        if(jedis.exists(RuleDomain.REDIS_KEY_RULE_ENTRANCE.getBytes())){
            saopRuleGroupRelaList =  SerializeUtil.unserializeList(jedis.get(RuleDomain.REDIS_KEY_RULE_GROUP.getBytes()),Map.class);
        }else {
            //查询全部业务规则分组信息
            List allSaopRuleGroupInfoList = sqlSessionTemplate.selectList("ruleDaoImpl.querySaopRuleGroupMap");

            //业务分组和编码映射关系集合
            List allsaopRuleGroupRelaInfoList = sqlSessionTemplate.selectList("ruleDaoImpl.querySaopRuleGroupRelaMap");

            int allSaopRuleGroupInfoListSize = allSaopRuleGroupInfoList.size();
            int allsaopRuleGroupRelaInfoListSize = allsaopRuleGroupRelaInfoList.size();

            if (allSaopRuleGroupInfoListSize > 0 && allsaopRuleGroupRelaInfoListSize > 0) {
                for (int i = 0; i < allSaopRuleGroupInfoListSize; i++) {
                    //每个业务规则分组项
                    Map saopRuleGroupMap = (Map) allSaopRuleGroupInfoList.get(i);
                    if (null == saopRuleGroupMap || null == saopRuleGroupMap.get("groupId")) {
                        continue;
                    }

                    //当前规则分组编码
                    String curRuleGroupId = String.valueOf(saopRuleGroupMap.get("groupId"));

                    //当前业务规则分组下的规则编码集合
                    List ruleIdList = new ArrayList();
                    saopRuleGroupMap.put("ruleIdList", ruleIdList);

                    for (int j = 0; j < allsaopRuleGroupRelaInfoListSize; j++) {
                        Map saopRuleGroupRelaMap = (Map) allsaopRuleGroupRelaInfoList.get(j);
                        if (null == saopRuleGroupRelaMap || null == saopRuleGroupRelaMap.get("groupId")) {
                            continue;
                        }

                        //当前规则分组编码
                        String ruleRelaGroupId = String.valueOf(saopRuleGroupRelaMap.get("groupId"));

                        if (curRuleGroupId.equals(ruleRelaGroupId)) {
                            //获取规则编码
                            String ruleId = "";
                            if (null != saopRuleGroupRelaMap.get("rule_id")) {
                                ruleId = String.valueOf(saopRuleGroupRelaMap.get("rule_id"));
                            }

                            if (!StringUtils.isEmpty(ruleId)) {
                                ruleIdList.add(ruleId);
                            }
                        }
                    }
                }

                saopRuleGroupRelaList = allSaopRuleGroupInfoList;

                jedis.set(RuleDomain.REDIS_KEY_RULE_ENTRANCE.getBytes(),SerializeUtil.serializeList(saopRuleGroupRelaList));
            }
        }


        return saopRuleGroupRelaList;
    }

    @Override
    @Cacheable(key=RuleDomain.REDIS_KEY_RULE)
    public Map<String, Rule> getRuleMap() throws Exception {

        Jedis jedis = jedisPool.getResource();

        List<Rule> ruleList = null;

        Map map = new HashMap();

        if(jedis.exists(RuleDomain.REDIS_KEY_RULE.getBytes())){
            ruleList =  SerializeUtil.unserializeList(jedis.get(RuleDomain.REDIS_KEY_RULE.getBytes()),Rule.class);
        }else{
            ruleList = sqlSessionTemplate.selectList("ruleDaoImpl.queryRule");
            for (Rule rule : ruleList) {
                String ruleId = rule.getRule_id();
                List<RuleCondCfg> ruleCondCfgList = sqlSessionTemplate.selectList("ruleDaoImpl.queryRuleCondCfg", ruleId);
                rule.setRuleCondCfgs(ruleCondCfgList);
            }
            //将 数据缓存至redis中

            jedis.set(RuleDomain.REDIS_KEY_RULE.getBytes(),SerializeUtil.serializeList(ruleList));
        }

        if (null != ruleList && !ruleList.isEmpty()) {
            Rule rule = null;
            for (Iterator i = ruleList.iterator(); i.hasNext();) {
                rule = (Rule) i.next();
                map.put(rule.getRule_id(), rule);
            }
        }

        return map;
    }
}
