package rrdbinary

import (
	"encoding/binary"
	"encoding/json"
	"math"
)

type Architecture struct {
	ByteOrder binary.ByteOrder
	// C `double`
	FloatWidth int // always 8 -- we assume IEEE 754 doubles
	FloatAlign int
	// C `long` or `unsigned long`
	IntWidth int
	IntAlign int
	// C `union { unsigned long; double; }`
	UnivalWidth int // max(FloatWidth, IntWidth)
	UnivalAlign int // max(FloatAlign, IntAlign)
	// C `time_t`
	TimeWidth int
	TimeAlign int
}

type String string // \0-terminated
type Float float64 // 8 bytes
type Uint uint64   // 4 or 8 bytes
type Int int64     // 4 or 8 bytes
type Unival uint64 // 8 bytes
type Time int64    // 4 or 8 bytes, only has second-precision
type EOF struct{}  // 0 bytes

func (u Unival) AsUint64() uint64   { return uint64(u) }
func (u Unival) AsFloat64() float64 { return math.Float64frombits(uint64(u)) }

// MarshalJSON is for my own debugging.
func (f Float) MarshalJSON() ([]byte, error) {
	raw := float64(f)
	if math.IsNaN(raw) {
		return json.Marshal("NaN")
	}
	return json.Marshal(raw)
}

// Statically assert that each of the above types implements the
// 'unmarshaler' interface.
var _ unmarshaler = func() *String { return nil }()
var _ unmarshaler = func() *Float { return nil }()
var _ unmarshaler = func() *Uint { return nil }()
var _ unmarshaler = func() *Int { return nil }()
var _ unmarshaler = func() *Unival { return nil }()
var _ unmarshaler = func() *Time { return nil }()
var _ unmarshaler = func() *EOF { return nil }()