// Copyright 2014 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package vm

import (
	"errors"
	"fmt"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/math"
	"github.com/ethereum/go-ethereum/core/tracing"
	"github.com/holiman/uint256"
)

// Config are the configuration options for the Interpreter
type Config struct {
	Tracer *tracing.Hooks

	NoBaseFee               bool  // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
	EnablePreimageRecording bool  // Enables recording of SHA3/keccak preimages
	ExtraEips               []int // Additional EIPS that are to be enabled

	ZkGasMeter *ZkGasMeter // CHANGE(taiko): per-opcode zk gas metering when non-nil (Unzen fork)
}

// ScopeContext contains the things that are per-call, such as stack and memory,
// but not transients like pc and gas
type ScopeContext struct {
	Memory   *Memory
	Stack    *Stack
	Contract *Contract
}

// MemoryData returns the underlying memory slice. Callers must not modify the contents
// of the returned data.
func (ctx *ScopeContext) MemoryData() []byte {
	if ctx.Memory == nil {
		return nil
	}
	return ctx.Memory.Data()
}

// StackData returns the stack data. Callers must not modify the contents
// of the returned data.
func (ctx *ScopeContext) StackData() []uint256.Int {
	if ctx.Stack == nil {
		return nil
	}
	return ctx.Stack.Data()
}

// Caller returns the current caller.
func (ctx *ScopeContext) Caller() common.Address {
	return ctx.Contract.Caller()
}

// Address returns the address where this scope of execution is taking place.
func (ctx *ScopeContext) Address() common.Address {
	return ctx.Contract.Address()
}

// CallValue returns the value supplied with this call.
func (ctx *ScopeContext) CallValue() *uint256.Int {
	return ctx.Contract.Value()
}

// CallInput returns the input/calldata with this call. Callers must not modify
// the contents of the returned data.
func (ctx *ScopeContext) CallInput() []byte {
	return ctx.Contract.Input
}

// ContractCode returns the code of the contract being executed.
func (ctx *ScopeContext) ContractCode() []byte {
	return ctx.Contract.Code
}

