import {
  isHex,
  isBase64,
  binToHex,
  base64ToBin,
  hexToBin,
  utf8ToBin,
  ripemd160,
  sha256,
} from '@bitauth/libauth';

/**
 * Represents a hash primitive that provides various cryptographic hashing capabilities.
 * This class handles conversions between different formats (bytes, hex, UTF-8) and
 * supports multiple hashing algorithms (SHA256, RIPEMD160, Hash160, Hash256).
 */
export class Hasher {
  /**
   * Creates a new Hash instance.
   * @param bytes - The byte array representation of the data to be hashed
   */
  constructor(public bytes: Uint8Array) {}

  /**
   * Creates a Hash instance from a byte array.
   * @param bytes - The byte array to create the hash from
   * @returns A new Hash instance containing the provided bytes
   */
  public static fromBytes(bytes: Uint8Array) {
    return new this(bytes);
  }

  /**
   * Creates a Hash instance from a Base64 string.
   * @param base64 - The Base64 string to create the hash from
   * @returns A new Hash instance containing the bytes converted from the Base64 string
   * @throws {Error} If the provided string is not valid Base64
   */
  public static fromBase64(base64: string) {
    // Ensure that the given string is base64.
    if (!isBase64(base64)) {
      throw new Error('The given string is not valid Base64.');
    }

    return new this(base64ToBin(base64));
  }

  /**
   * Creates a Hash instance from a hexadecimal string.
   * @param hex - The hexadecimal string to create the hash from
   * @returns A new Hash instance containing the bytes converted from the hex string
   * @throws {Error} If the provided string is not valid hexadecimal
   */
  public static fromHex(hex: string) {
    // Ensure that the given string is hex.
    if (!isHex(hex)) {
      throw new Error('The given string is not valid hexadecimal.');
    }

    return new this(hexToBin(hex));
  }

  /**
   * Creates a Hash instance from a UTF-8 string.
   * @param utf8 - The UTF-8 string to create the hash from
   * @returns A new Hash instance containing the bytes converted from the UTF-8 string
   */
  public static fromUTF8(utf8: string) {
    return new this(utf8ToBin(utf8));
  }

  /**
   * Computes the SHA256 hash of the stored bytes.
   * @returns A Uint8Array containing the SHA256 hash
   */
  public toSHA256Bytes(): Uint8Array {
    return sha256.hash(this.bytes);
  }

  /**
   * Computes the SHA256 hash of the stored bytes and returns it as a hexadecimal string.
   * @returns The SHA256 hash as a hexadecimal string
   */
  public toSHA256Hex(): string {
    return binToHex(this.toSHA256Bytes());
  }

  /**
   * Computes the RIPEMD160 hash of the stored bytes.
   * @returns A Uint8Array containing the RIPEMD160 hash
   */
  public toRIPEMD160Bytes(): Uint8Array {
    return ripemd160.hash(this.bytes);
  }

  /**
   * Computes the RIPEMD160 hash of the stored bytes and returns it as a hexadecimal string.
   * @returns The RIPEMD160 hash as a hexadecimal string
   */
  public toRIPEMD160Hex(): string {
    return binToHex(this.toRIPEMD160Bytes());
  }

  /**
   * Computes the Hash160 (RIPEMD160(SHA256(x))) of the stored bytes.
   * This is commonly used in cryptocurrency addresses.
   * @returns A Uint8Array containing the Hash160 value
   */
  public toHash160Bytes(): Uint8Array {
    return ripemd160.hash(this.toSHA256Bytes());
  }

  /**
   * Computes the Hash160 (RIPEMD160(SHA256(x))) of the stored bytes and returns it as a hexadecimal string.
   * @returns The Hash160 value as a hexadecimal string
   */
  public toHash160Hex(): string {
    return binToHex(this.toHash160Bytes());
  }

  /**
   * Computes the Hash256 (SHA256(SHA256(x))) of the stored bytes.
   * This is commonly used for computing block hashes in Bitcoin.
   * @returns A Uint8Array containing the Hash256 value
   */
  public toHash256Bytes(): Uint8Array {
    return sha256.hash(this.toSHA256Bytes());
  }

  /**
   * Computes the Hash256 (SHA256(SHA256(x))) of the stored bytes and returns it as a hexadecimal string.
   * @returns The Hash256 value as a hexadecimal string
   */
  public toHash256Hex(): string {
    return binToHex(sha256.hash(this.toSHA256Bytes()));
  }
}