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

import (
	"encoding/binary"
	"time"

	"git.smesh.lol/nostr/pkg/lol/chk"
	"git.smesh.lol/nostr/pkg/lol/errorf"
	"git.smesh.lol/nostr/pkg/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 *T) {
	tt := T{time.Now().Unix()}
	return &tt
}

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

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

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

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

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

func FromTime(t time.Time) (tv *T) { return &T{t.Unix()} }
func FromUnix(t int64) (tv *T) { return &T{t} }
func (t *T) FromInt(i int32)     { *t = T{int64(i)} }
func FromBytes(b []byte) (t *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) (buf []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() (s string) {
	return string(ints.New(t.U64()).Marshal(nil))
}

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