package com.fzzy.api.service;

import com.bstek.dorado.annotation.Expose;
import com.fzzy.api.Constant;
import com.fzzy.api.entity.*;
import com.fzzy.api.utils.RedisConst;
import com.fzzy.api.utils.RedisUtil;
import com.fzzy.api.view.repository.*;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;


/**
 * 基础数据接口
 */
@Component
public class ApiCommonService {


    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private ApiConfsRep apiConfsRep;
    @Autowired
    private GbAreaRep gbAreaRep;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1104Rep api1104Rep;
    @Autowired
    private Api1105Rep api1105Rep;
    @Autowired
    private Api1106Rep api1106ep;

    /**
     * 刷新缓存- 接口配置参数
     * apiCommonService#flushConfCache
     */
    @Expose
    public List<ApiConfs> flushConfCache() {
        List<ApiConfs> list = apiConfsRep.findAll();

        if (null == list || list.isEmpty()) return null;

        String key;
        for (ApiConfs conf : list) {
            key = RedisConst.buildKey(RedisConst.KYE_CONF, conf.getKqdm());
            redisUtil.set(key, conf);
        }
        return list;
    }

    /**
     * 根据库区代码获取接口配置信息
     *
     * @return
     */
    public List<ApiConfs> listCacheConf() {
        String pattern = RedisConst.buildKey(RedisConst.KYE_CONF);
        Set<String> keys = redisUtil.keys(pattern);
        if (null == keys || keys.isEmpty()) {
            return flushConfCache();
        }

        List<ApiConfs> result = new ArrayList<>();
        for (String key : keys) {
            result.add((ApiConfs) redisUtil.get(key));
        }

        return result;
    }

    public ApiConfs getConf(String kqdm) {
        String key = RedisConst.buildKey(RedisConst.KYE_CONF, kqdm);
        ApiConfs result = (ApiConfs) redisUtil.get(key);

        if (null == result) {
            List<ApiConfs> list = flushConfCache();
            if (null == list || list.isEmpty()) return null;
            for (ApiConfs conf : list) {
                if (kqdm.equals(conf.getKqdm())) return conf;
            }
        }

        return result;
    }

    public void updateCacheConf(ApiConfs conf) {
        String key = RedisConst.buildKey(RedisConst.KYE_CONF, conf.getKqdm());
        redisUtil.set(key, conf);
    }

    /**
     * 刷新货位信息缓存
     */
    public void flushApi1105Cache(List<Api1105> list) {

        if (null == list || list.isEmpty()) {
            return;
        }

        String key;
        for (Api1105 api1105 : list) {
            if (null == api1105.getBizId()) {
                continue;
            }
            key = RedisConst.buildKey(Constant.API_CODE_1105, api1105.getHwdm());
            redisUtil.set(key, api1105);
        }
    }
    /**
     * 刷新货位信息缓存
     */
    public void flushApi1105Cache() {
        List<Api1105> list = api1105Rep.findAll();
        if(list!= null && list.size() > 0){
            String key;
            for (Api1105 api1105 : list) {
                if (null == api1105.getBizId()) {
                    continue;
                }
                key = RedisConst.buildKey(Constant.API_CODE_1105, api1105.getBizId());
                redisUtil.set(key, api1105);
            }
        }
    }
    /**
     * 获取货位缓存
     *
     * @param bizId
     * @return
     */
    public Api1105 getApi1105Cache(String bizId) {

        if (null == bizId) {
            return null;
        }

        return (Api1105) redisUtil.get(RedisConst.buildKey(Constant.API_CODE_1105, bizId));
    }

    public void flushApi1103Cache(List<Api1103> list) {
        if (null == list || list.isEmpty()) {
            return;
        }

        String key;
        for (Api1103 apiData : list) {
            if (null == apiData.getCfdm()) {
                continue;
            }
            key = RedisConst.buildKey(Constant.API_CODE_1103, apiData.getCfdm());
            redisUtil.set(key, apiData);
        }
    }

    public Api1103 getApi1103Cache(String id) {
        if (null == id) {
            return null;
        }
        return (Api1103) redisUtil.get(RedisConst.buildKey(Constant.API_CODE_1103, id));
    }

