package com.qianwen.smartman.modules.resource.builder.oss;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.oss.OssTemplate;
import com.qianwen.core.oss.enums.OssEnum;
import com.qianwen.core.oss.enums.OssStatusEnum;
import com.qianwen.core.oss.props.OssProperties;
import com.qianwen.core.oss.rule.BladeOssRule;
import com.qianwen.core.oss.rule.OssRule;
import com.qianwen.core.redis.cache.BladeRedis;
import com.qianwen.core.tenant.mp.TenantEntity;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.core.tool.utils.StringUtil;
import com.qianwen.core.tool.utils.WebUtil;
import com.qianwen.smartman.common.constant.ExtCacheConstant;
import com.qianwen.smartman.modules.resource.entity.Oss;
import com.qianwen.smartman.modules.resource.enums.BucketEnum;
import com.qianwen.smartman.modules.resource.service.IOssService;

/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/resource/builder/oss/OssBuilder.class */
public class OssBuilder {
    public static final String OSS_CODE = "oss:code:";
    public static final String OSS_PARAM_KEY = "code";
    public static final String OSS_RULE = "oss:rule:";
    private static BladeRedis bladeRedis;
    private final OssProperties ossProperties;
    private final IOssService ossService;
    private final Map<String, OssTemplate> templatePool = new ConcurrentHashMap();
    private final Map<String, Oss> ossPool = new ConcurrentHashMap<>();

    public OssBuilder(OssProperties ossProperties, IOssService ossService) {
        this.ossProperties = ossProperties;
        this.ossService = ossService;
    }

    private static BladeRedis getBladeRedis() {
        if (bladeRedis == null) {
            bladeRedis = (BladeRedis) SpringUtil.getBean(BladeRedis.class);
        }
        return bladeRedis;
    }

    public OssTemplate template() {
        return template("");
    }

    public OssTemplate template(String code) {
        OssTemplate template;
        OssRule ossRule;
        Oss oss = getOss("000000", code);
        Oss ossCached = this.ossPool.get("000000");
        OssTemplate template2 = this.templatePool.get("000000");
        if (!Func.hasEmpty(new Object[]{template2, ossCached}) && oss.getEndpoint().equals(ossCached.getEndpoint()) && oss.getAccessKey().equals(ossCached.getAccessKey())) {
            return template2;
        }
        synchronized (OssBuilder.class) {
            template = this.templatePool.get("000000");
            if (Func.hasEmpty(new Object[]{template, ossCached}) || !oss.getEndpoint().equals(ossCached.getEndpoint()) || !oss.getAccessKey().equals(ossCached.getAccessKey())) {
                if (oss.getEndpoint().equals(this.ossProperties.getEndpoint()) && oss.getAccessKey().equals(this.ossProperties.getAccessKey()) && this.ossProperties.getTenantMode().booleanValue()) {
                    ossRule = new BladeOssRule(Boolean.TRUE);
                } else {
                    ossRule = new BladeOssRule(Boolean.FALSE);
                }
                template = getOssTemplate(oss, template, ossRule);
                this.templatePool.put("000000", template);
                this.ossPool.put("000000", oss);
            }
        }
        return template;
    }

    public OssTemplate systemTemplate() {
        return getTemplate(BucketEnum.SYSTEM);
    }

    public OssTemplate tempTemplate() {
        return getTemplate(BucketEnum.TEMP);
    }

    public OssTemplate visualTemplate() {
        OssTemplate template = getTemplate(BucketEnum.VISUAL);
        if (!template.bucketExists(BucketEnum.VISUAL.getName())) {
            template.makeBucket(BucketEnum.VISUAL.getName());
        }
        return template;
    }

