package goja

import (
	"math"
	"math/big"
	"reflect"
	"strconv"
	"unsafe"

	"github.com/dop251/goja/unistring"
)

type byteOrder bool

const (
	bigEndian    byteOrder = false
	littleEndian byteOrder = true
)

var (
	nativeEndian byteOrder

	arrayBufferType = reflect.TypeOf(ArrayBuffer{})
)

type typedArrayObjectCtor func(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject

type arrayBufferObject struct {
	baseObject
	detached bool
	data     []byte
}

// ArrayBuffer is a Go wrapper around ECMAScript ArrayBuffer. Calling Runtime.ToValue() on it
// returns the underlying ArrayBuffer. Calling Export() on an ECMAScript ArrayBuffer returns a wrapper.
// Use Runtime.NewArrayBuffer([]byte) to create one.
type ArrayBuffer struct {
	buf *arrayBufferObject
}

type dataViewObject struct {
	baseObject
	viewedArrayBuf      *arrayBufferObject
	byteLen, byteOffset int
}

type typedArray interface {
	toRaw(Value) uint64
	get(idx int) Value
	set(idx int, value Value)
	getRaw(idx int) uint64
	setRaw(idx int, raw uint64)
	less(i, j int) bool
	swap(i, j int)
	typeMatch(v Value) bool
	export(offset int, length int) interface{}
	exportType() reflect.Type
}

type uint8Array []byte
type uint8ClampedArray []byte
type int8Array []byte
type uint16Array []byte
type int16Array []byte
type uint32Array []byte
type int32Array []byte
type float32Array []byte
type float64Array []byte
type bigInt64Array []byte
type bigUint64Array []byte

type typedArrayObject struct {
	baseObject
	viewedArrayBuf *arrayBufferObject
	defaultCtor    *Object
	length, offset int
	elemSize       int
	typedArray     typedArray
}

func (a ArrayBuffer) toValue(r *Runtime) Value {
	if a.buf == nil {
		return _null
	}
	v := a.buf.val
	if v.runtime != r {
		panic(r.NewTypeError("Illegal runtime transition of an ArrayBuffer"))
	}
	return v
}

// Bytes returns the underlying []byte for this ArrayBuffer.
// For detached ArrayBuffers returns nil.
func (a ArrayBuffer) Bytes() []byte {
	return a.buf.data
}

// Detach the ArrayBuffer. After this, the underlying []byte becomes unreferenced and any attempt
// to use this ArrayBuffer results in a TypeError.
// Returns false if it was already detached, true otherwise.
// Note, this method may only be called from the goroutine that 'owns' the Runtime, it may not
// be called concurrently.
func (a ArrayBuffer) Detach() bool {
	if a.buf.detached {
		return false
	}
	a.buf.detach()
	return true
}

// Detached returns true if the ArrayBuffer is detached.
func (a ArrayBuffer) Detached() bool {
	return a.buf.detached
}

// NewArrayBuffer creates a new instance of ArrayBuffer backed by the provided byte slice.
//
// Warning: be careful when using unaligned slices (sub-slices that do not start at word boundaries). If later a
// typed array of a multibyte type (uint16, uint32, etc.) is created from a buffer backed by an unaligned slice,
// using this typed array will result in unaligned access which may cause performance degradation or runtime panics
// on some architectures or configurations.
func (r *Runtime) NewArrayBuffer(data []byte) ArrayBuffer {
	buf := r._newArrayBuffer(r.getArrayBufferPrototype(), nil)
	buf.data = data
	return ArrayBuffer{
		buf: buf,
	}
}

func (a *uint8Array) toRaw(v Value) uint64 {
	return uint64(toUint8(v))
}

func (a *uint8Array) ptr(idx int) *uint8 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*uint8)(unsafe.Pointer(uintptr(p) + uintptr(idx)))
}

func (a *uint8Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *uint8Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toUint8(value)
}

func (a *uint8Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *uint8Array) setRaw(idx int, raw uint64) {
	*(a.ptr(idx)) = uint8(raw)
}

func (a *uint8Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *uint8Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *uint8Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= 0 && i <= 255
	}
	return false
}

func (a *uint8Array) export(offset int, length int) interface{} {
	return ([]uint8)(*a)[offset : offset+length : offset+length]
}

func (a *uint8Array) exportType() reflect.Type {
	return typeBytes
}

