// 引入 CryptoJS（ES6 模块化导入）
import CryptoJS from 'crypto-js'

// 密钥和 IV（16字节，必须与后端完全一致）
const KEY_STR = 'ygtxgxtkey030206' // 16字节
const IV_STR = 'ygtxgxt-iv030206'  // 16字节

/**
 * AES 加密
 * @param {string} plainText 明文
 * @returns {string} Base64 编码的密文
 */
export function encryptAES(plainText) {
  if (!plainText) return ''
  
  try {
    // 1. 将密钥和 IV 转换为 WordArray
    const key = CryptoJS.enc.Utf8.parse(KEY_STR)
    const iv = CryptoJS.enc.Utf8.parse(IV_STR)
    
    // 2. 加密配置：CBC 模式，PKCS7 填充
    const encrypted = CryptoJS.AES.encrypt(
      CryptoJS.enc.Utf8.parse(plainText), // 需要加密的数据
      key,                                 // 密钥
      {
        iv: iv,                            // 初始化向量
        mode: CryptoJS.mode.CBC,          // CBC 模式
        padding: CryptoJS.pad.Pkcs7       // PKCS7 填充
      }
    )
    
    // 3. 返回 Base64 字符串
    return encrypted.toString()
  } catch (e) {
    console.error('AES 加密失败:', e)
    return ''
  }
}

/**
 * AES 解密
 * @param {string} cipherText Base64 编码的密文
 * @returns {string} 解密后的明文
 */
export function decryptAES(cipherText) {
  if (!cipherText) return ''
  
  try {
    // 1. 将密钥和 IV 转换为 WordArray
    const key = CryptoJS.enc.Utf8.parse(KEY_STR)
    const iv = CryptoJS.enc.Utf8.parse(IV_STR)
    
    // 2. 解密
    const decrypted = CryptoJS.AES.decrypt(
      cipherText,                          // 需要解密的密文
      key,                                 // 密钥
      {
        iv: iv,                            // 初始化向量
        mode: CryptoJS.mode.CBC,          // CBC 模式
        padding: CryptoJS.pad.Pkcs7       // PKCS7 填充
      }
    )
    
    // 3. 转换为 UTF-8 字符串
    return decrypted.toString(CryptoJS.enc.Utf8)
  } catch (e) {
    console.error('AES 解密失败:', e)
    return ''
  }
}

/**
 * 加密对象为 JSON 字符串
 * @param {Object} obj 需要加密的对象
 * @returns {string} Base64 编码的密文
 */
export function encryptObject(obj) {
  if (!obj) return ''
  
  try {
    const jsonString = JSON.stringify(obj)
    return encryptAES(jsonString)
  } catch (e) {
    console.error('加密对象失败:', e)
    return ''
  }
}

/**
 * 解密密文为对象
 * @param {string} cipherText Base64 编码的密文
 * @returns {Object} 解密后的对象
 */
export function decryptToObject(cipherText) {
  if (!cipherText) return null
  
  try {
    const jsonString = decryptAES(cipherText)
    return JSON.parse(jsonString)
  } catch (e) {
    console.error('解密对象失败:', e)
    return null
  }
}

/**
 * 生成 URL 安全的 Base64
 * @param {string} base64 标准 Base64
 * @returns {string} URL 安全的 Base64
 */
export function toUrlSafeBase64(base64) {
  return base64
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}

/**
 * 还原 URL 安全的 Base64
 * @param {string} urlBase64 URL 安全的 Base64
 * @returns {string} 标准 Base64
 */
export function fromUrlSafeBase64(urlBase64) {
  let base64 = urlBase64
    .replace(/-/g, '+')
    .replace(/_/g, '/')
    
  // 补充等号
  const padding = base64.length % 4
  if (padding > 0) {
    base64 += '===='.substring(0, 4 - padding)
  }
  
  return base64
}

/**
 * 测试加解密功能
 */
export function testAES() {
  console.log('=== 测试 AES 加解密 ===')
  
  const testCases = [
    'Hello World',
    '123456',
    '测试中文',
    'a'.repeat(15),
    'a'.repeat(16),
    'a'.repeat(17)
  ]
  
  testCases.forEach((text, index) => {
    console.log(`\n测试 ${index + 1}: "${text}"`)
    
    try {
      // 加密
      const encrypted = encryptAES(text)
      console.log('加密结果:', encrypted)
      console.log('长度:', encrypted.length)
      
      // 解密
      const decrypted = decryptAES(encrypted)
      console.log('解密结果:', decrypted)
      console.log('是否匹配:', text === decrypted ? '✓ 通过' : '✗ 失败')
      
      if (text !== decrypted) {
        console.error('不匹配！原始:', text, '解密:', decrypted)
      }
    } catch (e) {
      console.error('测试失败:', e)
    }
  })
  
  console.log('\n=== 测试完成 ===')
}

// 导出默认对象
export default {
  encryptAES,
  decryptAES,
  encryptObject,
  decryptToObject,
  toUrlSafeBase64,
  fromUrlSafeBase64,
  testAES
}