package com.aiotagro.cattletrade.config;

import cn.dev33.satoken.stp.StpLogic;
import com.aiotagro.common.core.constant.RoleConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 自定义 StpLogic，支持通配符权限匹配
 */
@Slf4j
@Component
public class CustomStpLogic extends StpLogic {

    public CustomStpLogic() {
        super("login");
    }

    /**
     * 重写权限校验方法，支持通配符匹配
     * 
     * @param permission 需要校验的权限码
     * @return 是否拥有该权限
     */
    @Override
    public boolean hasPermission(String permission) {
        try {
            // 获取当前用户的权限列表
            List<String> permissionList = getPermissionList();
            
            // 如果权限列表为空，返回false
            if (permissionList == null || permissionList.isEmpty()) {
                log.debug("权限列表为空，permission={}", permission);
                return false;
            }
            
            // 检查是否有通配符权限 *:*:*
            if (permissionList.contains(RoleConstants.ALL_PERMISSION)) {
                log.debug("拥有通配符权限 *:*:*，直接放行，permission={}", permission);
                return true;
            }
            
            // 检查是否有精确匹配的权限
            if (permissionList.contains(permission)) {
                log.debug("精确匹配权限，permission={}", permission);
                return true;
            }
            
            // 支持通配符匹配，例如：system:* 可以匹配 system:user:list
            for (String userPermission : permissionList) {
                if (matchPermission(userPermission, permission)) {
                    log.debug("通配符匹配成功，userPermission={}, requirePermission={}", userPermission, permission);
                    return true;
                }
            }
            
            log.debug("权限校验失败，permission={}, userPermissions={}", permission, permissionList);
            return false;
            
        } catch (Exception e) {
            log.error("权限校验异常: {}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 通配符权限匹配
     * 
     * @param pattern 权限模式（可能包含*）
     * @param permission 需要匹配的权限
     * @return 是否匹配
     */
    private boolean matchPermission(String pattern, String permission) {
        // 如果完全相等
        if (pattern.equals(permission)) {
            return true;
        }
        
        // 如果是通配符 *:*:*
        if ("*:*:*".equals(pattern) || "*".equals(pattern)) {
            return true;
        }
        
        // 分割权限字符串
        String[] patternParts = pattern.split(":");
        String[] permissionParts = permission.split(":");
        
        // 如果模式部分数量大于权限部分，肯定不匹配
        if (patternParts.length > permissionParts.length) {
            return false;
        }
        
        // 逐级匹配
        for (int i = 0; i < patternParts.length; i++) {
            String patternPart = patternParts[i];
            String permissionPart = permissionParts[i];
            
            // 如果是*，匹配任意
            if ("*".equals(patternPart)) {
                return true; // 后续所有部分都匹配
            }
            
            // 如果不相等，不匹配
            if (!patternPart.equals(permissionPart)) {
                return false;
            }
        }
        
        // 如果模式部分全部匹配，且模式长度等于权限长度，则匹配
        return patternParts.length == permissionParts.length;
    }
}