func (a *uint8ClampedArray) toRaw(v Value) uint64 {
	return uint64(toUint8Clamp(v))
}

func (a *uint8ClampedArray) ptr(idx int) *uint8 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*uint8)(unsafe.Pointer(uintptr(p) + uintptr(idx)))
}

func (a *uint8ClampedArray) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *uint8ClampedArray) set(idx int, value Value) {
	*(a.ptr(idx)) = toUint8Clamp(value)
}

func (a *uint8ClampedArray) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *uint8ClampedArray) setRaw(idx int, raw uint64) {
	*(a.ptr(idx)) = uint8(raw)
}

func (a *uint8ClampedArray) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *uint8ClampedArray) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *uint8ClampedArray) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= 0 && i <= 255
	}
	return false
}

func (a *uint8ClampedArray) export(offset int, length int) interface{} {
	return ([]uint8)(*a)[offset : offset+length : offset+length]
}

func (a *uint8ClampedArray) exportType() reflect.Type {
	return typeBytes
}

func (a *int8Array) ptr(idx int) *int8 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*int8)(unsafe.Pointer(uintptr(p) + uintptr(idx)))
}

func (a *int8Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *int8Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *int8Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toInt8(value)
}

func (a *int8Array) toRaw(v Value) uint64 {
	return uint64(toInt8(v))
}

func (a *int8Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = int8(v)
}

func (a *int8Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *int8Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *int8Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= math.MinInt8 && i <= math.MaxInt8
	}
	return false
}

func (a *int8Array) export(offset int, length int) interface{} {
	var res []int8
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeInt8Array = reflect.TypeOf(([]int8)(nil))

func (a *int8Array) exportType() reflect.Type {
	return typeInt8Array
}

func (a *uint16Array) toRaw(v Value) uint64 {
	return uint64(toUint16(v))
}

func (a *uint16Array) ptr(idx int) *uint16 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*uint16)(unsafe.Pointer(uintptr(p) + uintptr(idx)*2))
}

func (a *uint16Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *uint16Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toUint16(value)
}

func (a *uint16Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *uint16Array) setRaw(idx int, raw uint64) {
	*(a.ptr(idx)) = uint16(raw)
}

func (a *uint16Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *uint16Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *uint16Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= 0 && i <= math.MaxUint16
	}
	return false
}

var typeUint16Array = reflect.TypeOf(([]uint16)(nil))

func (a *uint16Array) export(offset int, length int) interface{} {
	var res []uint16
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*2
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

func (a *uint16Array) exportType() reflect.Type {
	return typeUint16Array
}

func (a *int16Array) ptr(idx int) *int16 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*int16)(unsafe.Pointer(uintptr(p) + uintptr(idx)*2))
}

func (a *int16Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *int16Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *int16Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toInt16(value)
}

func (a *int16Array) toRaw(v Value) uint64 {
	return uint64(toInt16(v))
}

func (a *int16Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = int16(v)
}

func (a *int16Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *int16Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *int16Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= math.MinInt16 && i <= math.MaxInt16
	}
	return false
}

func (a *int16Array) export(offset int, length int) interface{} {
	var res []int16
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*2
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeInt16Array = reflect.TypeOf(([]int16)(nil))

func (a *int16Array) exportType() reflect.Type {
	return typeInt16Array
}

func (a *uint32Array) ptr(idx int) *uint32 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*uint32)(unsafe.Pointer(uintptr(p) + uintptr(idx)*4))
}

func (a *uint32Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *uint32Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *uint32Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toUint32(value)
}

func (a *uint32Array) toRaw(v Value) uint64 {
	return uint64(toUint32(v))
}

func (a *uint32Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = uint32(v)
}

func (a *uint32Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *uint32Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *uint32Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= 0 && i <= math.MaxUint32
	}
	return false
}

func (a *uint32Array) export(offset int, length int) interface{} {
	var res []uint32
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*4
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeUint32Array = reflect.TypeOf(([]uint32)(nil))

func (a *uint32Array) exportType() reflect.Type {
	return typeUint32Array
}

func (a *int32Array) ptr(idx int) *int32 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*int32)(unsafe.Pointer(uintptr(p) + uintptr(idx)*4))
}

func (a *int32Array) get(idx int) Value {
	return intToValue(int64(*(a.ptr(idx))))
}

func (a *int32Array) getRaw(idx int) uint64 {
	return uint64(*(a.ptr(idx)))
}

func (a *int32Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toInt32(value)
}

