import CryptoJS from 'crypto-js';
import { JSEncrypt } from 'jsencrypt';

/**
 * API 加解密工具类
 * 支持 AES 和 RSA 加密算法
 */

/**
 * AES 加密工具类
 */
export const AES = {
  /**
   * AES 加密
   * @param data 要加密的数据
   * @param key 加密密钥
   * @returns 加密后的字符串
   */
  encrypt(data: string, key: string): string {
    try {
      if (!key) {
        throw new Error('AES 加密密钥不能为空');
      }
      if (key.length !== 32 && key.length !== 16) {
        throw new Error(
          `AES 加密密钥长度必须为 32 位或 16 位，当前长度: ${key.length}`,
        );
      }

      const keyUtf8 = CryptoJS.enc.Utf8.parse(key);
      const encrypted = CryptoJS.AES.encrypt(data, keyUtf8, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      });
      return encrypted.toString();
    } catch (error) {
      console.error('AES 加密失败:', error);
      throw error;
    }
  },

  /**
   * AES 解密
   * @param encryptedData 加密的数据
   * @param key 解密密钥
   * @returns 解密后的字符串
   */
  decrypt(encryptedData: string, key: string): string {
    try {
      if (!key) {
        throw new Error('AES 解密密钥不能为空');
      }
      if (key.length !== 32) {
        throw new Error(
          `AES 解密密钥长度必须为 32 位，当前长度: ${key.length}`,
        );
      }
      if (!encryptedData) {
        throw new Error('AES 解密数据不能为空');
      }

      const keyUtf8 = CryptoJS.enc.Utf8.parse(key);
      const decrypted = CryptoJS.AES.decrypt(encryptedData, keyUtf8, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      });
      const result = decrypted.toString(CryptoJS.enc.Utf8);
      if (!result) {
        throw new Error('AES 解密结果为空，可能是密钥错误或数据损坏');
      }
      return result;
    } catch (error) {
      console.error('AES 解密失败:', error);
      throw error;
    }
  },
};

/**
 * RSA 加密工具类
 */
export const RSA = {
  /**
   * RSA 加密
   * @param data 要加密的数据
   * @param publicKey 公钥（必需）
   * @returns 加密后的字符串
   */
  encrypt(data: string, publicKey: string): false | string {
    try {
      if (!publicKey) {
        throw new Error('RSA 公钥不能为空');
      }

      const encryptor = new JSEncrypt();
      encryptor.setPublicKey(publicKey);
      const result = encryptor.encrypt(data);
      if (result === false) {
        throw new Error('RSA 加密失败，可能是公钥格式错误或数据过长');
      }
      return result;
    } catch (error) {
      console.error('RSA 加密失败:', error);
      throw error;
    }
  },

  /**
   * RSA 解密
   * @param encryptedData 加密的数据
   * @param privateKey 私钥（必需）
   * @returns 解密后的字符串
   */
  decrypt(encryptedData: string, privateKey: string): false | string {
    try {
      if (!privateKey) {
        throw new Error('RSA 私钥不能为空');
      }
      if (!encryptedData) {
        throw new Error('RSA 解密数据不能为空');
      }

      const encryptor = new JSEncrypt();
      encryptor.setPrivateKey(privateKey);
      const result = encryptor.decrypt(encryptedData);
      if (result === false) {
        throw new Error('RSA 解密失败，可能是私钥错误或数据损坏');
      }
      return result;
    } catch (error) {
      console.error('RSA 解密失败:', error);
      throw error;
    }
  },
};

/**
 * API 加解密配置接口
 */
export interface ApiEncryptConfig {
  /** 加密算法 */
  algorithm: 'AES' | 'RSA';
  /** 是否启用加解密 */
  enable: boolean;
  /** 加密头名称 */
  header: string;
  /** 请求加密密钥（AES密钥或RSA公钥） */
  requestKey: string;
  /** 响应解密密钥（AES密钥或RSA私钥） */
  responseKey: string;
}

/**
 * API 加解密主类
 */
export class ApiEncrypt {
  private config: ApiEncryptConfig;

  constructor(config: ApiEncryptConfig) {
    this.config = config;
  }

  /**
   * 解密响应数据
   * @param encryptedData 加密的响应数据
   * @returns 解密后的数据
   */
  decryptResponse(encryptedData: string): any {
    if (!this.config.enable) {
      return encryptedData;
    }

    try {
      let decryptedData: false | string = '';
      if (this.config.algorithm.toUpperCase() === 'AES') {
        if (!this.config.responseKey) {
          throw new Error('AES 响应解密密钥未配置');
        }
        decryptedData = AES.decrypt(encryptedData, this.config.responseKey);
      } else if (this.config.algorithm.toUpperCase() === 'RSA') {
        if (!this.config.responseKey) {
          throw new Error('RSA 私钥未配置');
        }
        decryptedData = RSA.decrypt(encryptedData, this.config.responseKey);
        if (decryptedData === false) {
          throw new Error('RSA 解密失败');
        }
      } else {
        throw new Error(`不支持的解密算法: ${this.config.algorithm}`);
      }

      if (!decryptedData) {
        throw new Error('解密结果为空');
      }

      // 尝试解析为 JSON，如果失败则返回原字符串
      try {
        return JSON.parse(decryptedData);
      } catch {
        return decryptedData;
      }
    } catch (error) {
      console.error('响应数据解密失败:', error);
      throw error;
    }
  }

  /**
   * 加密请求数据
   * @param data 要加密的数据
   * @returns 加密后的数据
   */
  encryptRequest(data: any): string {
    if (!this.config.enable) {
      return data;
    }

    try {
      const jsonData = typeof data === 'string' ? data : JSON.stringify(data);

      if (this.config.algorithm.toUpperCase() === 'AES') {
        if (!this.config.requestKey) {
          throw new Error('AES 请求加密密钥未配置');
        }
        return AES.encrypt(jsonData, this.config.requestKey);
      } else if (this.config.algorithm.toUpperCase() === 'RSA') {
        if (!this.config.requestKey) {
          throw new Error('RSA 公钥未配置');
        }
        const result = RSA.encrypt(jsonData, this.config.requestKey);
        if (result === false) {
          throw new Error('RSA 加密失败');
        }
        return result;
      } else {
        throw new Error(`不支持的加密算法: ${this.config.algorithm}`);
      }
    } catch (error) {
      console.error('请求数据加密失败:', error);
      throw error;
    }
  }

  /**
   * 获取加密头名称
   */
  getEncryptHeader(): string {
    return this.config.header;
  }
}

/**
 * 创建基于环境变量的 API 加解密实例
 * @param env 环境变量对象
 * @returns ApiEncrypt 实例
 */
export function createApiEncrypt(env: Record<string, any>): ApiEncrypt {
  const config: ApiEncryptConfig = {
    enable: env.VITE_APP_API_ENCRYPT_ENABLE === 'true',
    header: env.VITE_APP_API_ENCRYPT_HEADER || 'X-Api-Encrypt',
    algorithm: env.VITE_APP_API_ENCRYPT_ALGORITHM || 'AES',
    requestKey: env.VITE_APP_API_ENCRYPT_REQUEST_KEY || '',
    responseKey: env.VITE_APP_API_ENCRYPT_RESPONSE_KEY || '',
  };

  return new ApiEncrypt(config);
}