package com.qianwen.core.cache.utils;

import java.lang.reflect.Field;
import java.util.List;
import java.util.concurrent.Callable;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.ClassUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.ObjectUtil;
import com.qianwen.core.tool.utils.ReflectUtil;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.core.tool.utils.StringUtil;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.lang.Nullable;

/* loaded from: blade-starter-cache-9.3.0.0-SNAPSHOT.jar:org/springblade/core/cache/utils/CacheUtil.class */
public class CacheUtil {
    private static CacheManager cacheManager;
    private static final Boolean TENANT_MODE = Boolean.TRUE;

    private static CacheManager getCacheManager() {
        if (cacheManager == null) {
            cacheManager = (CacheManager) SpringUtil.getBean(CacheManager.class);
        }
        return cacheManager;
    }

    public static Cache getCache(String cacheName) {
        return getCache(cacheName, TENANT_MODE);
    }

    public static Cache getCache(String cacheName, Boolean tenantMode) {
        return getCacheManager().getCache(formatCacheName(cacheName, tenantMode));
    }

    public static Cache getCache(String cacheName, String tenantId) {
        return getCacheManager().getCache(formatCacheName(cacheName, tenantId));
    }

    public static String formatCacheName(String cacheName, Boolean tenantMode) {
        if (!tenantMode.booleanValue()) {
            return cacheName;
        }
        return formatCacheName(cacheName, AuthUtil.getTenantId());
    }

    public static String formatCacheName(String cacheName, String tenantId) {
        return StringUtil.isBlank(tenantId) ? cacheName : tenantId.concat(":").concat(cacheName);
    }

    @Nullable
    public static Object get(String cacheName, String keyPrefix, Object key) {
        return get(cacheName, keyPrefix, key, TENANT_MODE);
    }

    @Nullable
    public static Object get(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
        if (Func.isEmpty(valueWrapper)) {
            return null;
        }
        return valueWrapper.get();
    }

    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type) {
        return (T) get(cacheName, keyPrefix, key, type, TENANT_MODE);
    }

    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, @Nullable Class<T> type, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        return (T) getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)), type);
    }

    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader) {
        return (T) get(cacheName, keyPrefix, key, valueLoader, TENANT_MODE);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Nullable
    public static <T> T get(String cacheName, String keyPrefix, Object key, Callable<T> valueLoader, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return null;
        }
        try {
            Cache.ValueWrapper valueWrapper = getCache(cacheName, tenantMode).get(keyPrefix.concat(String.valueOf(key)));
            //T t = null;
            Object value = null;
            if (valueWrapper == null) {
                T call = valueLoader.call();
                if (ObjectUtil.isNotEmpty(call)) {
                    Field field = ReflectUtil.getField(call.getClass(), "id");
                    if (ObjectUtil.isNotEmpty(field) && ObjectUtil.isEmpty(ClassUtil.getMethod(call.getClass(), "getId", new Class[0]).invoke(call, new Object[0]))) {
                        return null;
                    }
                    getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), call);
                    value = call;
                }
            } else {
            	
            	value = valueWrapper.get();
            }
            return (T)value;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value) {
        put(cacheName, keyPrefix, key, value, TENANT_MODE);
    }

    public static void put(String cacheName, String keyPrefix, Object key, @Nullable Object value, Boolean tenantMode) {
        getCache(cacheName, tenantMode).put(keyPrefix.concat(String.valueOf(key)), value);
    }

    public static void evict(String cacheName, String keyPrefix, Object key) {
        evict(cacheName, keyPrefix, key, TENANT_MODE);
    }

    public static void evict(String cacheName, String keyPrefix, Object key, Boolean tenantMode) {
        if (Func.hasEmpty(new Object[]{cacheName, keyPrefix, key})) {
            return;
        }
        getCache(cacheName, tenantMode).evict(keyPrefix.concat(String.valueOf(key)));
    }

    public static void clear(String cacheName) {
        clear(cacheName, TENANT_MODE);
    }

    public static void clear(String cacheName, Boolean tenantMode) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        getCache(cacheName, tenantMode).clear();
    }

    public static void clear(String cacheName, String tenantId) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        getCache(cacheName, tenantId).clear();
    }

    public static void clear(String cacheName, List<String> tenantIds) {
        if (Func.isEmpty(cacheName)) {
            return;
        }
        tenantIds.forEach(tenantId -> {
            getCache(cacheName, tenantId).clear();
        });
    }
}