import keccaky
import gleam/io

pub fn main() {
  case keccaky.hash_keccak_256("hello world") {
    Ok(hash) -> {
      let hex = keccaky.to_hex_string(hash)
      io.println("Hash: " <> hex)
      // Outputs: Hash: 47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad
    }
    Error(error) -> {
      case error {
        keccaky.InvalidInput -> io.println("Input too large")
        keccaky.HashError -> io.println("Hashing failed")
        _ -> io.println("Unknown error")
      }
    }
  }
}

import keccaky
import gleam/bit_array

let data = <<0x48, 0x65, 0x6c, 0x6c, 0x6f>>  // "Hello" in bytes
case keccaky.hash_keccak_256_bytes(data) {
  Ok(hash) -> {
    let hex = keccaky.to_hex_string(hash)
    // Process the hash
  }
  Error(_) -> // Handle error
}

import keccaky

// From hex string (with or without 0x prefix)
case keccaky.from_hex_string("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") {
  Ok(hash) -> {
    // Work with the hash
    let bytes = keccaky.to_bytes(hash)
    let hex = keccaky.to_hex_string(hash)
  }
  Error(keccaky.InvalidHexString) -> // Handle invalid hex
}

let hash1 = keccaky.hash_keccak_256("test1")
let hash2 = keccaky.hash_keccak_256("test2")

case hash1, hash2 {
  Ok(h1), Ok(h2) -> {
    case keccaky.compare(h1, h2) {
      True -> io.println("Hashes are equal")
      False -> io.println("Hashes are different")
    }
  }
  _, _ -> // Handle errors
}

pub type Keccak256Hash {
  Keccak256Hash(BitArray)
}

pub type KeccakError {
  InvalidInput      // Input too large (>100MB)
  HashError         // Internal hashing error
  InvalidHexString  // Invalid hex format
  EncodingError     // Encoding/decoding error
}

// Hash a string
pub fn hash_keccak_256(input: String) -> Result(Keccak256Hash, KeccakError)

// Hash raw bytes
pub fn hash_keccak_256_bytes(input: BitArray) -> Result(Keccak256Hash, KeccakError)

// Convert hash to lowercase hex string
pub fn to_hex_string(hash: Keccak256Hash) -> String

// Parse hex string to hash (supports 0x prefix)
pub fn from_hex_string(hex: String) -> Result(Keccak256Hash, KeccakError)

// Get raw bytes from hash
pub fn to_bytes(hash: Keccak256Hash) -> BitArray

// Compare two hashes for equality
pub fn compare(hash1: Keccak256Hash, hash2: Keccak256Hash) -> Bool