// Run loops and evaluates the contract's code with the given input data and returns
// the return byte-slice and an error if one occurred.
//
// It's important to note that any errors returned by the interpreter should be
// considered a revert-and-consume-all-gas operation except for
// ErrExecutionReverted which means revert-and-keep-gas-left.
func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error) {
	// Increment the call depth which is restricted to 1024
	evm.depth++
	defer func() { evm.depth-- }()

	// Make sure the readOnly is only set if we aren't in readOnly yet.
	// This also makes sure that the readOnly flag isn't removed for child calls.
	if readOnly && !evm.readOnly {
		evm.readOnly = true
		defer func() { evm.readOnly = false }()
	}

	// Reset the previous call's return data. It's unimportant to preserve the old buffer
	// as every returning call will return new data anyway.
	evm.returnData = nil

	// Don't bother with the execution if there's no code.
	if len(contract.Code) == 0 {
		return nil, nil
	}

	var (
		op          OpCode     // current opcode
		jumpTable   *JumpTable = evm.table
		mem                    = NewMemory() // bound memory
		stack                  = newstack()  // local stack
		callContext            = &ScopeContext{
			Memory:   mem,
			Stack:    stack,
			Contract: contract,
		}
		// For optimisation reason we're using uint64 as the program counter.
		// It's theoretically possible to go above 2^64. The YP defines the PC
		// to be uint256. Practically much less so feasible.
		pc   = uint64(0) // program counter
		cost uint64
		// copies used by tracer
		pcCopy    uint64 // needed for the deferred EVMLogger
		gasCopy   uint64 // for EVMLogger to log gas remaining before execution
		logged    bool   // deferred EVMLogger should ignore already logged steps
		res       []byte // result of the opcode execution function
		debug     = evm.Config.Tracer != nil
		isEIP4762 = evm.chainRules.IsEIP4762
	)
	// Don't move this deferred function, it's placed before the OnOpcode-deferred method,
	// so that it gets executed _after_: the OnOpcode needs the stacks before
	// they are returned to the pools
	defer func() {
		returnStack(stack)
		mem.Free()
	}()
	contract.Input = input

	if debug {
		defer func() { // this deferred method handles exit-with-error
			if err == nil {
				return
			}
			if !logged && evm.Config.Tracer.OnOpcode != nil {
				evm.Config.Tracer.OnOpcode(pcCopy, byte(op), gasCopy, cost, callContext, evm.returnData, evm.depth, VMErrorFromErr(err))
			}
			if logged && evm.Config.Tracer.OnFault != nil {
				evm.Config.Tracer.OnFault(pcCopy, byte(op), gasCopy, cost, callContext, evm.depth, VMErrorFromErr(err))
			}
		}()
	}
	// The Interpreter main run loop (contextual). This loop runs until either an
	// explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during
	// the execution of one of the operations or until the done flag is set by the
	// parent context.
	_ = jumpTable[0] // nil-check the jumpTable out of the loop
	for {
		// CHANGE(taiko): consume the sticky zk-gas-limit slot before dispatching
		// the next opcode. This rescues the case where op*Call swallows the Go
		// error returned from EVM.Call when ChargePrecompile or FinishAndCharge
		// fails inside a child frame — the slot persists on the EVM and exits
		// the outer frame here.
		if evm.zkGasErr != nil {
			return nil, ErrZkGasLimitExceeded
		}
		gasBefore := contract.Gas
		if debug {
			// Capture pre-execution values for tracing.
			logged, pcCopy, gasCopy = false, pc, contract.Gas
		}

		if isEIP4762 && !contract.IsDeployment && !contract.IsSystemCall {
			// if the PC ends up in a new "chunk" of verkleized code, charge the
			// associated costs.
			contractAddr := contract.Address()
			consumed, wanted := evm.TxContext.AccessEvents.CodeChunksRangeGas(contractAddr, pc, 1, uint64(len(contract.Code)), false, contract.Gas)
			contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk)
			if consumed < wanted {
				return nil, ErrOutOfGas
			}
		}

		// Get the operation from the jump table and validate the stack to ensure there are
		// enough stack items available to perform the operation.
		op = contract.GetOp(pc)
		operation := jumpTable[op]
		cost = operation.constantGas // For tracing
		// Validate stack
		if sLen := stack.len(); sLen < operation.minStack {
			// CHANGE(taiko): REVM deducts the instruction-table static gas in
			// step() before the instruction body pops the stack, so a stack
			// underflow still charges the static gas as zk gas (or all
			// remaining frame gas when even the static charge cannot be paid).
			if evm.zkGasTracker != nil && evm.zkGasErr == nil {
				evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
				gasAfterUnderflow := zkGasPreExecutionGasAfter(op, gasBefore)
				// CHANGE(taiko): CREATE2 pops its salt only after REVM charges
				// the initcode and memory costs, so a three-operand stack must
				// meter those in-body charges instead of the table static gas.
				if op == CREATE2 && sLen == 3 {
					gasAfterUnderflow = zkGasCreate2SaltUnderflowGasAfter(evm, stack, mem, gasBefore)
				}
				// CHANGE(taiko): LOG pops its topics only after REVM charges
				// the topic+data cost and memory expansion, so a stack holding
				// the two memory operands but missing topics must meter those
				// in-body charges the same way.
				if op >= LOG1 && op <= LOG4 && sLen >= 2 {
					gasAfterUnderflow = zkGasLogShortfallGasAfter(evm, op, stack, mem, gasBefore)
				}
				if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, gasAfterUnderflow); zkErr != nil {
					evm.setZkGasErr()
					return nil, ErrZkGasLimitExceeded
				}
			}
			return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}
		} else if sLen > operation.maxStack {
			// CHANGE(taiko): same REVM static-gas mirror as the underflow path.
			if evm.zkGasTracker != nil && evm.zkGasErr == nil {
				evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
				if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasPreExecutionGasAfter(op, gasBefore)); zkErr != nil {
					evm.setZkGasErr()
					return nil, ErrZkGasLimitExceeded
				}
			}
			return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}
		}
		// for tracing: this gas consumption event is emitted below in the debug section.
		if contract.Gas < cost {
			if evm.zkGasTracker != nil && evm.zkGasErr == nil {
				evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
				// CHANGE(taiko): CREATE-family fronts its 32000 base cost as
				// constant gas here, but REVM only charges that base inside the
				// instruction after the initcode and memory charges, so this
				// shortfall must reconstruct REVM's charge order instead of
				// spending all remaining gas.
				gasAfterShortfall := uint64(0)
				if op == CREATE || op == CREATE2 {
					gasAfterShortfall = zkGasCreateShortfallGasAfter(evm, stack, mem, gasBefore)
				}
				if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, gasAfterShortfall); zkErr != nil {
					evm.setZkGasErr()
					return nil, ErrZkGasLimitExceeded
				}
			}
			return nil, ErrOutOfGas
		} else {
			contract.Gas -= cost
		}

		// All ops with a dynamic memory usage also has a dynamic gas cost.
		var memorySize uint64
		if operation.dynamicGas != nil {
			gasAfterStatic := contract.Gas
			memoryLastGasCost := mem.lastGasCost
			// calculate the new memory size and expand the memory to fit
			// the operation
			// Memory check needs to be done prior to evaluating the dynamic gas portion,
			// to detect calculation overflows
			if operation.memorySize != nil {
				memSize, overflow := operation.memorySize(stack)
				if overflow {
					if evm.zkGasTracker != nil && evm.zkGasErr == nil {
						evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
						if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasMemorySizeOverflowGasAfter(evm, op, stack, mem, gasBefore, gasAfterStatic)); zkErr != nil {
							evm.setZkGasErr()
							return nil, ErrZkGasLimitExceeded
						}
					}
					return nil, ErrGasUintOverflow
				}
				// memory is expanded in words of 32 bytes. Gas
				// is also calculated in words.
				if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
					if evm.zkGasTracker != nil && evm.zkGasErr == nil {
						evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
						if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasMemorySizeOverflowGasAfter(evm, op, stack, mem, gasBefore, gasAfterStatic)); zkErr != nil {
							evm.setZkGasErr()
							return nil, ErrZkGasLimitExceeded
						}
					}
					return nil, ErrGasUintOverflow
				}
			}
			// Consume the gas and return an error if not enough gas is available.
			// cost is explicitly set so that the capture state defer method can get the proper cost
			var dynamicCost uint64
			dynamicCost, err = operation.dynamicGas(evm, contract, stack, mem, memorySize)
			cost += dynamicCost // for tracing
			if err != nil {
				// CHANGE(taiko): reconstruct the REVM-visible spend for the
				// dynamic-gas failure class. The classes are mutually
				// exclusive, and the switch guarantees a step can never be
				// metered twice even if a future gas function wraps several
				// of them into one error.
				if evm.zkGasTracker != nil && evm.zkGasErr == nil {
					switch {
					case errors.Is(err, ErrOutOfGas):
						evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
						if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasDynamicOOGGasAfter(evm, op, stack, mem, memorySize, memoryLastGasCost, gasBefore, gasAfterStatic)); zkErr != nil {
							evm.setZkGasErr()
							return nil, ErrZkGasLimitExceeded
						}
					case errors.Is(err, ErrWriteProtection):
						// Write-protection failures occur before go-ethereum
						// reaches opcode execution. REVM has already deducted
						// the instruction-table static gas at that point, so
						// mirror the same pre-execution charge here.
						evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
						if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasPreExecutionGasAfter(op, gasBefore)); zkErr != nil {
							evm.setZkGasErr()
							return nil, ErrZkGasLimitExceeded
						}
					case errors.Is(err, ErrGasUintOverflow):
						// Memory costs beyond go-ethereum's uint64 cap halt
						// REVM around the affected opcode's in-body charges
						// (initcode, topic+data, per-word, or memory
						// expansion), so they must be metered instead of
						// skipped.
						if gasAfterOverflow, handled := zkGasDynamicUintOverflowGasAfter(evm, op, stack, mem, gasBefore, gasAfterStatic); handled {
							evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
							if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, gasAfterOverflow); zkErr != nil {
								evm.setZkGasErr()
								return nil, ErrZkGasLimitExceeded
							}
						}
					case errors.Is(err, errSStoreSentry), errors.Is(err, ErrMaxInitCodeSizeExceeded):
						// The SSTORE reentrancy sentry and the EIP-3860
						// initcode size limit halt REVM inside the instruction
						// body before any in-body charge, leaving only the
						// (zero) table static gas spent.
						evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
						if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasPreExecutionGasAfter(op, gasBefore)); zkErr != nil {
							evm.setZkGasErr()
							return nil, ErrZkGasLimitExceeded
						}
					}
				}
				return nil, fmt.Errorf("%w: %v", ErrOutOfGas, err)
			}
			// for tracing: this gas consumption event is emitted below in the debug section.
			if contract.Gas < dynamicCost {
				if evm.zkGasTracker != nil && evm.zkGasErr == nil {
					evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
					if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasDynamicOOGGasAfter(evm, op, stack, mem, memorySize, memoryLastGasCost, gasBefore, gasAfterStatic)); zkErr != nil {
						evm.setZkGasErr()
						return nil, ErrZkGasLimitExceeded
					}
				}
				return nil, ErrOutOfGas
			} else {
				contract.Gas -= dynamicCost
			}
		}

		// Do tracing before potential memory expansion
		if debug {
			if evm.Config.Tracer.OnGasChange != nil {
				evm.Config.Tracer.OnGasChange(gasCopy, gasCopy-cost, tracing.GasChangeCallOpCode)
			}
			if evm.Config.Tracer.OnOpcode != nil {
				evm.Config.Tracer.OnOpcode(pc, byte(op), gasCopy, cost, callContext, evm.returnData, evm.depth, VMErrorFromErr(err))
				logged = true
			}
		}
		if memorySize > 0 {
			mem.Resize(memorySize)
		}

		// CHANGE(taiko): capture the pre-step opcode and gas so zk gas charging
		// can be resolved after execution with consensus zk-gas semantics.
		if evm.zkGasTracker != nil {
			evm.zkGasTracker.Begin(evm.depth, byte(op), gasBefore)
		}

		// execute the operation
		res, err = operation.execute(&pc, evm, callContext)

		// CHANGE(taiko): charge zk gas after opcode execution using consensus
		// semantics: net per-step gas unless the opcode actually
		// spawned child work, in which case the fixed spawn estimate is used.
		if evm.zkGasTracker != nil && evm.zkGasErr == nil {
			if zkErr := evm.zkGasTracker.FinishAndCharge(evm.depth, zkGasStepGasAfter(op, err, gasBefore, contract.Gas)); zkErr != nil {
				evm.setZkGasErr()
				return nil, ErrZkGasLimitExceeded
			}
		}

		if err != nil {
			break
		}
		pc++
	}

	if err == errStopToken {
		err = nil // clear stop token error
	}

	return res, err
}
