// Package timestamp provides helpers for working with UNIX timestamps.
package timestamp

import (
	"encoding/binary"
	"time"

	"smesh.lol/pkg/lol/chk"
	"smesh.lol/pkg/lol/errorf"
	"smesh.lol/pkg/nostr/ints"
)

type T struct{ V int64 }

func New(x ...int64) (t *T) {
	t = &T{}
	if len(x) > 0 {
		t.V = x[0]
	}
	return
}

func Now() *T {
	tt := T{time.Now().Unix()}
	return &tt
}

func (t *T) U64() uint64 {
	if t == nil {
		return 0
	}
	return uint64(t.V)
}

func (t *T) I64() int64 {
	if t == nil {
		return 0
	}
	return t.V
}

func (t *T) Time() time.Time { return time.Unix(t.V, 0) }

func (t *T) Int() int {
	if t == nil {
		return 0
	}
	return int(t.V)
}

func (t *T) Bytes() (b []byte) {
	b = []byte{:8}
	binary.BigEndian.PutUint64(b, uint64(t.V))
	return
}

func FromTime(t time.Time) *T  { return &T{t.Unix()} }
func FromUnix(t int64) *T      { return &T{t} }
func (t *T) FromInt(i int)     { *t = T{int64(i)} }
func FromBytes(b []byte) *T    { return &T{int64(binary.BigEndian.Uint64(b))} }

func FromVarint(b []byte) (t *T, rem []byte, err error) {
	n, read := binary.Varint(b)
	if read < 1 {
		err = errorf.E([]byte("failed to decode varint timestamp %v"), b)
		return
	}
	t = &T{n}
	rem = b[:read]
	return
}

// Marshal renders the timestamp as decimal ASCII bytes.
func (t *T) Marshal(dst []byte) []byte { return ints.New(t.U64()).Marshal(dst) }

func (t *T) Unmarshal(b []byte) (r []byte, err error) {
	n := ints.New(0)
	if r, err = n.Unmarshal(b); chk.E(err) {
		return
	}
	*t = T{n.Int64()}
	return
}

func (t *T) String() string {
	return string(ints.New(t.U64()).Marshal(nil))
}

func (t *T) MarshalJSON() ([]byte, error) {
	return ints.New(t.U64()).Marshal(nil), nil
}