package com.estate.expert.admin.utils;

import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.common.exception.BizException;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Base64;
import java.util.logging.Logger;

/**
 * License验证工具类
 * 用于系统license的加密、解密和验证
 * 当license过期时，系统将停止运行
 */
public class License {
    
    private static final Logger logger = Logger.getLogger(License.class.getName());
    
    // 加密密钥（实际使用时应该从配置文件或环境变量中读取）
    // AES密钥必须是16、24或32字节长度
    private static final String SECRET_KEY = "EstateExpert2024Key32BytesForAES";
    
    // License密钥（从配置文件读取）
    private static String LICENSE_KEY;
    
    // 加密算法
    private static final String ALGORITHM = "AES";
    
    // 日期格式
    private static final String DATE_FORMAT = "yyyy-MM-dd";
    
    // 系统启动时间
    private static LocalDate systemStartDate;
    
    // License过期日期
    private static LocalDate licenseExpiryDate;
    
    // License是否有效
    private static boolean isLicenseValid = false;
    
    // 静态初始化块，验证密钥
    static {
        if (!validateKey()) {
            logger.severe("License系统初始化失败：密钥长度不正确");
        }
    }
    
    /**
     * 设置License密钥（从配置文件读取）
     * @param licenseKey License密钥
     */
    public static void setLicenseKey(String licenseKey) {
        LICENSE_KEY = licenseKey;
//        logger.info("License密钥已设置");
    }
    
    /**
     * 初始化License验证（使用配置文件中的密钥）
     * @throws BizException 当License验证失败时抛出
     */
    public static void initializeLicenseFromConfig() {
        if (LICENSE_KEY == null || LICENSE_KEY.trim().isEmpty()) {
            logger.severe("License密钥未设置，系统无法启动");
            throw new BizException(BizResultCode.LICENSE_NOT_CONFIGURED);
        }
        
        if (!initializeLicense(LICENSE_KEY)) {
            throw new BizException(BizResultCode.LICENSE_VALIDATION_FAILED);
        }
    }
    
    /**
     * 验证密钥长度
     * @return 密钥是否有效
     */
    private static boolean validateKey() {
        byte[] keyBytes = SECRET_KEY.getBytes(StandardCharsets.UTF_8);
        if (keyBytes.length != 32) {
            logger.severe("密钥长度不正确，需要32字节，当前: " + keyBytes.length + " 字节");
            return false;
        }
        return true;
    }
    