func (a *int32Array) toRaw(v Value) uint64 {
	return uint64(toInt32(v))
}

func (a *int32Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = int32(v)
}

func (a *int32Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *int32Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *int32Array) typeMatch(v Value) bool {
	if i, ok := v.(valueInt); ok {
		return i >= math.MinInt32 && i <= math.MaxInt32
	}
	return false
}

func (a *int32Array) export(offset int, length int) interface{} {
	var res []int32
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*4
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeInt32Array = reflect.TypeOf(([]int32)(nil))

func (a *int32Array) exportType() reflect.Type {
	return typeInt32Array
}

func (a *float32Array) ptr(idx int) *float32 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*float32)(unsafe.Pointer(uintptr(p) + uintptr(idx)*4))
}

func (a *float32Array) get(idx int) Value {
	return floatToValue(float64(*(a.ptr(idx))))
}

func (a *float32Array) getRaw(idx int) uint64 {
	return uint64(math.Float32bits(*(a.ptr(idx))))
}

func (a *float32Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toFloat32(value)
}

func (a *float32Array) toRaw(v Value) uint64 {
	return uint64(math.Float32bits(toFloat32(v)))
}

func (a *float32Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = math.Float32frombits(uint32(v))
}

func typedFloatLess(x, y float64) bool {
	xNan := math.IsNaN(x)
	yNan := math.IsNaN(y)
	if yNan {
		return !xNan
	} else if xNan {
		return false
	}
	if x == 0 && y == 0 { // handle neg zero
		return math.Signbit(x)
	}
	return x < y
}

func (a *float32Array) less(i, j int) bool {
	return typedFloatLess(float64(*(a.ptr(i))), float64(*(a.ptr(j))))
}

func (a *float32Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *float32Array) typeMatch(v Value) bool {
	switch v.(type) {
	case valueInt, valueFloat:
		return true
	}
	return false
}

func (a *float32Array) export(offset int, length int) interface{} {
	var res []float32
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*4
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeFloat32Array = reflect.TypeOf(([]float32)(nil))

func (a *float32Array) exportType() reflect.Type {
	return typeFloat32Array
}

func (a *float64Array) ptr(idx int) *float64 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*float64)(unsafe.Pointer(uintptr(p) + uintptr(idx)*8))
}

func (a *float64Array) get(idx int) Value {
	return floatToValue(*(a.ptr(idx)))
}

func (a *float64Array) getRaw(idx int) uint64 {
	return math.Float64bits(*(a.ptr(idx)))
}

func (a *float64Array) set(idx int, value Value) {
	*(a.ptr(idx)) = value.ToFloat()
}

func (a *float64Array) toRaw(v Value) uint64 {
	return math.Float64bits(v.ToFloat())
}

func (a *float64Array) setRaw(idx int, v uint64) {
	*(a.ptr(idx)) = math.Float64frombits(v)
}

func (a *float64Array) less(i, j int) bool {
	return typedFloatLess(*(a.ptr(i)), *(a.ptr(j)))
}

func (a *float64Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *float64Array) typeMatch(v Value) bool {
	switch v.(type) {
	case valueInt, valueFloat:
		return true
	}
	return false
}

func (a *float64Array) export(offset int, length int) interface{} {
	var res []float64
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*8
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeFloat64Array = reflect.TypeOf(([]float64)(nil))

func (a *float64Array) exportType() reflect.Type {
	return typeFloat64Array
}

func (a *bigInt64Array) toRaw(value Value) uint64 {
	return toBigInt64(value).Uint64()
}

func (a *bigInt64Array) ptr(idx int) *int64 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*int64)(unsafe.Pointer(uintptr(p) + uintptr(idx)*8))
}

func (a *bigInt64Array) get(idx int) Value {
	return (*valueBigInt)(big.NewInt(*a.ptr(idx)))
}

func toBigInt64(v Value) *big.Int {
	n := (*big.Int)(toBigInt(v))

	twoTo64 := new(big.Int).Lsh(big.NewInt(1), 64)
	twoTo63 := new(big.Int).Lsh(big.NewInt(1), 63)

	int64bit := new(big.Int).Mod(n, twoTo64)
	if int64bit.Cmp(twoTo63) >= 0 {
		return int64bit.Sub(int64bit, twoTo64)
	}
	return int64bit
}

func (a *bigInt64Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toBigInt64(value).Int64()
}

