T = floor(currentTimestamp / step)

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import org.apache.commons.codec.binary.Base32;

public class OTPUtils {
    
    // HOTP默认密码长度
    private static final int DEFAULT_HOTP_LENGTH = 6;
    
    // TOTP默认时间步长（秒）
    private static final int TOTP_TIME_STEP = 30;
    
    // TOTP默认起始时间（Unix时间戳，毫秒）
    private static final long TOTP_T0 = 0;
    
    /**
     * 生成HOTP密码
     * 
     * @param key 共享密钥（Base32编码）
     * @param counter 计数器
     * @param digits 密码长度（6-8）
     * @return 生成的HOTP密码
     */
    public static String generateHOTP(String key, long counter, int digits) {
        // 解码Base32密钥
        byte[] keyBytes = new Base32().decode(key);
        
        // 将计数器转换为8字节数组（大端序）
        byte[] counterBytes = new byte[8];
        for (int i = 7; i >= 0; i--) {
            counterBytes[i] = (byte) (counter & 0xFF);
            counter >>= 8;
        }
        
        try {
            // 计算HMAC-SHA-1
            Mac mac = Mac.getInstance("HmacSHA1");
            mac.init(new SecretKeySpec(keyBytes, "HmacSHA1"));
            byte[] hmacResult = mac.doFinal(counterBytes);
            
            // 截断处理（动态截断函数）
            int offset = hmacResult[hmacResult.length - 1] & 0x0F;
            int binary = ((hmacResult[offset] & 0x7F) << 24) |
                         ((hmacResult[offset + 1] & 0xFF) << 16) |
                         ((hmacResult[offset + 2] & 0xFF) << 8) |
                         (hmacResult[offset + 3] & 0xFF);
            
            // 生成指定长度的数字
            int otp = binary % (int) Math.pow(10, digits);
            
            // 补前导零
            return String.format("%0" + digits + "d", otp);
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            throw new RuntimeException("生成HOTP失败", e);
        }
    }
    
    /**
     * 生成默认长度（6位）的HOTP密码
     */
    public static String generateHOTP(String key, long counter) {
        return generateHOTP(key, counter, DEFAULT_HOTP_LENGTH);
    }
    
    /**
     * 生成TOTP密码
     * 
     * @param key 共享密钥（Base32编码）
     * @param digits 密码长度（6-8）
     * @return 生成的TOTP密码
     */
    public static String generateTOTP(String key, int digits) {
        // 计算当前计数器值：C = floor((T - T0) / 时间步长)
        long currentTime = System.currentTimeMillis() / 1000;
        long counter = (currentTime - TOTP_T0) / TOTP_TIME_STEP;
        
        // 调用HOTP生成密码
        return generateHOTP(key, counter, digits);
    }
    
    /**
     * 生成默认长度（6位）的TOTP密码
     */
    public static String generateTOTP(String key) {
        return generateTOTP(key, DEFAULT_HOTP_LENGTH);
    }
    
    /**
     * 验证HOTP密码
     */
    public static boolean verifyHOTP(String key, long counter, String code, int digits) {
        String generatedCode = generateHOTP(key, counter, digits);
        return generatedCode.equals(code);
    }
    
    /**
     * 验证TOTP密码（考虑时间容错，默认允许前后各一个时间窗口）
     */
    public static boolean verifyTOTP(String key, String code, int digits, int window) {
        long currentTime = System.currentTimeMillis() / 1000;
        long currentCounter = (currentTime - TOTP_T0) / TOTP_TIME_STEP;
        
        // 检查当前窗口及前后window个窗口
        for (int i = -window; i <= window; i++) {
            long counter = currentCounter + i;
            if (generateHOTP(key, counter, digits).equals(code)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 生成随机的Base32编码密钥
     */
    public static String generateRandomKey() {
        // 生成160位（20字节）的随机密钥，符合HOTP推荐长度
        byte[] key = new byte[20];
        new java.security.SecureRandom().nextBytes(key);
        return new Base32().encodeToString(key).replaceAll("=", ""); // 移除填充
    }
}