package com.iplatform.base.cache;

import com.iplatform.base.Constants;
import com.iplatform.base.DeptCacheProvider;
import com.iplatform.base.service.DeptServiceImpl;
import com.iplatform.base.util.DeptUtils;
import com.iplatform.model.po.S_dept;
import com.walker.cache.Cache;
import com.walker.infrastructure.utils.JsonUtils;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.support.redis.cache.RedisCacheProvider;

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

public class RedisDeptCacheProvider extends RedisCacheProvider<String> implements DeptCacheProvider {

    private boolean allowCacheChildren = true;

    private DeptServiceImpl deptService;

    public void setDeptService(DeptServiceImpl deptService) {
        this.deptService = deptService;
    }

    public RedisDeptCacheProvider(){
        this.setUseRedis(true);
        this.setLoadPage(false);
    }

    @Override
    public void setAllowCacheChildren(boolean allow) {
        this.allowCacheChildren = allow;
    }

    @Override
    public S_dept getDept(long deptId) {
        // 超级用户虚拟一个机构
        if(deptId == 0){
            return DeptUtils.SUPER_VISOR_DEPT;
        }

        String data = this.getCacheData(String.valueOf(deptId));
        if(StringUtils.isEmpty(data)){
            logger.error("查询机构缓存不存在，重新加载:" + deptId);
            S_dept s_dept = this.deptService.queryOneDept(deptId);
            if(s_dept == null){
                throw new IllegalStateException("数据库加载机构不存在，id=" + deptId);
            }
            try {
                if(this.allowCacheChildren){
                    this.putDept(s_dept);
                } else {
                    this.putCacheData(String.valueOf(deptId), JsonUtils.objectToJsonString(s_dept));
                }
                return s_dept;
            } catch (Exception ex){
                throw new RuntimeException("添加 [机构] 缓存错误:" + ex.getMessage(), ex);
            }
        }
        try {
            return JsonUtils.jsonStringToObject(data, S_dept.class);
        } catch (Exception e) {
            throw new RuntimeException("获得机构缓存错误:" + deptId + ", " + e.getMessage(), e);
        }
    }

    @Override
    public void updateDept(S_dept s_dept) {
        try {
            this.updateCacheData(String.valueOf(s_dept.getId()), JsonUtils.objectToJsonString(s_dept));
        } catch (Exception e) {
            throw new RuntimeException("更新机构缓存错误:" + s_dept.getId() + ", " + e.getMessage(), e);
        }
    }

    @Override
    public void removeDept(long deptId) {
        String key = String.valueOf(deptId);
        String keyChildren = key + DeptUtils.KEY_CHILDREN_PREFIX;

        S_dept current = this.getDept(deptId);
        if(current == null){
            logger.warn("机构缓存已不存在，无需删除");
            return;
        }

        // 删除该机构子机构缓存列表
        this.removeCacheData(keyChildren);
        this.removeCacheData(key);

        if(current.getParent_id().longValue() == 0){
            return;
        }

        // 2023-07-17，针对机构较大的项目，是不需要把机构树放Redis缓存的。
        if(this.allowCacheChildren){
            // 更新父机构对应的childrenList
            String parentId = String.valueOf(current.getParent_id());
            List<String> parentChildrenList = this.getChildrenDeptIdOneLevel(current.getParent_id());
            if(parentChildrenList != null){
                parentChildrenList.remove(String.valueOf(deptId));
                try {
                    this.updateCacheData(parentId + DeptUtils.KEY_CHILDREN_PREFIX, JsonUtils.objectToJsonString(parentChildrenList));
                } catch (Exception e) {
                    throw new RuntimeException("删除机构缓存时，更新父节点childrenList报错:" + e.getMessage(), e);
                }
            }
        }
    }

    @Override
    public void putDept(S_dept s_dept) {
        String id = String.valueOf(s_dept.getId());
        try {
            // 添加机构对象缓存
            this.putCacheData(id, JsonUtils.objectToJsonString(s_dept));
            if(this.allowCacheChildren){
                // 2023-07-17
                // 添加机构子机构列表，目前为空列表
                this.putCacheData(id + DeptUtils.KEY_CHILDREN_PREFIX, JsonUtils.objectToJsonString(new ArrayList<String>(2)));
            }

            if(s_dept.getParent_id().longValue() == 0){
                // 顶级单位，没有父机构了
                logger.debug("顶级机构，不用更新父机构列表, " + id);
                return;
            }

            if(this.allowCacheChildren){
                // 2023-07-17
                // 更新父机构列表
                List<String> parentChildrenList = this.getChildrenDeptIdOneLevel(s_dept.getParent_id());
                if(StringUtils.isEmptyList(parentChildrenList)){
                    parentChildrenList = new ArrayList<>();
                }
                parentChildrenList.add(id);
                this.updateCacheData(String.valueOf(s_dept.getParent_id()) + DeptUtils.KEY_CHILDREN_PREFIX, JsonUtils.objectToJsonString(parentChildrenList));
                if(logger.isDebugEnabled()){
                    logger.debug("添加机构缓存，parentChildrenList = " + parentChildrenList);
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("添加 [机构] 缓存错误:" + e.getMessage(), e);
        }
    }

    @Override
    public List<String> getChildrenDeptIdOneLevel(long deptId) {
        if(this.allowCacheChildren){
            String key = String.valueOf(deptId) + DeptUtils.KEY_CHILDREN_PREFIX;
            String data = this.getCacheData(key);
            if(StringUtils.isEmpty(data)){
                logger.error("未找到缓存中子机构列表: " + key);
                return null;
            }
            try {
                return JsonUtils.jsonStringToObject(data, List.class);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        } else {
            // 2023-07-17，不支持缓存树结构，从数据库查询
            throw new UnsupportedOperationException("暂未实现代码：从数据库加载："+ deptId + " 下一级所有子机构ID集合");
        }
    }

    @Override
    public List<S_dept> getChildrenDeptOneLevel(long deptId) {
        List<String> childrenIdList = this.getChildrenDeptIdOneLevel(deptId);
        if(StringUtils.isEmptyList(childrenIdList)){
            return null;
        }

        List<S_dept> resultList = new ArrayList<>();
        S_dept s_dept = null;
        for(String id : childrenIdList){
            s_dept = this.getDept(Long.parseLong(id));
            resultList.add(s_dept);
        }
        return resultList;
    }

//    @Override
//    protected int loadDataToCache(Cache cache) {
//        List<S_dept> list = this.deptService.queryAllDeptListForCache();
//        if(!StringUtils.isEmptyList(list)){
//            // 如果redis中缓存数量和数据库中不一致（少），则清空redis缓存，重新加载数据库数据到缓存中。
//            long totalCache = cache.getPersistentSize();
//            if(totalCache < list.size()){
//                logger.info("redis缓存中[机构]数量小于实际用户，需要清空缓存重新加载! cache = " + totalCache + ", db = " + list.size());
//                cache.clear();
//                for(S_dept h : list){
//                    this.putDept(h);
//                }
//            }
//            return list.size();
//        }
//        return 0;
//    }

    @Override
    public String getProviderName() {
        return Constants.CACHE_NAME_DEPT;
    }

    @Override
    public Class<?> getProviderType() {
        return String.class;
    }

//    private static final String KEY_CHILDREN_PREFIX = ".children";
}