package com.ynxbd.common.helper.common;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.struts2.ServletActionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletRequest;
import java.util.Calendar;

/**
 * jwt工具类
 *
 * @Author skotori
 * @Date 2019-11-08 11:50
 */
public class JwtHelper {
    private static final Logger log = LoggerFactory.getLogger(JwtHelper.class);

    // token头名
    public static final String TOKEN_HEADER = "AuthToken";

    // 存储信息
    public static final String USER_ID = "user_id";
    public static final String USERNAME = "username";

    /**
     * 生成token
     *
     * @param sign     密钥
     * @param username 用户名
     * @return token
     */
    public static String createToken(String sign, String username, Long userId) {
        try {
            JWTCreator.Builder builder = JWT.create();
            builder.withClaim(USER_ID, userId);
            builder.withClaim(USERNAME, username);
            // 有效时间
            Calendar instance = Calendar.getInstance();
            instance.add(Calendar.HOUR, 6);
            builder.withExpiresAt(instance.getTime());

            return builder.sign(Algorithm.HMAC256(sign));
        } catch (Exception e) {
            log.error("生成token异常：[ {} ]", e.getMessage());
            return null;
        }
    }

    /**
     * 校验token
     *
     * @param token token
     * @param sign  签名
     * @return 是否合法
     */
    public static boolean verifyToken(String token, String username, String sign) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(sign);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim(USERNAME, username)
                    .build();
            verifier.verify(token);
            return true;
        } catch (Exception e) {
            log.error("校验token异常：[ {} ]", e.getMessage());
            return false;
        }
    }


    /**
     * 判断是否是超级管理员
     *
     * @return 是否为超管
     */
    public static boolean isSuperAdmin() {
        return getUserId() == 0;
    }


    /**
     * 获取用户名
     *
     * @return username
     */
    public static String getUsername(String... token) {
        if (token.length != 1) {
            return getTokenVal(null, USERNAME, String.class);
        } else {
            return getTokenVal(token[0], USERNAME, String.class);
        }
    }

    /**
     * 获取userId
     *
     * @return userId
     */
    public static Long getUserId() {
        return getTokenVal(USER_ID, Long.class);
    }

    /**
     * 从token中获取account
     *
     * @param key 键
     * @return value
     */
    public static <T> T getTokenVal(String key, Class<T> cls) {
        return getTokenVal(null, key, cls);
    }

    /**
     * 从token中获取account
     *
     * @param key 键
     * @return value
     */
    public static <T> T getTokenVal(String token, String key, Class<T> cls) {
        try {
            if (ObjectUtils.isEmpty(token)) {
                token = getReqToken(null);
                if (token == null) {
                    return null;
                }
            }

            DecodedJWT jwt = JWT.decode(token);
            T val = jwt.getClaim(key).as(cls);
            return ObjectUtils.isEmpty(val) ? null : val;
        } catch (Exception e) {
            log.error("从token中获取 {} 异常：[ {} ]", key, e.getMessage());
            return null;
        }
    }


    /**
     * 获取请求Header中的token
     *
     * @param servletRequest 请求
     * @return token
     */
    public static String getReqToken(ServletRequest servletRequest) {
        String token = ServletActionContext.getRequest().getHeader(TOKEN_HEADER);
        if (ObjectUtils.isEmpty(token)) {
            return null;
        }
        return token;
    }
}