func (a *bigInt64Array) getRaw(idx int) uint64 {
	return uint64(*a.ptr(idx))
}

func (a *bigInt64Array) setRaw(idx int, raw uint64) {
	*(a.ptr(idx)) = int64(raw)
}

func (a *bigInt64Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *bigInt64Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *bigInt64Array) typeMatch(v Value) bool {
	if _, ok := v.(*valueBigInt); ok {
		return true
	}
	return false
}

func (a *bigInt64Array) export(offset int, length int) interface{} {
	var res []int64
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*8
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeBigInt64Array = reflect.TypeOf(([]int64)(nil))

func (a *bigInt64Array) exportType() reflect.Type {
	return typeBigInt64Array
}

func (a *bigUint64Array) toRaw(value Value) uint64 {
	return toBigUint64(value).Uint64()
}

func (a *bigUint64Array) ptr(idx int) *uint64 {
	p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(a)).Data)
	return (*uint64)(unsafe.Pointer(uintptr(p) + uintptr(idx)*8))
}

func (a *bigUint64Array) get(idx int) Value {
	return (*valueBigInt)(new(big.Int).SetUint64(*a.ptr(idx)))
}

func toBigUint64(v Value) *big.Int {
	n := (*big.Int)(toBigInt(v))
	return new(big.Int).Mod(n, new(big.Int).Lsh(big.NewInt(1), 64))
}

func (a *bigUint64Array) set(idx int, value Value) {
	*(a.ptr(idx)) = toBigUint64(value).Uint64()
}

func (a *bigUint64Array) getRaw(idx int) uint64 {
	return *a.ptr(idx)
}

func (a *bigUint64Array) setRaw(idx int, raw uint64) {
	*(a.ptr(idx)) = raw
}

func (a *bigUint64Array) less(i, j int) bool {
	return *(a.ptr(i)) < *(a.ptr(j))
}

func (a *bigUint64Array) swap(i, j int) {
	pi, pj := a.ptr(i), a.ptr(j)
	*pi, *pj = *pj, *pi
}

func (a *bigUint64Array) typeMatch(v Value) bool {
	if _, ok := v.(*valueBigInt); ok {
		return true
	}
	return false
}

func (a *bigUint64Array) export(offset int, length int) interface{} {
	var res []uint64
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&res))
	sliceHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(a)).Data + uintptr(offset)*8
	sliceHeader.Len = length
	sliceHeader.Cap = length
	return res
}

var typeBigUint64Array = reflect.TypeOf(([]uint64)(nil))

func (a *bigUint64Array) exportType() reflect.Type {
	return typeBigUint64Array
}

func (a *typedArrayObject) _getIdx(idx int) Value {
	if 0 <= idx && idx < a.length {
		if !a.viewedArrayBuf.ensureNotDetached(false) {
			return nil
		}
		return a.typedArray.get(idx + a.offset)
	}
	return nil
}

func (a *typedArrayObject) getOwnPropStr(name unistring.String) Value {
	idx, ok := strToIntNum(name)
	if ok {
		v := a._getIdx(idx)
		if v != nil {
			return &valueProperty{
				value:        v,
				writable:     true,
				enumerable:   true,
				configurable: true,
			}
		}
		return nil
	}
	if idx == 0 {
		return nil
	}
	return a.baseObject.getOwnPropStr(name)
}

func (a *typedArrayObject) getOwnPropIdx(idx valueInt) Value {
	v := a._getIdx(toIntClamp(int64(idx)))
	if v != nil {
		return &valueProperty{
			value:        v,
			writable:     true,
			enumerable:   true,
			configurable: true,
		}
	}
	return nil
}

func (a *typedArrayObject) getStr(name unistring.String, receiver Value) Value {
	idx, ok := strToIntNum(name)
	if ok {
		return a._getIdx(idx)
	}
	if idx == 0 {
		return nil
	}
	return a.baseObject.getStr(name, receiver)
}

func (a *typedArrayObject) getIdx(idx valueInt, receiver Value) Value {
	return a._getIdx(toIntClamp(int64(idx)))
}

func (a *typedArrayObject) isValidIntegerIndex(idx int) bool {
	if a.viewedArrayBuf.ensureNotDetached(false) {
		if idx >= 0 && idx < a.length {
			return true
		}
	}
	return false
}

