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

// +build fuchsia

package fidl

import (
	"sync"

	"syscall/zx"
)

const FidlWireFormatMagicNumberInitial = 1

// messageBytesPool is a pool of buffers that can fit the data part of any
// FIDL message.
var messageBytesPool = sync.Pool{
	New: func() interface{} {
		return make([]byte, zx.ChannelMaxMessageBytes)
	},
}

// messageHandlesPool is a pool of buffers that can fit the handles part of
// any FIDL message.
var messageHandlesPool = sync.Pool{
	New: func() interface{} {
		return make([]zx.Handle, zx.ChannelMaxMessageHandles)
	},
}

// MessageHeader represents a transactional message header.
type MessageHeader struct {
	_       struct{} `fidl:"s,16,8" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Txid    uint32   `fidl:"0" fidl_offset_v1:"0"`
	Flags   [3]uint8 `fidl:"4" fidl_offset_v1:"4"`
	Magic   uint8    `fidl:"7" fidl_offset_v1:"7"`
	Ordinal uint64   `fidl:"8" fidl_offset_v1:"8"`
}

func (msg *MessageHeader) IsSupportedVersion() bool {
	return msg.Magic == FidlWireFormatMagicNumberInitial
}

func (msg *MessageHeader) HasUnionFromXunionBytes() bool {
	return msg.Flags[0] & 0x01 != 0
}

func (msg *MessageHeader) SetUnionFromXunionBytes() {
	msg.Flags[0] |= 0x01
}

var mMessageHeader = MustCreateMarshaler(MessageHeader{})

var MessageHeaderSize = 16

func (msg *MessageHeader) Marshaler() Marshaler {
	return mMessageHeader
}

// MarshalHeaderThenMessage marshals a transactional message
// (see https://fuchsia.googlesource.com/fuchsia/+/master/docs/development/languages/fidl/reference/wire-format/README.md#messages-for-transactions).
// It marshals a `MessageHeader`, optionally followed by a `Message` (body).
func MarshalHeaderThenMessage(header *MessageHeader, body Message, data []byte, handles []zx.Handle) (int, int, error) {
	hnb, _, err := Marshal(header, data, nil)
	if err != nil {
		return 0, 0, err
	}
	if body == nil {
		return hnb, 0, nil
	}
	nb, nh, err := Marshal(body, data[hnb:], handles)
	if err != nil {
		return 0, 0, err
	}
	return hnb + nb, nh, nil
}

// UnmarshalHeaderThenMessage unmarshals a transactional message
// (see https://fuchsia.googlesource.com/fuchsia/+/master/docs/development/languages/fidl/reference/wire-format/README.md#messages-for-transactions).
// It unmarshals a `MessageHeader`, optionally followed by a `Message` (body).
func UnmarshalHeaderThenMessage(data []byte, handles []zx.Handle, header *MessageHeader, body Message) error {
	hnb, _, err := Unmarshal(data, nil, header)
	if err != nil {
		return err
	}
	if body == nil {
		return nil
	}
	ctx := newCtx()
	ctx.DecodeUnionsFromXUnionBytes = header.HasUnionFromXunionBytes()
	if _, _, err := UnmarshalWithContext(ctx, data[hnb:], handles, body); err != nil {
		return err
	}
	return nil
}