package cn.iocoder.yudao.module.im.service.sensitiveword;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.cache.CacheUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.tenant.core.context.TenantContextHolder;
import cn.iocoder.yudao.framework.tenant.core.util.TenantUtils;
import cn.iocoder.yudao.module.im.controller.admin.manager.sensitiveword.vo.ImSensitiveWordPageReqVO;
import cn.iocoder.yudao.module.im.controller.admin.manager.sensitiveword.vo.ImSensitiveWordSaveReqVO;
import cn.iocoder.yudao.module.im.dal.dataobject.sensitiveword.ImSensitiveWordDO;
import cn.iocoder.yudao.module.im.dal.mysql.sensitiveword.ImSensitiveWordMapper;
import com.github.houbb.sensitive.word.bs.SensitiveWordBs;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import jakarta.annotation.Resource;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertList;
import static cn.iocoder.yudao.module.im.enums.ErrorCodeConstants.MESSAGE_SENSITIVE_WORD_BLOCKED;
import static cn.iocoder.yudao.module.im.enums.ErrorCodeConstants.SENSITIVE_WORD_DUPLICATED;
import static cn.iocoder.yudao.module.im.enums.ErrorCodeConstants.SENSITIVE_WORD_NOT_EXISTS;

/**
 * IM 敏感词 Service 实现类
 * <p>
 * 词库匹配交给 houbb sensitive-word 库（trie 树 + 全/半角 / 大小写 / 繁简体 / 数字风格规范化）
 *
 * @author 芋道源码
 */
@Service
@Validated
@Slf4j
public class ImSensitiveWordServiceImpl implements ImSensitiveWordService {

    @Resource
    private ImSensitiveWordMapper sensitiveWordMapper;

    /**
     * 缓存条目
     */
    @Data
    @AllArgsConstructor
    private static class SensitiveWordBsCache {

        /**
         * 敏感词检测器
         */
        private SensitiveWordBs bs;
        /**
         * 构建本实例时数据库里的 max(update_time)，作为下次刷新比对的基线
         */
        private LocalDateTime maxUpdateTime;

    }

    /**
     * 租户 → SensitiveWordBs 实例的本地缓存
     * <p>
     * 每分钟触发一次异步 reload，先读 max(update_time)，没变就复用旧实例（避免 trie 重建），变了才重新读词库 + 重建。
     * 单实例 CRUD 后另外通过 {@link #invalidateSensitiveWordBsCaches()} 立即让本机失效，多实例靠定时刷新最长 1 分钟内收敛。
     */
    @SuppressWarnings({"Convert2Diamond", "NullableProblems"})
    private final LoadingCache<Long, SensitiveWordBsCache> sensitiveWordBsCaches = CacheUtils.buildAsyncReloadingCache(
            Duration.ofMinutes(1L), // 1 分钟过期
            new CacheLoader<Long, SensitiveWordBsCache>() {

                @Override
                public SensitiveWordBsCache load(Long tenantId) {
                    return loadFresh(tenantId);
                }

                @Override
                public ListenableFuture<SensitiveWordBsCache> reload(Long tenantId, SensitiveWordBsCache oldValue) {
                    // 异步刷新线程独立于业务线程，没有租户上下文；必须显式 TenantUtils.execute 设置，否则租户拦截器会按当前线程的空上下文拼 SQL
                    return Futures.immediateFuture(TenantUtils.execute(tenantId, () -> {
                        LocalDateTime currentMax = sensitiveWordMapper.selectMaxUpdateTime(tenantId);
                        // 没变 → 复用旧实例，避免无谓地重建 trie
                        if (Objects.equals(oldValue.getMaxUpdateTime(), currentMax)) {
                            return oldValue;
                        }
                        // 变了 → 重新读词库并重建 trie
                        return loadFresh(tenantId);
                    }));
                }

            });