func (a *typedArrayObject) _putIdx(idx int, v Value) {
	switch a.typedArray.(type) {
	case *bigInt64Array, *bigUint64Array:
		v = toBigInt(v)
	default:
		v = v.ToNumber()
	}
	if a.isValidIntegerIndex(idx) {
		a.typedArray.set(idx+a.offset, v)
	}
}

func (a *typedArrayObject) _hasIdx(idx int) bool {
	return a.isValidIntegerIndex(idx)
}

func (a *typedArrayObject) setOwnStr(p unistring.String, v Value, throw bool) bool {
	idx, ok := strToIntNum(p)
	if ok {
		a._putIdx(idx, v)
		return true
	}
	if idx == 0 {
		toNumeric(v) // make sure it throws
		return true
	}
	return a.baseObject.setOwnStr(p, v, throw)
}

func (a *typedArrayObject) setOwnIdx(p valueInt, v Value, throw bool) bool {
	a._putIdx(toIntClamp(int64(p)), v)
	return true
}

func (a *typedArrayObject) setForeignStr(p unistring.String, v, receiver Value, throw bool) (res bool, handled bool) {
	return a._setForeignStr(p, a.getOwnPropStr(p), v, receiver, throw)
}

func (a *typedArrayObject) setForeignIdx(p valueInt, v, receiver Value, throw bool) (res bool, handled bool) {
	return a._setForeignIdx(p, trueValIfPresent(a.hasOwnPropertyIdx(p)), v, receiver, throw)
}

func (a *typedArrayObject) hasOwnPropertyStr(name unistring.String) bool {
	idx, ok := strToIntNum(name)
	if ok {
		return a._hasIdx(idx)
	}
	if idx == 0 {
		return false
	}
	return a.baseObject.hasOwnPropertyStr(name)
}

func (a *typedArrayObject) hasOwnPropertyIdx(idx valueInt) bool {
	return a._hasIdx(toIntClamp(int64(idx)))
}

func (a *typedArrayObject) hasPropertyStr(name unistring.String) bool {
	idx, ok := strToIntNum(name)
	if ok {
		return a._hasIdx(idx)
	}
	if idx == 0 {
		return false
	}
	return a.baseObject.hasPropertyStr(name)
}

func (a *typedArrayObject) hasPropertyIdx(idx valueInt) bool {
	return a.hasOwnPropertyIdx(idx)
}

func (a *typedArrayObject) _defineIdxProperty(idx int, desc PropertyDescriptor, throw bool) bool {
	if desc.Configurable == FLAG_FALSE || desc.Enumerable == FLAG_FALSE || desc.IsAccessor() || desc.Writable == FLAG_FALSE {
		a.val.runtime.typeErrorResult(throw, "Cannot redefine property: %d", idx)
		return false
	}
	_, ok := a._defineOwnProperty(unistring.String(strconv.Itoa(idx)), a.getOwnPropIdx(valueInt(idx)), desc, throw)
	if ok {
		if !a.isValidIntegerIndex(idx) {
			a.val.runtime.typeErrorResult(throw, "Invalid typed array index")
			return false
		}
		a._putIdx(idx, desc.Value)
		return true
	}
	return ok
}

func (a *typedArrayObject) defineOwnPropertyStr(name unistring.String, desc PropertyDescriptor, throw bool) bool {
	idx, ok := strToIntNum(name)
	if ok {
		return a._defineIdxProperty(idx, desc, throw)
	}
	if idx == 0 {
		a.viewedArrayBuf.ensureNotDetached(throw)
		a.val.runtime.typeErrorResult(throw, "Invalid typed array index")
		return false
	}
	return a.baseObject.defineOwnPropertyStr(name, desc, throw)
}

func (a *typedArrayObject) defineOwnPropertyIdx(name valueInt, desc PropertyDescriptor, throw bool) bool {
	return a._defineIdxProperty(toIntClamp(int64(name)), desc, throw)
}

func (a *typedArrayObject) deleteStr(name unistring.String, throw bool) bool {
	idx, ok := strToIntNum(name)
	if ok {
		if a.isValidIntegerIndex(idx) {
			a.val.runtime.typeErrorResult(throw, "Cannot delete property '%d' of %s", idx, a.val.String())
			return false
		}
		return true
	}
	if idx == 0 {
		return true
	}
	return a.baseObject.deleteStr(name, throw)
}

