// Copyright 2015 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 (
	"v.io/v23/vdl"
	"v.io/v23/verror"
)

var (
	errDecodeZeroTypeID         = verror.Register(pkgPath+".errDecodeZeroTypeID", verror.NoRetry, "{1:}{2:} vom: zero type id{:_}")
	errIndexOutOfRange          = verror.Register(pkgPath+".errIndexOutOfRange", verror.NoRetry, "{1:}{2:} vom: index out of range{:_}")
	errLeftOverBytes            = verror.Register(pkgPath+".errLeftOverBytes", verror.NoRetry, "{1:}{2:} vom: {3} leftover bytes{:_}")
	errUnexpectedControlByte    = verror.Register(pkgPath+".errUnexpectedControlByte", verror.NoRetry, "{1:}{2:} vom: unexpected control byte {3}{:_}")
	errDecodeValueUnhandledType = verror.Register(pkgPath+".errDecodeValueUnhandledType", verror.NoRetry, "{1:}{2:} vom: decodeValue unhandled type {3}{:_}")
	errIgnoreValueUnhandledType = verror.Register(pkgPath+".errIgnoreValueUnhandledType", verror.NoRetry, "{1:}{2:} vom: ignoreValue unhandled type {3}{:_}")
	errInvalidTypeIdIndex       = verror.Register(pkgPath+".errInvalidTypeIdIndex", verror.NoRetry, "{1:}{2:} vom: value referenced invalid index into type id table {:_}")
	errInvalidAnyIndex          = verror.Register(pkgPath+".errInvalidAnyIndex", verror.NoRetry, "{1:}{2:} vom: value referenced invalid index into anyLen table {:_}")
)

func (d *decoder81) decodeTypeDefs() error {
	for {
		typeNext, err := d.typeIsNext()
		if err != nil {
			return err
		}
		if !typeNext {
			return nil
		}
		if err := d.typeDec.readSingleType(); err != nil {
			return err
		}
	}
}

// peekValueByteLen returns the byte length of the next value.
func (d *decoder81) peekValueByteLen(tt *vdl.Type) (int, error) {
	if hasChunkLen(tt) {
		// Use the explicit message length.
		return d.buf.lim, nil
	}
	// No explicit message length, but the length can be computed.
	switch {
	case tt.Kind() == vdl.Array && tt.IsBytes():
		// Byte arrays are exactly their length and encoded with 1-byte header.
		return tt.Len() + 1, nil
	case tt.Kind() == vdl.String || tt.IsBytes():
		// Strings and byte lists are encoded with a length header.
		strlen, bytelen, err := binaryPeekUint(d.buf)
		switch {
		case err != nil:
			return 0, err
		case strlen > maxBinaryMsgLen:
			return 0, verror.New(errMsgLen, nil, maxBinaryMsgLen)
		}
		return int(strlen) + bytelen, nil
	default:
		// Must be a primitive, which is encoded as an underlying uint.
		return binaryPeekUintByteLen(d.buf)
	}
}

func (d *decoder81) decodeRaw(tt *vdl.Type, valLen int, raw *RawBytes) error {
	raw.Version = d.buf.version
	raw.Type = tt
	raw.Data = make([]byte, valLen)
	if err := d.buf.ReadIntoBuf(raw.Data); err != nil {
		return err
	}
	refTypeLen := len(d.refTypes.tids)
	if cap(raw.RefTypes) >= refTypeLen {
		raw.RefTypes = raw.RefTypes[:refTypeLen]
	} else {
		raw.RefTypes = make([]*vdl.Type, refTypeLen)
	}
	for i, tid := range d.refTypes.tids {
		var err error
		if raw.RefTypes[i], err = d.typeDec.lookupType(tid); err != nil {
			return err
		}
	}
	raw.AnyLengths = d.refAnyLens.lens
	return nil
}

func (d *decoder81) readAnyHeader() (*vdl.Type, int, error) {
	// Handle WireCtrlNil.
	switch ok, err := binaryDecodeControlOnly(d.buf, WireCtrlNil); {
	case err != nil:
		return nil, 0, err
	case ok:
		return nil, 0, nil // nil any
	}
	// Read the index of the referenced type id.
	typeIndex, err := binaryDecodeUint(d.buf)
	if err != nil {
		return nil, 0, err
	}
	var tid TypeId
	if d.buf.version == Version80 {
		tid = TypeId(typeIndex)
	} else if tid, err = d.refTypes.ReferencedTypeId(typeIndex); err != nil {
		return nil, 0, err
	}
	// Look up the referenced type id.
	ttElem, err := d.typeDec.lookupType(tid)
	if err != nil {
		return nil, 0, err
	}
	var anyLen int
	if d.buf.version != Version80 {
		// Read and lookup the index of the any byte length.  Reference the any len,
		// even if it isn't used, to report missing references.
		lenIndex, err := binaryDecodeUint(d.buf)
		if err != nil {
			return nil, 0, err
		}
		if anyLen, err = d.refAnyLens.ReferencedAnyLen(lenIndex); err != nil {
			return nil, 0, err
		}
	}
	return ttElem, anyLen, nil
}

