/**
 * 极简比特币脚本虚拟机（P2PKH 核心流程）
 * 纯 TypeScript 从零实现，无外部依赖
 */

// 操作码定义（与比特币一致）
enum Op {
  PUSH1 = 0x01,
  PUSH20 = 0x14,   // 压入 20 字节数据（公钥哈希长度）
  PUSH33 = 0x21,   // 压入 33 字节数据（压缩公钥长度）
  DUP = 0x76,
  HASH160 = 0xa9,
  EQUALVERIFY = 0x88,
  CHECKSIG = 0xac,
}

/** 简化双 SHA-256（教学实现，非加密安全） */
function sha256Loop(data: Uint8Array): Uint8Array {
  // 占位：真实实现参见 02.02-sha256 从零实现
  // 此处返回确定性伪哈希以便演示栈逻辑
  const out = new Uint8Array(32);
  let acc = 0x9e3779b9;
  for (let i = 0; i < data.length; i++) {
    acc = (acc ^ data[i]) * 0x85ebca6b;
    acc ^= acc >>> 13; // 仅演示用
  }
  for (let i = 0; i < 32; i++) {
    acc = (acc * 0x5bd1e995 + i) >>> 0;
    out[i] = acc & 0xff;
  }
  return out;
}

/** RIPEMD160(SHA256(x)) —— 比特币 HASH160 */
function hash160(data: Uint8Array): Uint8Array {
  const inner = sha256Loop(data);
  return sha256Loop(inner).slice(0, 20);
}

/** 栈式脚本执行器 */
export function runScript(
  scriptSig: Uint8Array[],      // 解锁脚本压入的数据
  scriptPubKey: Uint8Array,     // 锁定脚本字节
  pubKeyHashExpected: Uint8Array
): boolean {
  const stack: Uint8Array[] = [];

  // 1. 执行解锁脚本：压入 sig 与 pubKey
  for (const item of scriptSig) stack.push(item);

  // 2. 执行锁定脚本（简化：按操作码序列遍历）
  const pubKey = stack[stack.length - 1]; // 栈顶公钥
  const sig = stack[stack.length - 2];    // 次栈顶签名

  // OP_DUP: 复制栈顶
  stack.push(pubKey);

  // OP_HASH160: 栈顶公钥 → 哈希
  const hashed = hash160(pubKey);
  stack.push(hashed);

  // 压入期望的公钥哈希
  stack.push(pubKeyHashExpected);

  // OP_EQUALVERIFY: 比较两个哈希
  const h1 = stack.pop()!;
  const h2 = stack.pop()!;
  if (!bytesEqual(h1, h2)) return false;

  // OP_CHECKSIG: 验证签名（教学简化：仅检查签名长度合法）
  if (sig.length < 8) return false;

  return true;
}

function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
  return true;
}

// ---- 演示 ----
// 模拟：公钥 → 哈希 → 用配对公钥花费成功
const fakePubKey = new Uint8Array(33).fill(2);   // 压缩公钥占位
const correctHash = hash160(fakePubKey);
const fakeSig = new Uint8Array(70).fill(7);      // DER 签名占位

const unlock = [fakeSig, fakePubKey];            // scriptSig
const ok = runScript(unlock, new Uint8Array(), correctHash);

console.log("P2PKH 验证结果:", ok ? "✅ 通过" : "❌ 失败");

// 错误的公钥哈希 → 验证失败
const wrongHash = new Uint8Array(20).fill(99);
console.log(
  "错误哈希验证结果:",
  runScript(unlock, new Uint8Array(), wrongHash) ? "❌(不应通过)" : "✅ 正确拒绝"
);

P2PKH 验证结果: ✅ 通过
错误哈希验证结果: ✅ 正确拒绝

/**
 * Base58Check 地址编码（P2PKH）
 * 从零实现，无外部依赖
 */

const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnopqrstuvwxyz";

/** 字节 → Base58 字符串（保留前导零） */
function base58Encode(bytes: Uint8Array): string {
  // 统计前导零字节
  let zeros = 0;
  for (const b of bytes) {
    if (b === 0) zeros++;
    else break;
  }

  // 字节 → 大整数
  let num = 0n;
  for (const b of bytes) num = (num << 8n) | BigInt(b);

  let encoded = "";
  while (num > 0n) {
    const rem = num % 58n;
    num /= 58n;
    encoded = ALPHABET[Number(rem)] + encoded;
  }

  return "1".repeat(zeros) + encoded;
}

/** 双重 SHA-256 取前 4 字节作为校验和 */
function checksum4(data: Uint8Array): Uint8Array {
  // 教学占位：真实实现见 02.02
  let acc = 0x811c9dc5;
  for (const b of data) {
    acc ^= b;
    acc = (acc * 0x01000193) >>> 0;
  }
  const out = new Uint8Array(4);
  for (let i = 0; i < 4; i++) {
    acc = (acc * 0x5bd1e995) >>> 0;
    out[i] = acc & 0xff;
  }
  return out;
}

/** Base58Check 编码：version + payload + 前4字节双SHA校验 */
export function base58CheckEncode(version: number, payload: Uint8Array): string {
  const data = new Uint8Array(1 + payload.length + 4);
  data[0] = version;
  data.set(payload, 1);
  const checksum = checksum4(data.subarray(0, 1 + payload.length));
  data.set(checksum, 1 + payload.length);
  return base58Encode(data);
}

// ---- 演示：主网 P2PKH（version 0x00）----
// 占位公钥哈希（真实情境由 HASH160(pubkey) 得到）
const pubKeyHashDemo = new Uint8Array(20).fill(0xAB);
const address = base58CheckEncode(0x00, pubKeyHashDemo);
console.log("P2PKH 地址（主网）:", address);
console.log("地址前缀:", address[0], "（主网以 1 开头）");

P2PKH 地址（主网）: 1GejCghxCErkGS3hDZ1g1SM95h6F6XGfL3
地址前缀: 1 （主网以 1 开头）