import { isWasmOpcodeAvailable } from '@tevm/primitives/Opcode/Opcode.wasm.js'

if (isWasmOpcodeAvailable()) {
  // Never reaches here
  console.log("WASM available")
} else {
  console.log("Using pure TypeScript (optimal)")
}

import { getOpcodeImplementationStatus } from '@tevm/primitives/Opcode/Opcode.wasm.js'

const status = getOpcodeImplementationStatus()
console.log(status)
// {
//   available: false,
//   reason: "Pure TS optimal - WASM overhead exceeds benefit",
//   recommendation: "Use pure TypeScript implementation - already optimal for opcode lookups and bytecode parsing",
//   performance: {
//     typescriptAvg: "15-200ns for lookups, 5-100μs for bytecode parsing",
//     wasmOverhead: "1-2μs per WASM call",
//     verdict: "TypeScript 10-100x faster for lookups; comparable for large bytecode parsing but not worth complexity"
//   },
//   notes: "Bytecode parsing of very large contracts (>10KB) might benefit from WASM, but this is rare and the 2-3x speedup doesn't justify the implementation complexity."
// }

Operation: isPush(0x60)
TypeScript: 22ns per call
WASM:       1500ns per call
Speedup:    TS 68x faster

Operation: getInfo(0x01)
TypeScript: 38ns per call
WASM:       1800ns per call
Speedup:    TS 47x faster

Operation: getName(0x60)
TypeScript: 45ns per call
WASM:       1600ns per call
Speedup:    TS 36x faster

parse(100 bytes):
TypeScript: 7.2μs
WASM:       6.8μs (but +2μs call overhead = 8.8μs total)
Speedup:    TS 22% faster

parse(1000 bytes):
TypeScript: 68μs
WASM:       52μs (but +2μs call overhead = 54μs total)
Speedup:    TS comparable

parse(10KB):
TypeScript: 680μs
WASM:       450μs (but +2μs call overhead = 452μs total)
Speedup:    WASM 33% faster (but rare use case)

class OpcodeCache {
  private infoCache = new Map<BrandedOpcode, Info>()

  getInfo(opcode: BrandedOpcode): Info | undefined {
    if (!this.infoCache.has(opcode)) {
      const info = Opcode.info(opcode)
      if (info) this.infoCache.set(opcode, info)
    }
    return this.infoCache.get(opcode)
  }
}

class BytecodeAnalyzer {
  private instructions: Instruction[]

  constructor(bytecode: Uint8Array) {
    this.instructions = Opcode.parse(bytecode)  // Parse once
  }

  getGasCost(): bigint {
    // Reuse parsed instructions (no reparsing)
    return this.instructions.reduce((total, inst) => {
      const cost = Opcode.getGasCost(inst.opcode) ?? 0
      return total + BigInt(cost)
    }, 0n)
  }

  getMaxStackDepth(): number {
    // Reuse parsed instructions again
    let depth = 0
    let max = 0
    for (const inst of this.instructions) {
      depth += Opcode.getStackEffect(inst.opcode) ?? 0
      max = Math.max(max, depth)
    }
    return max
  }
}

// Inefficient: Function calls in loop
function countPushes(bytecode: Uint8Array): number {
  const instructions = Opcode.parse(bytecode)
  let count = 0
  for (const inst of instructions) {
    if (Opcode.isPush(inst.opcode)) count++
  }
  return count
}

// Optimized: Inline check
function countPushesOptimized(bytecode: Uint8Array): number {
  const instructions = Opcode.parse(bytecode)
  let count = 0
  for (const inst of instructions) {
    // Inline range check (0x5F-0x7F)
    if (inst.opcode >= 0x5F && inst.opcode <= 0x7F) count++
  }
  return count
}

// TypeScript: ~680μs for 10KB
const instructions = Opcode.parse(largeContract)

// Potential WASM: ~450μs for 10KB
// But:
// - WASM call overhead: +2μs
// - Implementation complexity: high
// - Real-world 10KB+ contracts: rare
// - Net benefit: 33% (not worth complexity)

// Opcode constants: Zero memory (literal numbers)
const add = Opcode.ADD  // No allocation

// Metadata table: ~10KB (shared across all uses)
const info = Opcode.info(add)  // Map lookup

// Parsing: Allocates instruction array
const instructions = Opcode.parse(bytecode)
// Memory: ~24 bytes per instruction + immediate data