func (a *typedArrayObject) deleteIdx(idx valueInt, throw bool) bool {
	if a.viewedArrayBuf.ensureNotDetached(false) && idx >= 0 && int64(idx) < int64(a.length) {
		a.val.runtime.typeErrorResult(throw, "Cannot delete property '%d' of %s", idx, a.val.String())
		return false
	}

	return true
}

func (a *typedArrayObject) stringKeys(all bool, accum []Value) []Value {
	if accum == nil {
		accum = make([]Value, 0, a.length)
	}
	for i := 0; i < a.length; i++ {
		accum = append(accum, asciiString(strconv.Itoa(i)))
	}
	return a.baseObject.stringKeys(all, accum)
}

type typedArrayPropIter struct {
	a   *typedArrayObject
	idx int
}

func (i *typedArrayPropIter) next() (propIterItem, iterNextFunc) {
	if i.idx < i.a.length {
		name := strconv.Itoa(i.idx)
		prop := i.a._getIdx(i.idx)
		i.idx++
		return propIterItem{name: asciiString(name), value: prop}, i.next
	}

	return i.a.baseObject.iterateStringKeys()()
}

func (a *typedArrayObject) iterateStringKeys() iterNextFunc {
	return (&typedArrayPropIter{
		a: a,
	}).next
}

func (a *typedArrayObject) exportToArrayOrSlice(dst reflect.Value, typ reflect.Type, ctx *objectExportCtx) error {
	if typ == typeBytes {
		dst.Set(reflect.ValueOf(a.viewedArrayBuf.data))
		return nil
	}
	return a.baseObject.exportToArrayOrSlice(dst, typ, ctx)
}

func (a *typedArrayObject) export(_ *objectExportCtx) interface{} {
	return a.typedArray.export(a.offset, a.length)
}

func (a *typedArrayObject) exportType() reflect.Type {
	return a.typedArray.exportType()
}

func (o *dataViewObject) exportToArrayOrSlice(dst reflect.Value, typ reflect.Type, ctx *objectExportCtx) error {
	if typ == typeBytes {
		dst.Set(reflect.ValueOf(o.viewedArrayBuf.data))
		return nil
	}
	return o.baseObject.exportToArrayOrSlice(dst, typ, ctx)
}

func (r *Runtime) _newTypedArrayObject(buf *arrayBufferObject, offset, length, elemSize int, defCtor *Object, arr typedArray, proto *Object) *typedArrayObject {
	o := &Object{runtime: r}
	a := &typedArrayObject{
		baseObject: baseObject{
			val:        o,
			class:      classObject,
			prototype:  proto,
			extensible: true,
		},
		viewedArrayBuf: buf,
		offset:         offset,
		length:         length,
		elemSize:       elemSize,
		defaultCtor:    defCtor,
		typedArray:     arr,
	}
	o.self = a
	a.init()
	return a

}

func (r *Runtime) newUint8ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	// Note, no need to use r.getUint8Array() here or in the similar methods below, because the value is already set
	// by the time they are called.
	return r._newTypedArrayObject(buf, offset, length, 1, r.global.Uint8Array, (*uint8Array)(&buf.data), proto)
}

func (r *Runtime) newUint8ClampedArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 1, r.global.Uint8ClampedArray, (*uint8ClampedArray)(&buf.data), proto)
}

func (r *Runtime) newInt8ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 1, r.global.Int8Array, (*int8Array)(&buf.data), proto)
}

func (r *Runtime) newUint16ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 2, r.global.Uint16Array, (*uint16Array)(&buf.data), proto)
}

func (r *Runtime) newInt16ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 2, r.global.Int16Array, (*int16Array)(&buf.data), proto)
}

func (r *Runtime) newUint32ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 4, r.global.Uint32Array, (*uint32Array)(&buf.data), proto)
}

func (r *Runtime) newInt32ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 4, r.global.Int32Array, (*int32Array)(&buf.data), proto)
}

func (r *Runtime) newFloat32ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 4, r.global.Float32Array, (*float32Array)(&buf.data), proto)
}

func (r *Runtime) newFloat64ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 8, r.global.Float64Array, (*float64Array)(&buf.data), proto)
}

func (r *Runtime) newBigInt64ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 8, r.global.BigInt64Array, (*bigInt64Array)(&buf.data), proto)
}

func (r *Runtime) newBigUint64ArrayObject(buf *arrayBufferObject, offset, length int, proto *Object) *typedArrayObject {
	return r._newTypedArrayObject(buf, offset, length, 8, r.global.BigUint64Array, (*bigUint64Array)(&buf.data), proto)
}