    public void flushApi1104Cache(List<Api1104> list) {
        if (null == list || list.isEmpty()) {
            return;
        }

        String key;
        for (Api1104 apiData : list) {
            if (null == apiData.getAjdh()) {
                continue;
            }
            key = RedisConst.buildKey(Constant.API_CODE_1104, apiData.getAjdh());
            redisUtil.set(key, apiData);
        }
    }

    public Api1104 getApi1104Cache(String id) {
        if (null == id) {
            return null;
        }
        return (Api1104) redisUtil.get(RedisConst.buildKey(Constant.API_CODE_1104, id));
    }

    public void flushApi1102Cache(List<Api1102> list) {
        if (null == list || list.isEmpty()) {
            return;
        }

        String key;
        for (Api1102 apiData : list) {
            if (null == apiData.getKqdm()) {
                continue;
            }
            key = RedisConst.buildKey(Constant.API_CODE_1102, apiData.getKqdm());
            redisUtil.set(key, apiData);
        }
    }

    public Api1102 getApi1102Cache(String id) {
        if (null == id) {
            return null;
        }
        return (Api1102) redisUtil.get(RedisConst.buildKey(Constant.API_CODE_1102, id));
    }

    /**
     * 根据粮食产地获取编码
     *
     * @param foodLocationName
     * @return
     */
    @SuppressWarnings("unchecked")
	public String getFoodLocationIdFromCache(String foodLocationName) {
        String key = RedisConst.buildKey("GB_AREA");
        List<GbArea> list = (List<GbArea>) redisUtil.get(key);
        if (null == list) {
            list = gbAreaRep.findAll();
            redisUtil.set(key, list);
        }

        for (GbArea area : list) {
            if(StringUtils.isEmpty(foodLocationName)){
                return null;
            }
            if (area.getName().indexOf(foodLocationName) != -1) return area.getCode();
        }

        return null;
    }

    /**
     * 根据单位代码获取统一单位编码
     * @param dwdm
     * @return
     */
    public String getTydwbm(String dwdm) {
        if(StringUtils.isEmpty(dwdm)){
            return dwdm;
        }

        Api1101 api1101= api1101Rep.findData(dwdm);
        if(null == api1101){
            return dwdm;
        }

        return api1101.getTydwbm();
    }

    /**
     * 根据库区代码获取统一库区编码
     * @param kqdm
     * @return
     */
    public String getTykqbm(String kqdm) {
        if(StringUtils.isEmpty(kqdm)){
            return kqdm;
        }

        Api1102 api1102= api1102Rep.findDataByKqdm(kqdm);
        if(null == api1102){
            return kqdm;
        }

        return api1102.getTykqbm();
    }

    /**
     * 根据仓房代码获取统一仓房编码
     * @param cfdm
     * @return
     */
    public String getTycfbm(String cfdm) {
        if(StringUtils.isEmpty(cfdm)){
            return cfdm;
        }

        Api1103 api1103= api1103Rep.findDataByCfdm(cfdm);
        if(null == api1103){
            return cfdm;
        }

        return api1103.getTycfbm();
    }

    /**
     * 根据廒间代码获取统一廒间编码
     * @param ajdm
     * @return
     */
    public String getTyajbm(String ajdm) {
        if(StringUtils.isEmpty(ajdm)){
            return ajdm;
        }

        Api1104 api1104 = api1104Rep.findByAjdh(ajdm);
        if(null == api1104){
            return ajdm;
        }

        return api1104.getTyajbm();
    }

    /**
     * 根据货位代码获取统一货位编码
     * @param hwdm
     * @return
     */
    public String getTyhwbm(String hwdm) {
        if(StringUtils.isEmpty(hwdm)){
            return hwdm;
        }

        Api1105 api1105= api1105Rep.findDataByHwdm(hwdm);
        if(null == api1105){
            return hwdm;
        }

        return api1105.getTyhwbm();
    }

    /**
     * 根据油罐代码获取统一油罐编码
     * @param ygdm
     * @return
     */
    public String getTyygbm(String ygdm) {
        if(StringUtils.isEmpty(ygdm)){
            return ygdm;
        }

        Api1106 api1106= api1106ep.findDataByYgdm(ygdm);
        if(null == api1106){
            return ygdm;
        }

        return api1106.getTyygbm();
    }

}