// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vom

import (
	"strconv"

	"v.io/v23/vdl"
)

// This file contains the ReadValue* methods.  The semantics of these methods is
// the same as if StartValue, Decode*, FinishValue were called in sequence.  The
// implementation is faster than actually calling that sequence, because we can
// avoid pushing and popping the decoder stack and also avoid unnecessary
// compatibility checks.  We also get a minor improvement by avoiding extra
// method calls indirected through the Decoder interface.
//
// Each method has the same pattern:
//
// StartValue:
//   If IgnoreNextStarValue is set, the type is already on the stack.  Otherwise
//   setup the type to process Any and Optional headers.  We pass nil to
//   d.setupType to avoid the compatibility check, since the decode step will
//   naturally let us perform that check.
// Decode:
//   We implement common-case fastpaths; e.g. avoiding unnecessary conversions.
// FinishValue:
//   Mirrors StartValue, only pop the stack if necessary.

func (d *decoder81) ReadValueBool() (value bool, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return false, err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return false, err
		}
	}
	// Decode
	switch tt.Kind() {
	case vdl.Bool:
		value, err = binaryDecodeBool(d.buf)
	default:
		return false, errIncompatibleDecode(tt, "bool")
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return false, err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return false, err
			}
		}
	}
	return value, err
}

func (d *decoder81) ReadValueString() (value string, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return "", err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return "", err
		}
	}
	// Decode
	switch tt.Kind() {
	case vdl.String:
		value, err = binaryDecodeString(d.buf)
	case vdl.Enum:
		value, err = d.binaryDecodeEnum(tt)
	default:
		return "", errIncompatibleDecode(tt, "string")
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return "", err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return "", err
			}
		}
	}
	return value, err
}

func (d *decoder81) ReadValueUint(bitlen int) (value uint64, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return 0, err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return 0, err
		}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Uint16, vdl.Uint32, vdl.Uint64:
		if kind.BitLen() <= bitlen {
			value, err = binaryDecodeUint(d.buf)
		} else {
			value, err = d.decodeUint(tt, uint(bitlen))
		}
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64:
		value, err = d.decodeUint(tt, uint(bitlen))
	case vdl.Byte:
		var b byte
		b, err = d.binaryDecodeByte()
		value = uint64(b)
	default:
		return 0, errIncompatibleDecode(tt, "uint"+strconv.Itoa(bitlen))
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return 0, err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return 0, err
			}
		}
	}
	return value, err
}

func (d *decoder81) ReadValueInt(bitlen int) (value int64, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return 0, err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return 0, err
		}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		if kind.BitLen() <= bitlen {
			value, err = binaryDecodeInt(d.buf)
		} else {
			value, err = d.decodeInt(tt, uint(bitlen))
		}
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Float32, vdl.Float64:
		value, err = d.decodeInt(tt, uint(bitlen))
	default:
		return 0, errIncompatibleDecode(tt, "int"+strconv.Itoa(bitlen))
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return 0, err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return 0, err
			}
		}
	}
	return value, err
}

func (d *decoder81) ReadValueFloat(bitlen int) (value float64, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return 0, err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return 0, err
		}
	}
	// Decode, avoiding unnecessary number conversions.
	switch kind := tt.Kind(); kind {
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64:
		value, err = d.decodeFloat(tt, uint(bitlen))
	default:
		return 0, errIncompatibleDecode(tt, "float"+strconv.Itoa(bitlen))
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return 0, err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return 0, err
			}
		}
	}
	return value, err
}

func (d *decoder81) ReadValueTypeObject() (value *vdl.Type, err error) {
	// StartValue
	isOnStack := d.flag.IgnoreNextStartValue()
	var tt *vdl.Type
	if isOnStack {
		tt = d.stack[len(d.stack)-1].Type
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return nil, err
		}
		if tt, _, _, err = d.setupType(tt, nil); err != nil {
			return nil, err
		}
	}
	// Decode
	switch tt.Kind() {
	case vdl.TypeObject:
		value, err = d.binaryDecodeType()
	default:
		return nil, errIncompatibleDecode(tt, "typeobject")
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return nil, err
		}
	} else {
		d.flag = d.flag.Clear(decFlagFinishValue)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return nil, err
			}
		}
	}
	return value, err
}

// ReadValueBytes is more complicated than the other ReadValue* methods, since
// []byte lists and [n]byte arrays aren't scalar, and may need more complicated
// conversions
func (d *decoder81) ReadValueBytes(fixedLen int, x *[]byte) (err error) {
	// StartValue.  Initialize tt and lenHint, and track whether the []byte type
	// is already on the stack via isOnStack.
	isOnStack := d.flag.IgnoreNextStartValue()
	d.flag = d.flag.Clear(decFlagIgnoreNextStartValue)
	var tt *vdl.Type
	var lenHint int
	if isOnStack {
		top := d.top()
		tt, lenHint = top.Type, top.LenHint
	} else {
		if tt, err = d.dfsNextType(); err != nil {
			return err
		}
		var flag decStackFlag
		if tt, lenHint, flag, err = d.setupType(tt, nil); err != nil {
			return err
		}
		// If tt isn't []byte or [n]byte (or a named variant of these), we need to
		// perform conversion byte-by-byte.  This is complicated, and can't be
		// really fast, so we just push an entry onto the stack and handle this via
		// DecodeConvertedBytes below.
		//
		// We also need to perform the compatibility check, to make sure tt is
		// compatible with []byte.  The check is fairly expensive, so skipping it
		// when tt is actually a bytes type makes the the common case faster.
		if !tt.IsBytes() {
			if !vdl.Compatible(tt, ttByteList) {
				return errIncompatibleDecode(tt, "bytes")
			}
			d.stack = append(d.stack, decStackEntry{
				Type:    tt,
				Index:   -1,
				LenHint: lenHint,
				Flag:    flag,
			})
			isOnStack = true
		}
	}
	// Decode.  The common-case fastpath reads directly from the buffer.
	if tt.IsBytes() {
		if err := d.decodeBytes(tt, lenHint, fixedLen, x); err != nil {
			return err
		}
	} else {
		if err := vdl.DecodeConvertedBytes(d, fixedLen, x); err != nil {
			return err
		}
	}
	// FinishValue
	if isOnStack {
		if err := d.FinishValue(); err != nil {
			return err
		}
	} else {
		d.flag = d.flag.Clear(decFlagIsParentBytes)
		if len(d.stack) == 0 {
			if err := d.endMessage(); err != nil {
				return err
			}
		}
	}
	return nil
}

var ttByteList = vdl.ListType(vdl.ByteType)