    /**
     * 初始化License验证
     * @param encryptedLicense 加密的license字符串
     * @return 是否初始化成功
     */
    public static boolean initializeLicense(String encryptedLicense) {
        try {
            if (encryptedLicense == null || encryptedLicense.trim().isEmpty()) {
                logger.severe("License字符串为空，系统无法启动");
                BizResultCode.LICENSE_NOT_CONFIGURED.check(true);
                return false;
            }
            
            // 解密license
            String decryptedLicense = decrypt(encryptedLicense);
            if (decryptedLicense == null) {
                logger.severe("License解密失败，系统无法启动");
                BizResultCode.LICENSE_VALIDATION_FAILED.check(true);
                return false;
            }
            
            // 解析license信息
            String[] licenseParts = decryptedLicense.split("\\|");
            if (licenseParts.length != 3) {
                logger.severe("License格式错误，系统无法启动");
                BizResultCode.LICENSE_INVALID_FORMAT.check(true);
                return false;
            }
            
            // 验证license签名
            String licenseData = licenseParts[0] + "|" + licenseParts[1];
            String signature = licenseParts[2];
            if (!verifySignature(licenseData, signature)) {
                logger.severe("License签名验证失败，系统无法启动");
                BizResultCode.LICENSE_SIGNATURE_INVALID.check(true);
                return false;
            }
            
            // 解析过期日期
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DATE_FORMAT);
            licenseExpiryDate = LocalDate.parse(licenseParts[1], formatter);
            systemStartDate = LocalDate.now();
            
            // 检查license是否过期
            if (isLicenseExpired()) {
                logger.severe("License已过期，系统无法启动");
                BizResultCode.LICENSE_EXPIRED.check(true);
                return false;
            }
            
            isLicenseValid = true;
            logger.info("启动验证，系统启动时间: " + systemStartDate +
                       ", 过期时间: " + licenseExpiryDate);
            return true;
        } catch (BizException e) {
            // 重新抛出BizException
            throw e;
        } catch (Exception e) {
            logger.severe("License初始化失败: " + e.getMessage());
            BizResultCode.LICENSE_VALIDATION_FAILED.check(true);
            return false;
        }
    }
    
    /**
     * 检查License是否有效
     * @return 是否有效
     */
    public static boolean isLicenseValid() {
        if (!isLicenseValid) {
            return false;
        }
        
        // 检查是否过期
        if (isLicenseExpired()) {
            logger.severe("License已过期，系统将停止运行");
            isLicenseValid = false;
            return false;
        }
        
        return true;
    }
    
    /**
     * 验证License有效性，如果无效则抛出异常
     * @throws BizException 当License无效时抛出
     */
    public static void validateLicense() {
        if (!isLicenseValid()) {
            throw new BizException(BizResultCode.LICENSE_EXPIRED);
        }
    }
    
    /**
     * 检查License是否过期
     * @return 是否过期
     */
    public static boolean isLicenseExpired() {
        if (licenseExpiryDate == null) {
            return true;
        }
        
        LocalDate currentDate = LocalDate.now();
        return currentDate.isAfter(licenseExpiryDate);
    }
    
    /**
     * 获取剩余天数
     * @return 剩余天数，-1表示已过期
     */
    public static long getRemainingDays() {
        if (licenseExpiryDate == null) {
            return -1;
        }
        
        LocalDate currentDate = LocalDate.now();
        if (currentDate.isAfter(licenseExpiryDate)) {
            return -1;
        }
        
        return java.time.temporal.ChronoUnit.DAYS.between(currentDate, licenseExpiryDate);
    }
    
    /**
     * 生成License
     * @param expiryDate 过期日期
     * @return 加密的license字符串
     */
    public static String generateLicense(LocalDate expiryDate) {
        try {
            String licenseData = "EstateExpert|" + expiryDate.format(DateTimeFormatter.ofPattern(DATE_FORMAT));
            String signature = generateSignature(licenseData);
            String fullLicense = licenseData + "|" + signature;
            
            return encrypt(fullLicense);
        } catch (Exception e) {
            logger.severe("生成License失败: " + e.getMessage());
            return null;
        }
    }
    
    /**
     * 加密字符串
     * @param plainText 明文
     * @return 加密后的字符串
     */
    private static String encrypt(String plainText) {
        try {
            if (!validateKey()) {
                return null;
            }
            
            SecretKeySpec secretKey = new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            
            byte[] encryptedBytes = cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            logger.severe("加密失败: " + e.getMessage());
            return null;
        }
    }
    
    /**
     * 解密字符串
     * @param encryptedText 加密的字符串
     * @return 解密后的字符串
     */
    private static String decrypt(String encryptedText) {
        try {
            if (!validateKey()) {
                return null;
            }
            
            SecretKeySpec secretKey = new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            
            byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedText));
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            logger.severe("解密失败: " + e.getMessage());
            return null;
        }
    }
    
    /**
     * 生成签名
     * @param data 数据
     * @return 签名
     */
    private static String generateSignature(String data) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest((data + SECRET_KEY).getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(hash);
        } catch (Exception e) {
            logger.severe("生成签名失败: " + e.getMessage());
            return null;
        }
    }
    
    /**
     * 验证签名
     * @param data 数据
     * @param signature 签名
     * @return 是否验证通过
     */
    private static boolean verifySignature(String data, String signature) {
        try {
            String expectedSignature = generateSignature(data);
            return expectedSignature != null && expectedSignature.equals(signature);
        } catch (Exception e) {
            logger.severe("验证签名失败: " + e.getMessage());
            return false;
        }
    }
    
    /**
     * 强制停止系统
     */
    public static void forceSystemShutdown() {
        logger.severe("License验证失败，系统强制停止运行");
        System.exit(1);
    }
    
    /**
     * 获取License信息
     * @return License信息字符串
     */
    public static String getLicenseInfo() {
        if (!isLicenseValid) {
            return "License无效";
        }
        
        StringBuilder info = new StringBuilder();
        info.append("系统启动时间: ").append(systemStartDate).append("\n");
        info.append("License过期时间: ").append(licenseExpiryDate).append("\n");
        info.append("剩余天数: ").append(getRemainingDays()).append("\n");
        info.append("License状态: ").append(isLicenseExpired() ? "已过期" : "有效");
        
        return info.toString();
    }
    
    /**
     * 测试方法 - 生成测试License
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        try {
            System.out.println("=== License验证系统测试 ===");
            
            // 生成一个30天后过期的License
//            LocalDate expiryDate = LocalDate.now().plusDays(-10);
            LocalDate expiryDate = LocalDate.now().plusDays(199999);
            String license = generateLicense(expiryDate);
            
            if (license == null) {
                System.err.println("生成License失败");
                return;
            }
            
            System.out.println("生成的License: " + license);
            System.out.println("过期日期: " + expiryDate);
            System.out.println();
            
            // 测试License验证
            System.out.println("开始验证License...");
            boolean isValid = initializeLicense(license);
            System.out.println("License验证结果: " + isValid);
            
            if (isValid) {
                System.out.println("License信息:");
                System.out.println(getLicenseInfo());
                
                // 测试License有效性检查
                System.out.println("\n当前License是否有效: " + isLicenseValid());
                System.out.println("剩余天数: " + getRemainingDays());
            } else {
                System.err.println("License验证失败，系统无法启动");
            }
            
        } catch (Exception e) {
            System.err.println("测试过程中发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}