(function (EXPORTS) {
  "use strict";
  const suiCrypto = EXPORTS;

  // Generate a new random key
  function generateNewID() {
    var key = new Bitcoin.ECKey(false);
    key.setCompressed(true);
    return {
      floID: key.getBitcoinAddress(),
      pubKey: key.getPubKeyHex(),
      privKey: key.getBitcoinWalletImportFormat(),
    };
  }

  Object.defineProperties(suiCrypto, {
    newID: {
      get: () => generateNewID(),
    },
    hashID: {
      value: (str) => {
        let bytes = ripemd160(Crypto.SHA256(str, { asBytes: true }), {
          asBytes: true,
        });
        bytes.unshift(bitjs.pub);
        var hash = Crypto.SHA256(Crypto.SHA256(bytes, { asBytes: true }), {
          asBytes: true,
        });
        var checksum = hash.slice(0, 4);
        return bitjs.Base58.encode(bytes.concat(checksum));
      },
    },
    tmpID: {
      get: () => {
        let bytes = Crypto.util.randomBytes(20);
        bytes.unshift(bitjs.pub);
        var hash = Crypto.SHA256(Crypto.SHA256(bytes, { asBytes: true }), {
          asBytes: true,
        });
        var checksum = hash.slice(0, 4);
        return bitjs.Base58.encode(bytes.concat(checksum));
      },
    },
  });

  // --- Multi-chain Generator (BTC, FLO, SUI) ---
  suiCrypto.generateMultiChain = async function (inputWif) {
    const versions = {
      BTC: { pub: 0x00, priv: 0x80 },
      FLO: { pub: 0x23, priv: 0xa3 },
    };

    const origBitjsPub = bitjs.pub;
    const origBitjsPriv = bitjs.priv;
    const origBitjsCompressed = bitjs.compressed;
    const origCoinJsCompressed = coinjs.compressed;

    bitjs.compressed = true;
    coinjs.compressed = true;

    let privKeyHex;
    let compressed = true;

    // --- Decode input or generate new ---
    if (typeof inputWif === "string" && inputWif.trim().length > 0) {
      const trimmedInput = inputWif.trim();
      const hexOnly = /^[0-9a-fA-F]+$/.test(trimmedInput);

      if (trimmedInput.startsWith('suiprivkey1')) {
        try {
          const decoded = coinjs.bech32_decode(trimmedInput);
          if (!decoded) throw new Error('Invalid SUI private key checksum');
          const bytes = coinjs.bech32_convert(decoded.data, 5, 8, false);
          // First byte is the scheme flag (should be 0x00 for Ed25519), the rest is the 32-byte private key.
          if (bytes[0] !== 0) throw new Error('Unsupported SUI private key scheme');
          const privateKeyBytes = bytes.slice(1);
          privKeyHex = Crypto.util.bytesToHex(privateKeyBytes);
        } catch (e) {
          console.warn("Invalid SUI private key, generating new key:", e);
          const newKey = generateNewID();
          const decode = Bitcoin.Base58.decode(newKey.privKey);
          const keyWithVersion = decode.slice(0, decode.length - 4);
          let key = keyWithVersion.slice(1);
          if (key.length >= 33 && key[key.length - 1] === 0x01)
            key = key.slice(0, key.length - 1);
          privKeyHex = Crypto.util.bytesToHex(key);
        }
      } else if (hexOnly && (trimmedInput.length === 64 || trimmedInput.length === 128)) {
        privKeyHex =
          trimmedInput.length === 128 ? trimmedInput.substring(0, 64) : trimmedInput;
      } else {
        try {
          const decode = Bitcoin.Base58.decode(trimmedInput);
          const keyWithVersion = decode.slice(0, decode.length - 4);
          let key = keyWithVersion.slice(1);
          if (key.length >= 33 && key[key.length - 1] === 0x01) {
            key = key.slice(0, key.length - 1);
            compressed = true;
          }
          privKeyHex = Crypto.util.bytesToHex(key);
        } catch (e) {
          console.warn("Invalid WIF, generating new key:", e);
          const newKey = generateNewID();
          const decode = Bitcoin.Base58.decode(newKey.privKey);
          const keyWithVersion = decode.slice(0, decode.length - 4);
          let key = keyWithVersion.slice(1);
          if (key.length >= 33 && key[key.length - 1] === 0x01)
            key = key.slice(0, key.length - 1);
          privKeyHex = Crypto.util.bytesToHex(key);
        }
      }
    } else {
      // Generate new key if no input
      const newKey = generateNewID();
      const decode = Bitcoin.Base58.decode(newKey.privKey);
      const keyWithVersion = decode.slice(0, decode.length - 4);
      let key = keyWithVersion.slice(1);
      if (key.length >= 33 && key[key.length - 1] === 0x01)
        key = key.slice(0, key.length - 1);
      privKeyHex = Crypto.util.bytesToHex(key);
    }

    // --- Derive addresses for each chain ---
    const result = { BTC: {}, FLO: {}, SUI: {} };

    // BTC
    bitjs.pub = versions.BTC.pub;
    bitjs.priv = versions.BTC.priv;
    const pubKeyBTC = bitjs.newPubkey(privKeyHex);
    result.BTC.address = coinjs.bech32Address(pubKeyBTC).address;
    result.BTC.privateKey = bitjs.privkey2wif(privKeyHex);

    // FLO
    bitjs.pub = versions.FLO.pub;
    bitjs.priv = versions.FLO.priv;
    const pubKeyFLO = bitjs.newPubkey(privKeyHex);
    result.FLO.address = bitjs.pubkey2address(pubKeyFLO);
    result.FLO.privateKey = bitjs.privkey2wif(privKeyHex);

    // SUI

    try {
      const privBytes = Crypto.util.hexToBytes(privKeyHex.substring(0, 64));
      const seed = new Uint8Array(privBytes.slice(0, 32));

      // Generate Ed25519 keypair from seed
      const keyPair = nacl.sign.keyPair.fromSeed(seed);
      const pubKey = keyPair.publicKey;

      const prefixedPubKey = new Uint8Array([0x00, ...pubKey]);

      // Hash with BLAKE2b-256
      const hash = blakejs.blake2b(prefixedPubKey, null, 32);

      // Convert to hex address
      const suiAddress = "0x" + Crypto.util.bytesToHex(hash);

      // Encode the private key in Sui's Bech32 format
      const privateKeyBytes = new Uint8Array([0x00, ...seed]);
      const words = coinjs.bech32_convert(Array.from(privateKeyBytes), 8, 5, true);
      const suiPrivateKey = coinjs.bech32_encode('suiprivkey', words);

      result.SUI.address = suiAddress;
      result.SUI.privateKey = suiPrivateKey; 
    } catch (error) {
      console.error("Error generating SUI address:", error);
      result.SUI.address = "Error generating address";
      result.SUI.privateKey = privKeyHex;
    }

    bitjs.pub = origBitjsPub;
    bitjs.priv = origBitjsPriv;
    bitjs.compressed = origBitjsCompressed;
    coinjs.compressed = origCoinJsCompressed;

    return result;
  };

  // Sign Transaction 
  suiCrypto.sign = async function (txBytes, suiPrivateKey) {
    // Decode the private key from Bech32
    const decoded = coinjs.bech32_decode(suiPrivateKey);
    if (!decoded) throw new Error("Invalid SUI private key format.");
    const keyBytes = coinjs.bech32_convert(decoded.data, 5, 8, false);
    
    // The first byte is the scheme flag (0x00 for Ed25519), the rest is the seed.
    if (keyBytes[0] !== 0x00) {
      throw new Error("Unsupported SUI private key scheme.");
    }
    const seed = new Uint8Array(keyBytes.slice(1));

    // Re-derive the keypair from the seed
    const keypair = nacl.sign.keyPair.fromSeed(seed);

    // Decode the transaction bytes from base64
    const txData = new Uint8Array(atob(txBytes).split('').map(c => c.charCodeAt(0)));

    // Create the message to sign
    const INTENT_BYTES = [0, 0, 0];
    const messageToSign = new Uint8Array(INTENT_BYTES.length + txData.length);
    messageToSign.set(INTENT_BYTES);
    messageToSign.set(txData, INTENT_BYTES.length);

    // Sign the message digest
    const digest = blakejs.blake2b(messageToSign, null, 32);
    const signature = nacl.sign.detached(digest, keypair.secretKey);

    // Combine signature scheme flag (0x00 for Ed25519) with the signature and public key
    const suiSignature = new Uint8Array(1 + signature.length + keypair.publicKey.length);
    suiSignature[0] = 0x00; // Ed25519 scheme
    suiSignature.set(signature, 1);
    suiSignature.set(keypair.publicKey, 1 + signature.length);

    return btoa(String.fromCharCode.apply(null, suiSignature));
  };

})("object" === typeof module ? module.exports : (window.suiCrypto = {}));