import * as Opcode from '@tevm/primitives/Opcode'

Opcode.isValid(0x00)  // true (STOP)
Opcode.isValid(0x01)  // true (ADD)
Opcode.isValid(0x60)  // true (PUSH1)
Opcode.isValid(0xFF)  // true (SELFDESTRUCT)

// Invalid opcodes
Opcode.isValid(0x0C)  // false (undefined)
Opcode.isValid(0x0D)  // false (undefined)
Opcode.isValid(0x21)  // false (undefined, between KECCAK256 and ADDRESS)
Opcode.isValid(0x4B)  // false (undefined, after BLOBBASEFEE)

const valid = Opcode.isValidOpcode(0x60)  // true

import * as Opcode from '@tevm/primitives/Opcode'

const bytecode = new Uint8Array([
  0x60, 0x04,     // PUSH1 0x04
  0x56,           // JUMP
  0x5B,           // JUMPDEST (offset 3)
  0x00            // STOP
])

Opcode.isValidJumpDest(bytecode, 3)  // true (valid JUMPDEST)
Opcode.isValidJumpDest(bytecode, 0)  // false (PUSH1, not JUMPDEST)
Opcode.isValidJumpDest(bytecode, 1)  // false (inside PUSH data)
Opcode.isValidJumpDest(bytecode, 99) // false (out of bounds)

Opcode.isJumpDestination(0x5B)  // true
Opcode.isJumpDestination(0x56)  // false (JUMP, not JUMPDEST)

import * as Opcode from '@tevm/primitives/Opcode'

Opcode.isPush(0x5F)  // true (PUSH0)
Opcode.isPush(0x60)  // true (PUSH1)
Opcode.isPush(0x7F)  // true (PUSH32)
Opcode.isPush(0x01)  // false (ADD)
Opcode.isPush(0x80)  // false (DUP1)

Opcode.isDup(0x80)  // true (DUP1)
Opcode.isDup(0x8F)  // true (DUP16)
Opcode.isDup(0x60)  // false (PUSH1)
Opcode.isDup(0x90)  // false (SWAP1)

Opcode.isSwap(0x90)  // true (SWAP1)
Opcode.isSwap(0x9F)  // true (SWAP16)
Opcode.isSwap(0x80)  // false (DUP1)
Opcode.isSwap(0xA0)  // false (LOG0)

Opcode.isLog(0xA0)  // true (LOG0)
Opcode.isLog(0xA4)  // true (LOG4)
Opcode.isLog(0xA5)  // false (undefined)
Opcode.isLog(0x9F)  // false (SWAP16)

Opcode.isJump(0x56)  // true (JUMP)
Opcode.isJump(0x57)  // true (JUMPI)
Opcode.isJump(0x5B)  // false (JUMPDEST)
Opcode.isJump(0x00)  // false (STOP)

Opcode.isTerminating(0x00)  // true (STOP)
Opcode.isTerminating(0xF3)  // true (RETURN)
Opcode.isTerminating(0xFD)  // true (REVERT)
Opcode.isTerminating(0xFE)  // true (INVALID)
Opcode.isTerminating(0xFF)  // true (SELFDESTRUCT)
Opcode.isTerminating(0x01)  // false (ADD)

const terminates = Opcode.isTerminator(0xF3)  // true

function validateBytecode(bytecode: Uint8Array): string[] {
  const errors: string[] = []
  const instructions = Opcode.parse(bytecode)

  for (const inst of instructions) {
    if (!Opcode.isValid(inst.opcode)) {
      errors.push(`Invalid opcode 0x${inst.opcode.toString(16)} at offset ${inst.offset}`)
    }
  }

  return errors
}

function hasUnsafeJumps(bytecode: Uint8Array): boolean {
  const instructions = Opcode.parse(bytecode)
  const validDests = Opcode.jumpDests(bytecode)

  for (const inst of instructions) {
    if (Opcode.isJump(inst.opcode)) {
      // In real analysis, would need symbolic execution to get jump target
      // This is simplified
      if (validDests.size === 0) {
        return true  // Has jumps but no valid destinations
      }
    }
  }

  return false
}

interface InstructionCategories {
  push: number
  dup: number
  swap: number
  log: number
  jump: number
  terminating: number
  other: number
}

function categorizeInstructions(bytecode: Uint8Array): InstructionCategories {
  const instructions = Opcode.parse(bytecode)
  const categories: InstructionCategories = {
    push: 0,
    dup: 0,
    swap: 0,
    log: 0,
    jump: 0,
    terminating: 0,
    other: 0
  }

  for (const inst of instructions) {
    if (Opcode.isPush(inst.opcode)) categories.push++
    else if (Opcode.isDup(inst.opcode)) categories.dup++
    else if (Opcode.isSwap(inst.opcode)) categories.swap++
    else if (Opcode.isLog(inst.opcode)) categories.log++
    else if (Opcode.isJump(inst.opcode)) categories.jump++
    else if (Opcode.isTerminating(inst.opcode)) categories.terminating++
    else categories.other++
  }

  return categories
}

function findInvalidOpcodes(bytecode: Uint8Array): number[] {
  const instructions = Opcode.parse(bytecode)
  const invalidOffsets: number[] = []

  for (const inst of instructions) {
    if (!Opcode.isValid(inst.opcode)) {
      invalidOffsets.push(inst.offset)
    }
  }

  return invalidOffsets
}

function validatePushInstructions(bytecode: Uint8Array): boolean {
  const instructions = Opcode.parse(bytecode)

  for (const inst of instructions) {
    if (Opcode.isPush(inst.opcode)) {
      const expectedBytes = Opcode.pushBytes(inst.opcode)

      // PUSH0 has no immediate
      if (expectedBytes === 0 && inst.immediate !== undefined) {
        return false
      }

      // Other PUSHes must have immediate data
      if (expectedBytes > 0) {
        if (!inst.immediate || inst.immediate.length !== expectedBytes) {
          return false
        }
      }
    }
  }

  return true
}

function findUnreachableCode(bytecode: Uint8Array): Set<number> {
  const instructions = Opcode.parse(bytecode)
  const reachable = new Set<number>([0])  // Start is reachable

  for (const inst of instructions) {
    if (!reachable.has(inst.offset)) {
      continue  // Skip unreachable instructions
    }

    // Next instruction is reachable unless this terminates
    if (!Opcode.isTerminating(inst.opcode)) {
      // Find next instruction offset
      const nextOffset = inst.offset + 1 + (inst.immediate?.length ?? 0)
      reachable.add(nextOffset)
    }

    // JUMP/JUMPI make destinations reachable (would need symbolic execution for actual targets)
  }

  const unreachable = new Set<number>()
  for (const inst of instructions) {
    if (!reachable.has(inst.offset)) {
      unreachable.add(inst.offset)
    }
  }

  return unreachable
}