import { decrypt as aesDecrypt, encrypt as aesEncrypt } from 'crypto-js/aes';
import UTF8, { parse } from 'crypto-js/enc-utf8';
import pkcs7 from 'crypto-js/pad-pkcs7';
import CTR from 'crypto-js/mode-ctr';
import Base64 from 'crypto-js/enc-base64';
import MD5 from 'crypto-js/md5';
import SHA256 from 'crypto-js/sha256';
import SHA512 from 'crypto-js/sha512';

// Define an interface for encryption
// 定义一个加密器的接口
export interface Encryption {
 encrypt(plainText: string): string;
 decrypt(cipherText: string): string;
}
// Define an interface for Hashing
// 定义一个哈希算法的接口
export interface Hashing {
 hash(data: string): string;
}

export interface EncryptionParams {
 key: string;
 iv: string;
}

class AesEncryption implements Encryption {
 private readonly key;
 private readonly iv;

 constructor({ key, iv }: EncryptionParams) {
 this.key = parse(key);
 this.iv = parse(iv);
 }

 get getOptions() {
 return {
 mode: CTR,
 padding: pkcs7,
 iv: this.iv,
 };
 }

 encrypt(plainText: string) {
 return aesEncrypt(plainText, this.key, this.getOptions).toString();
 }

 decrypt(cipherText: string) {
 return aesDecrypt(cipherText, this.key, this.getOptions).toString(UTF8);
 }
}

// Define a singleton class for Base64 encryption
class Base64Encryption implements Encryption {
 private static instance: Base64Encryption;

 private constructor() {}

 // Get the singleton instance
 // 获取单例实例
 public static getInstance(): Base64Encryption {
 if (!Base64Encryption.instance) {
 Base64Encryption.instance = new Base64Encryption();
 }
 return Base64Encryption.instance;
 }

 encrypt(plainText: string) {
 return UTF8.parse(plainText).toString(Base64);
 }

 decrypt(cipherText: string) {
 return Base64.parse(cipherText).toString(UTF8);
 }
}

// Define a singleton class for MD5 Hashing
class MD5Hashing implements Hashing {
 private static instance: MD5Hashing;

 private constructor() {}

 // Get the singleton instance
 // 获取单例实例
 public static getInstance(): MD5Hashing {
 if (!MD5Hashing.instance) {
 MD5Hashing.instance = new MD5Hashing();
 }
 return MD5Hashing.instance;
 }

 hash(plainText: string) {
 return MD5(plainText).toString();
 }
}

// Define a singleton class for SHA256 Hashing
class SHA256Hashing implements Hashing {
 private static instance: SHA256Hashing;

 private constructor() {}

 // Get the singleton instance
 // 获取单例实例
 public static getInstance(): SHA256Hashing {
 if (!SHA256Hashing.instance) {
 SHA256Hashing.instance = new SHA256Hashing();
 }
 return SHA256Hashing.instance;
 }

 hash(plainText: string) {
 return SHA256(plainText).toString();
 }
}

// Define a singleton class for SHA512 Hashing
class SHA512Hashing implements Hashing {
 private static instance: SHA512Hashing;

 private constructor() {}

 // Get the singleton instance
 // 获取单例实例
 public static getInstance(): SHA256Hashing {
 if (!SHA512Hashing.instance) {
 SHA512Hashing.instance = new SHA512Hashing();
 }
 return SHA512Hashing.instance;
 }

 hash(plainText: string) {
 return SHA512(plainText).toString();
 }
}

export class EncryptionFactory {
 public static createAesEncryption(params: EncryptionParams): Encryption {
 return new AesEncryption(params);
 }

 public static createBase64Encryption(): Encryption {
 return Base64Encryption.getInstance();
 }
}

export class HashingFactory {
 public static createMD5Hashing(): Hashing {
 return MD5Hashing.getInstance();
 }

 public static createSHA256Hashing(): Hashing {
 return SHA256Hashing.getInstance();
 }

 public static createSHA512Hashing(): Hashing {
 return SHA512Hashing.getInstance();
 }
}