func (d *decoder81) skipValue(tt *vdl.Type) error {
	if tt.IsBytes() {
		len, err := binaryDecodeLenOrArrayLen(d.buf, tt)
		if err != nil {
			return err
		}
		return d.buf.Skip(len)
	}
	switch kind := tt.Kind(); kind {
	case vdl.Bool:
		return d.buf.Skip(1)
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64, vdl.Enum, vdl.TypeObject:
		// The underlying encoding of all these types is based on uint.
		return binarySkipUint(d.buf)
	case vdl.String:
		return binarySkipString(d.buf)
	case vdl.Array, vdl.List, vdl.Set, vdl.Map:
		len, err := binaryDecodeLenOrArrayLen(d.buf, tt)
		if err != nil {
			return err
		}
		for ix := 0; ix < len; ix++ {
			if kind == vdl.Set || kind == vdl.Map {
				if err := d.skipValue(tt.Key()); err != nil {
					return err
				}
			}
			if kind == vdl.Array || kind == vdl.List || kind == vdl.Map {
				if err := d.skipValue(tt.Elem()); err != nil {
					return err
				}
			}
		}
		return nil
	case vdl.Struct:
		// Loop through decoding the 0-based field index and corresponding field.
		for {
			switch ok, err := binaryDecodeControlOnly(d.buf, WireCtrlEnd); {
			case err != nil:
				return err
			case ok:
				return nil // end of struct
			}
			switch index, err := binaryDecodeUint(d.buf); {
			case err != nil:
				return err
			case index >= uint64(tt.NumField()):
				return verror.New(errIndexOutOfRange, nil)
			default:
				ttfield := tt.Field(int(index))
				if err := d.skipValue(ttfield.Type); err != nil {
					return err
				}
			}
		}
	case vdl.Union:
		switch index, err := binaryDecodeUint(d.buf); {
		case err != nil:
			return err
		case index >= uint64(tt.NumField()):
			return verror.New(errIndexOutOfRange, nil)
		default:
			ttfield := tt.Field(int(index))
			return d.skipValue(ttfield.Type)
		}
	case vdl.Optional:
		// Read the WireCtrlNil code, but if it's not WireCtrlNil we need to keep
		// the buffer as-is, since it's the first byte of the value, which may
		// itself be another control code.
		switch ctrl, err := binaryPeekControl(d.buf); {
		case err != nil:
			return err
		case ctrl == WireCtrlNil:
			d.buf.SkipAvailable(1) // nil optional
			return nil
		default:
			return d.skipValue(tt.Elem()) // non-nil optional
		}
	case vdl.Any:
		switch ok, err := binaryDecodeControlOnly(d.buf, WireCtrlNil); {
		case err != nil:
			return err
		case ok:
			return nil // nil any
		}
		switch index, err := binaryDecodeUint(d.buf); {
		case err != nil:
			return err
		default:
			tid, err := d.refTypes.ReferencedTypeId(index)
			if err != nil {
				return err
			}
			ttElem, err := d.typeDec.lookupType(tid)
			if err != nil {
				return err
			}
			return d.skipValue(ttElem)
		}
	default:
		return verror.New(errIgnoreValueUnhandledType, nil, tt)
	}
}