    private SensitiveWordBsCache loadFresh(Long tenantId) {
        return TenantUtils.execute(tenantId, () -> {
            // 先取基线时间再读词库：反过来在两次查询之间出现的新插入会被漏感知
            LocalDateTime maxUpdateTime = sensitiveWordMapper.selectMaxUpdateTime(tenantId);
            List<ImSensitiveWordDO> words = sensitiveWordMapper.selectListByStatus(CommonStatusEnum.ENABLE.getStatus());
            // 构建敏感词检测器
            SensitiveWordBs bs = SensitiveWordBs.newInstance()
                    .wordDeny(() -> convertList(words, ImSensitiveWordDO::getWord))
                    .ignoreCase(true)
                    .ignoreWidth(true)         // 忽略全/半角
                    .ignoreNumStyle(true)      // 忽略数字风格（中文/阿拉伯）
                    .ignoreChineseStyle(true)  // 忽略繁简体
                    .enableWordCheck(true)
                    .init();
            return new SensitiveWordBsCache(bs, maxUpdateTime);
        });
    }

    /**
     * 强制让敏感词缓存失效，下次访问按最新 DB 重建
     * <p>
     * 有租户上下文：仅失效该租户。无租户上下文（如系统级 / 跨租户清理）：兜底失效所有租户。
     */
    private void invalidateSensitiveWordBsCaches() {
        Long tenantId = TenantContextHolder.getTenantId();
        if (tenantId != null) {
            sensitiveWordBsCaches.invalidate(tenantId);
            return;
        }
        sensitiveWordBsCaches.invalidateAll();
    }

    @Override
    public void validateText(String text) {
        if (StrUtil.isBlank(text)) {
            return;
        }
        SensitiveWordBs bs = sensitiveWordBsCaches.getUnchecked(TenantContextHolder.getRequiredTenantId()).getBs();
        if (bs.contains(text)) {
            throw exception(MESSAGE_SENSITIVE_WORD_BLOCKED);
        }
    }

    // ==================== 管理后台 ====================

    @Override
    public PageResult<ImSensitiveWordDO> getSensitiveWordPage(ImSensitiveWordPageReqVO reqVO) {
        return sensitiveWordMapper.selectPage(reqVO);
    }

    @Override
    public ImSensitiveWordDO getSensitiveWord(Long id) {
        return sensitiveWordMapper.selectById(id);
    }

    @Override
    public Long createSensitiveWord(ImSensitiveWordSaveReqVO reqVO) {
        // 1. 校验唯一
        validateWordUnique(null, reqVO.getWord());

        // 2.1 入库
        ImSensitiveWordDO word = BeanUtils.toBean(reqVO, ImSensitiveWordDO.class);
        sensitiveWordMapper.insert(word);
        // 2.2 强制失效本机缓存（多实例靠定时刷新收敛）
        invalidateSensitiveWordBsCaches();
        return word.getId();
    }

    @Override
    public void updateSensitiveWord(ImSensitiveWordSaveReqVO reqVO) {
        // 1.1 校验存在
        validateSensitiveWordExists(reqVO.getId());
        // 1.2 校验唯一（排除自身）
        validateWordUnique(reqVO.getId(), reqVO.getWord());

        // 2.1 更新
        ImSensitiveWordDO updateObj = BeanUtils.toBean(reqVO, ImSensitiveWordDO.class);
        sensitiveWordMapper.updateById(updateObj);
        // 2.2 强制失效本机缓存
        invalidateSensitiveWordBsCaches();
    }

    @Override
    public void deleteSensitiveWord(Long id) {
        // 1. 校验存在
        validateSensitiveWordExists(id);

        // 2.1 删除
        sensitiveWordMapper.deleteById(id);
        // 2.2 强制失效本机缓存
        invalidateSensitiveWordBsCaches();
    }


    @Override
    public void deleteSensitiveWordList(List<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return;
        }
        // 1. 删除
        sensitiveWordMapper.deleteByIds(ids);
        // 2. 强制失效本机缓存
        invalidateSensitiveWordBsCaches();
    }

    private void validateSensitiveWordExists(Long id) {
        if (sensitiveWordMapper.selectById(id) == null) {
            throw exception(SENSITIVE_WORD_NOT_EXISTS);
        }
    }

    /**
     * 校验敏感词唯一（修改时排除自身）
     */
    private void validateWordUnique(Long id, String word) {
        ImSensitiveWordDO exist = sensitiveWordMapper.selectByWord(word);
        if (exist == null) {
            return;
        }
        if (id == null || ObjUtil.notEqual(exist.getId(), id)) {
            throw exception(SENSITIVE_WORD_DUPLICATED, word);
        }
    }

}