    public OssTemplate getTemplate(BucketEnum bucketEnum) {
        OssTemplate template;
        Oss oss = getOss("000000", "");
        oss.setBucketName(bucketEnum.getName());
        Oss ossCached = this.ossPool.get("000000");
        OssTemplate template2 = this.templatePool.get("000000" + bucketEnum.getName());
        if (!Func.hasEmpty(new Object[]{template2, ossCached}) && oss.getEndpoint().equals(ossCached.getEndpoint()) && oss.getAccessKey().equals(ossCached.getAccessKey())) {
            return template2;
        }
        synchronized (OssBuilder.class) {
            template = this.templatePool.get("000000" + bucketEnum.getName());
            if (Func.hasEmpty(new Object[]{template, ossCached}) || !oss.getEndpoint().equals(ossCached.getEndpoint()) || !oss.getAccessKey().equals(ossCached.getAccessKey())) {
                OssRule ossRule = getOssRule(bucketEnum);
                template = getOssTemplate(oss, template, ossRule);
                this.templatePool.put("000000" + bucketEnum.getName(), template);
                this.ossPool.put("000000", oss);
            }
        }
        return template;
    }

    private OssRule getOssRule(BucketEnum bucketEnum) {
        OssRule ossRule = null;
        if (bucketEnum.getName() == BucketEnum.SYSTEM.getName()) {
            ossRule = new SystemOssRule();
        } else if (bucketEnum.getName() == BucketEnum.TEMP.getName()) {
            ossRule = new TempOssRule();
        } else if (bucketEnum.getName() == BucketEnum.VISUAL.getName()) {
            ossRule = new VisualOssRule();
        }
        return ossRule;
    }

    public OssTemplate getOssTemplate(Oss oss, OssTemplate template, OssRule ossRule) {
        if (oss.getCategory().intValue() == OssEnum.MINIO.getCategory()) {
            template = MinioOssBuilder.template(oss, ossRule);
        } else if (oss.getCategory().intValue() == OssEnum.QINIU.getCategory()) {
            template = QiniuOssBuilder.template(oss, ossRule);
        } else if (oss.getCategory().intValue() == OssEnum.ALI.getCategory()) {
            template = AliOssBuilder.template(oss, ossRule);
        } else if (oss.getCategory().intValue() == OssEnum.TENCENT.getCategory()) {
            template = TencentOssBuilder.template(oss, ossRule);
        }
        return template;
    }

    public Oss getOss(String tenantId, String code) {
        String key = Func.isBlank(tenantId) ? "000000" : tenantId;
        LambdaQueryWrapper<Oss> lqw = Wrappers.<Oss>query().lambda().eq(Oss::getTenantId, tenantId);
        /*
        Wrapper wrapper = (LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getTenantId();
        }, tenantId);*/
        String ossCode = StringUtil.isBlank(code) ? WebUtil.getParameter("code") : code;
        if (StringUtil.isNotBlank(ossCode)) {
            key = key.concat("-").concat(ossCode);
            
            lqw.eq(Oss::getOssCode, ossCode);
            /*
            wrapper.eq((v0) -> {
                return v0.getOssCode();
            }, ossCode);*/
        } else {
        	lqw.eq(Oss::getStatus, Integer.valueOf(OssStatusEnum.ENABLE.getNum()));
        	/*
            wrapper.eq((v0) -> {
                return v0.getStatus();
            }, Integer.valueOf(OssStatusEnum.ENABLE.getNum()));*/
        }
        Oss oss = (Oss) CacheUtil.get("blade:resource", OSS_CODE, key, ExtCacheConstant.TENANT_MODE);
        if (Func.isEmpty(oss)) {
            oss = this.ossService.getOne(lqw);
            String redisKey = "blade:resource".concat("::").concat(OSS_CODE).concat(tenantId);
            getBladeRedis().setEx(redisKey, oss, ExtCacheConstant.FIVE_MINUTES_EXPIRE_TIME);
        }
        if (oss == null || oss.getId() == null) {
            throw new ServiceException("未获取到对应的对象存储配置");
        }
        return oss;
    }
}