package com.nb.auth.sa;

import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.annotation.*;
import cn.dev33.satoken.basic.SaBasicUtil;
import cn.dev33.satoken.dao.SaTokenDaoRedisJackson;
import cn.dev33.satoken.exception.NotPermissionException;
import cn.dev33.satoken.stp.StpLogic;
import cn.dev33.satoken.strategy.SaStrategy;
import cn.hutool.core.util.StrUtil;
import com.nb.auth.enums.StpTypeEnum;
import com.nb.auth.utils.SecurityUtil;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.regex.Pattern;

/**
 * @author lifang
 * @version 1.0.0
 * @ClassName SaConfig.java
 * @Description TODO
 * @createTime 2022年03月15日 16:51:00
 */
@Component
@AllArgsConstructor
public class SaConfig {
    private final SaTokenDaoRedisJackson saTokenDaoRedisJackson;
    private final DefaultSaTokenListener defaultSaTokenListener;
    @PostConstruct
    public void init(){
        SaStrategy.me.hasElement=(list,element)->{
            // 空集合直接返回false
            if(list == null || list.size() == 0) {
                return false;
            }
            // 先尝试一下简单匹配，如果可以匹配成功则无需继续模糊匹配
            if (list.contains(element)) {
                return true;
            }
            // 开始模糊匹配
            for (String patt : list) {
                if(vagueMatch(patt, element)) {
                    return true;
                }
            }
            // 走出for循环说明没有一个元素可以匹配成功
            return false;
        };
        SaStrategy.me.checkElementAnnotation=target->{
            // 校验 @SaCheckLogin 注解
            SaCheckLogin checkLogin = (SaCheckLogin) SaStrategy.me.getAnnotation.apply(target, SaCheckLogin.class);
            if(checkLogin != null) {
                SaManager.getStpLogic(checkLogin.type()).checkByAnnotation(checkLogin);
            }

            // 校验 @SaCheckRole 注解
            SaCheckRole checkRole = (SaCheckRole) SaStrategy.me.getAnnotation.apply(target, SaCheckRole.class);
            if(checkRole != null) {
                SaManager.getStpLogic(checkRole.type()).checkByAnnotation(checkRole);
            }

            // 校验 @SaCheckPermission 注解
            SaCheckPermission checkPermission = (SaCheckPermission) SaStrategy.me.getAnnotation.apply(target, SaCheckPermission.class);
            if(checkPermission != null) {
                String type= StrUtil.isBlankIfStr(checkPermission.type())?"login":checkPermission.type();
                StpLogic stpLogic = SecurityUtil.getStpLogic();
                if (!type.equals(stpLogic.getLoginType())) {
                    throw new NotPermissionException("无权限访问此体系接口");
                }
                SaManager.getStpLogic(checkPermission.type()).checkByAnnotation(checkPermission);
            }

            // 校验 @SaCheckSafe 注解
            SaCheckSafe checkSafe = (SaCheckSafe) SaStrategy.me.getAnnotation.apply(target, SaCheckSafe.class);
            if(checkSafe != null) {
                SaManager.getStpLogic(checkSafe.type()).checkByAnnotation(checkSafe);
            }

            // 校验 @SaCheckBasic 注解
            SaCheckBasic checkBasic = (SaCheckBasic) SaStrategy.me.getAnnotation.apply(target, SaCheckBasic.class);
            if(checkBasic != null) {
                SaBasicUtil.check(checkBasic.realm(), checkBasic.account());
            }
        };
//        SaManager.setSaTokenContext();
//        SaManager.setSaTokenAction(new SaTokenActionDefaultImpl());
        SaManager.setSaTokenDao(saTokenDaoRedisJackson);
//        SaManager.setSaTokenListener(defaultSaTokenListener);
        StpTypeEnum[] values = StpTypeEnum.values();
        for (StpTypeEnum value : values) {
            SaManager.putStpLogic(new StpLogic(value.getText()));
        }
    }

    /**
     * 字符串模糊匹配
     * <p>example:
     * <p> user-add user*    --  true
     * <p> art-add user*     --  false
     * @param patt 表达式
     * @param str 待匹配的字符串
     * @return 是否可以匹配
     */
    public static boolean vagueMatch(String patt, String str) {
        // 如果表达式不带有*号，则只需简单equals即可 (速度提升200倍)
        if(!str.contains("*")&&!patt.contains("*")) {
            return patt.equals(str);
        }
        return Pattern.matches(str.replaceAll("\\*", ".*"), patt)||Pattern.matches(patt.replaceAll("\\*", ".*"), str);
    }
}