func (o *dataViewObject) getIdxAndByteOrder(getIdx int, littleEndianVal Value, size int) (int, byteOrder) {
	o.viewedArrayBuf.ensureNotDetached(true)
	if getIdx+size > o.byteLen {
		panic(o.val.runtime.newError(o.val.runtime.getRangeError(), "Index %d is out of bounds", getIdx))
	}
	getIdx += o.byteOffset
	var bo byteOrder
	if littleEndianVal != nil {
		if littleEndianVal.ToBoolean() {
			bo = littleEndian
		} else {
			bo = bigEndian
		}
	} else {
		bo = nativeEndian
	}
	return getIdx, bo
}

func (o *arrayBufferObject) ensureNotDetached(throw bool) bool {
	if o.detached {
		o.val.runtime.typeErrorResult(throw, "ArrayBuffer is detached")
		return false
	}
	return true
}

func (o *arrayBufferObject) getFloat32(idx int, byteOrder byteOrder) float32 {
	return math.Float32frombits(o.getUint32(idx, byteOrder))
}

func (o *arrayBufferObject) setFloat32(idx int, val float32, byteOrder byteOrder) {
	o.setUint32(idx, math.Float32bits(val), byteOrder)
}

func (o *arrayBufferObject) getFloat64(idx int, byteOrder byteOrder) float64 {
	return math.Float64frombits(o.getUint64(idx, byteOrder))
}

func (o *arrayBufferObject) setFloat64(idx int, val float64, byteOrder byteOrder) {
	o.setUint64(idx, math.Float64bits(val), byteOrder)
}

func (o *arrayBufferObject) getUint64(idx int, byteOrder byteOrder) uint64 {
	var b []byte
	if byteOrder == nativeEndian {
		b = o.data[idx : idx+8]
	} else {
		b = make([]byte, 8)
		d := o.data[idx : idx+8]
		b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] = d[7], d[6], d[5], d[4], d[3], d[2], d[1], d[0]
	}
	return *((*uint64)(unsafe.Pointer(&b[0])))
}

func (o *arrayBufferObject) setUint64(idx int, val uint64, byteOrder byteOrder) {
	if byteOrder == nativeEndian {
		*(*uint64)(unsafe.Pointer(&o.data[idx])) = val
	} else {
		b := (*[8]byte)(unsafe.Pointer(&val))
		d := o.data[idx : idx+8]
		d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7] = b[7], b[6], b[5], b[4], b[3], b[2], b[1], b[0]
	}
}

func (o *arrayBufferObject) getUint32(idx int, byteOrder byteOrder) uint32 {
	var b []byte
	if byteOrder == nativeEndian {
		b = o.data[idx : idx+4]
	} else {
		b = make([]byte, 4)
		d := o.data[idx : idx+4]
		b[0], b[1], b[2], b[3] = d[3], d[2], d[1], d[0]
	}
	return *((*uint32)(unsafe.Pointer(&b[0])))
}

func (o *arrayBufferObject) setUint32(idx int, val uint32, byteOrder byteOrder) {
	o.ensureNotDetached(true)
	if byteOrder == nativeEndian {
		*(*uint32)(unsafe.Pointer(&o.data[idx])) = val
	} else {
		b := (*[4]byte)(unsafe.Pointer(&val))
		d := o.data[idx : idx+4]
		d[0], d[1], d[2], d[3] = b[3], b[2], b[1], b[0]
	}
}

func (o *arrayBufferObject) getBigInt64(idx int, byteOrder byteOrder) *big.Int {
	var b []byte
	if byteOrder == nativeEndian {
		b = o.data[idx : idx+8]
	} else {
		b = make([]byte, 8)
		d := o.data[idx : idx+8]
		b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] = d[7], d[6], d[5], d[4], d[3], d[2], d[1], d[0]
	}
	return big.NewInt(*((*int64)(unsafe.Pointer(&b[0]))))
}

func (o *arrayBufferObject) getBigUint64(idx int, byteOrder byteOrder) *big.Int {
	var b []byte
	if byteOrder == nativeEndian {
		b = o.data[idx : idx+8]
	} else {
		b = make([]byte, 8)
		d := o.data[idx : idx+8]
		b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] = d[7], d[6], d[5], d[4], d[3], d[2], d[1], d[0]
	}
	return new(big.Int).SetUint64(*((*uint64)(unsafe.Pointer(&b[0]))))
}