func (d *decoder81) nextMessage() (TypeId, error) {
	if leftover := d.buf.RemoveLimit(); leftover > 0 {
		return 0, verror.New(errLeftOverBytes, nil, leftover)
	}
	// Decode version byte, if not already decoded.
	if d.buf.version == 0 {
		version, err := d.buf.ReadByte()
		if err != nil {
			return 0, verror.New(errEndedBeforeVersionByte, nil, err)
		}
		d.buf.version = Version(version)
		if !isAllowedVersion(d.buf.version) {
			return 0, verror.New(errBadVersionByte, nil, d.buf.version)
		}
	}
	// Decode the next message id.
	incomplete, err := binaryDecodeControlOnly(d.buf, WireCtrlTypeIncomplete)
	if err != nil {
		return 0, err
	}
	mid, err := binaryDecodeInt(d.buf)
	if err != nil {
		return 0, err
	}
	if incomplete {
		if mid >= 0 {
			// TypeIncomplete must be followed with a type message.
			return 0, verror.New(errInvalid, nil)
		}
		d.flag = d.flag.Set(decFlagTypeIncomplete)
	} else if mid < 0 {
		d.flag = d.flag.Clear(decFlagTypeIncomplete)
	}
	// TODO(toddw): Clean up the logic below.
	var tid TypeId
	var hasAny, hasTypeObject, hasLength bool
	switch {
	case mid < 0:
		tid = TypeId(-mid)
		hasLength = true
		hasAny = false
		hasTypeObject = false
	case mid > 0:
		tid = TypeId(mid)
		t, err := d.typeDec.lookupType(tid)
		if err != nil {
			return 0, err
		}
		hasLength = hasChunkLen(t)
		hasAny = containsAny(t)
		hasTypeObject = containsTypeObject(t)
	default:
		return 0, verror.New(errDecodeZeroTypeID, nil)
	}

	if (hasAny || hasTypeObject) && d.buf.version != Version80 {
		l, err := binaryDecodeUint(d.buf)
		if err != nil {
			return 0, err
		}
		for i := 0; i < int(l); i++ {
			refId, err := binaryDecodeUint(d.buf)
			if err != nil {
				return 0, err
			}
			d.refTypes.AddTypeID(TypeId(refId))
		}
	}
	if hasAny && d.buf.version != Version80 {
		l, err := binaryDecodeUint(d.buf)
		if err != nil {
			return 0, err
		}
		for i := 0; i < int(l); i++ {
			refAnyLen, err := binaryDecodeLen(d.buf)
			if err != nil {
				return 0, err
			}
			d.refAnyLens.AddAnyLen(refAnyLen)
		}
	}

	if hasLength {
		chunkLen, err := binaryDecodeUint(d.buf)
		if err != nil {
			return 0, err
		}
		d.buf.SetLimit(int(chunkLen))
	}

	return tid, nil
}

func (d *decoder81) typeIsNext() (bool, error) {
	if d.buf.version == 0 {
		version, err := d.buf.ReadByte()
		if err != nil {
			return false, verror.New(errEndedBeforeVersionByte, nil, err)
		}
		d.buf.version = Version(version)
		if !isAllowedVersion(d.buf.version) {
			return false, verror.New(errBadVersionByte, nil, d.buf.version)
		}
	}
	switch ctrl, err := binaryPeekControl(d.buf); {
	case err != nil:
		return false, err
	case ctrl == WireCtrlTypeIncomplete:
		return true, nil
	case ctrl != 0:
		return false, verror.New(errBadControlCode, nil, ctrl)
	}
	mid, _, err := binaryPeekInt(d.buf)
	if err != nil {
		return false, err
	}
	return mid < 0, nil
}

func (d *decoder81) endMessage() error {
	if leftover := d.buf.RemoveLimit(); leftover > 0 {
		return verror.New(errLeftOverBytes, nil, leftover)
	}
	if err := d.refTypes.Reset(); err != nil {
		return err
	}
	if err := d.refAnyLens.Reset(); err != nil {
		return err
	}
	return nil
}

type referencedTypes struct {
	tids   []TypeId
	marker int
}

func (refTypes *referencedTypes) Reset() (err error) {
	refTypes.tids = refTypes.tids[:0]
	refTypes.marker = 0
	return
}

func (refTypes *referencedTypes) AddTypeID(tid TypeId) {
	refTypes.tids = append(refTypes.tids, tid)
}

func (refTypes *referencedTypes) ReferencedTypeId(index uint64) (TypeId, error) {
	if index >= uint64(len(refTypes.tids)) {
		return 0, verror.New(errInvalidTypeIdIndex, nil)
	}
	return refTypes.tids[index], nil
}

func (refTypes *referencedTypes) Mark() {
	refTypes.marker = len(refTypes.tids)
}

type referencedAnyLens struct {
	lens   []int
	marker int
}

func (refAnys *referencedAnyLens) Reset() (err error) {
	refAnys.lens = refAnys.lens[:0]
	return
}

func (refAnys *referencedAnyLens) AddAnyLen(len int) {
	refAnys.lens = append(refAnys.lens, len)
}

func (refAnys *referencedAnyLens) ReferencedAnyLen(index uint64) (int, error) {
	if index >= uint64(len(refAnys.lens)) {
		return 0, verror.New(errInvalidAnyIndex, nil)
	}
	return refAnys.lens[index], nil
}

func (refAnys *referencedAnyLens) Mark() {
	refAnys.marker = len(refAnys.lens)
}