func (o *arrayBufferObject) setBigInt64(idx int, val *big.Int, byteOrder byteOrder) {
	if byteOrder == nativeEndian {
		*(*int64)(unsafe.Pointer(&o.data[idx])) = val.Int64()
	} else {
		n := val.Int64()
		b := (*[8]byte)(unsafe.Pointer(&n))
		d := o.data[idx : idx+8]
		d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7] = b[7], b[6], b[5], b[4], b[3], b[2], b[1], b[0]
	}
}

func (o *arrayBufferObject) setBigUint64(idx int, val *big.Int, byteOrder byteOrder) {
	if byteOrder == nativeEndian {
		*(*uint64)(unsafe.Pointer(&o.data[idx])) = val.Uint64()
	} else {
		n := val.Uint64()
		b := (*[8]byte)(unsafe.Pointer(&n))
		d := o.data[idx : idx+8]
		d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7] = b[7], b[6], b[5], b[4], b[3], b[2], b[1], b[0]
	}
}

func (o *arrayBufferObject) getUint16(idx int, byteOrder byteOrder) uint16 {
	var b []byte
	if byteOrder == nativeEndian {
		b = o.data[idx : idx+2]
	} else {
		b = make([]byte, 2)
		d := o.data[idx : idx+2]
		b[0], b[1] = d[1], d[0]
	}
	return *((*uint16)(unsafe.Pointer(&b[0])))
}

func (o *arrayBufferObject) setUint16(idx int, val uint16, byteOrder byteOrder) {
	if byteOrder == nativeEndian {
		*(*uint16)(unsafe.Pointer(&o.data[idx])) = val
	} else {
		b := (*[2]byte)(unsafe.Pointer(&val))
		d := o.data[idx : idx+2]
		d[0], d[1] = b[1], b[0]
	}
}

func (o *arrayBufferObject) getUint8(idx int) uint8 {
	return o.data[idx]
}

func (o *arrayBufferObject) setUint8(idx int, val uint8) {
	o.data[idx] = val
}

func (o *arrayBufferObject) getInt32(idx int, byteOrder byteOrder) int32 {
	return int32(o.getUint32(idx, byteOrder))
}

func (o *arrayBufferObject) setInt32(idx int, val int32, byteOrder byteOrder) {
	o.setUint32(idx, uint32(val), byteOrder)
}

func (o *arrayBufferObject) getInt16(idx int, byteOrder byteOrder) int16 {
	return int16(o.getUint16(idx, byteOrder))
}

func (o *arrayBufferObject) setInt16(idx int, val int16, byteOrder byteOrder) {
	o.setUint16(idx, uint16(val), byteOrder)
}

func (o *arrayBufferObject) getInt8(idx int) int8 {
	return int8(o.data[idx])
}

func (o *arrayBufferObject) setInt8(idx int, val int8) {
	o.setUint8(idx, uint8(val))
}

func (o *arrayBufferObject) detach() {
	o.data = nil
	o.detached = true
}

func (o *arrayBufferObject) exportType() reflect.Type {
	return arrayBufferType
}

func (o *arrayBufferObject) export(*objectExportCtx) interface{} {
	return ArrayBuffer{
		buf: o,
	}
}

func (o *arrayBufferObject) exportToArrayOrSlice(dst reflect.Value, typ reflect.Type, ctx *objectExportCtx) error {
	if typ == typeBytes {
		dst.Set(reflect.ValueOf(o.data))
		return nil
	}
	return o.baseObject.exportToArrayOrSlice(dst, typ, ctx)
}

func (r *Runtime) _newArrayBuffer(proto *Object, o *Object) *arrayBufferObject {
	if o == nil {
		o = &Object{runtime: r}
	}
	b := &arrayBufferObject{
		baseObject: baseObject{
			class:      classObject,
			val:        o,
			prototype:  proto,
			extensible: true,
		},
	}
	o.self = b
	b.init()
	return b
}

func init() {
	buf := [2]byte{}
	*(*uint16)(unsafe.Pointer(&buf[0])) = uint16(0xCAFE)

	switch buf {
	case [2]byte{0xFE, 0xCA}:
		nativeEndian = littleEndian
	case [2]byte{0xCA, 0xFE}:
		nativeEndian = bigEndian
	default:
		panic("Could not determine native endianness.")
	}
}