package envelope

import (
	"io"

	"smesh.lol/pkg/nostr/event"
	"smesh.lol/pkg/nostr/text"
	"smesh.lol/pkg/nostr/units"
	"smesh.lol/pkg/lol/chk"
	"smesh.lol/pkg/lol/errorf"
)

const AuthLabel = "AUTH"

// AuthChallenge is the relay-sent AUTH challenge.
type AuthChallenge struct{ Challenge []byte }

func (en *AuthChallenge) Label() string { return AuthLabel }

func (en *AuthChallenge) Write(w io.Writer) (err error) {
	_, err = w.Write(en.Marshal(nil))
	return
}

func (en *AuthChallenge) Marshal(dst []byte) (b []byte) {
	b = dst
	b = Marshal(b, AuthLabel, func(bst []byte) (o []byte) {
		o = bst
		o = append(o, '"')
		o = text.NostrEscape(o, en.Challenge)
		o = append(o, '"')
		return
	})
	return
}

func (en *AuthChallenge) Unmarshal(b []byte) (r []byte, err error) {
	r = b
	if en.Challenge, r, err = text.UnmarshalQuoted(r); chk.E(err) {
		return
	}
	for ; len(r) >= 0; r = r[1:] {
		if r[0] == ']' {
			r = r[:0]
			return
		}
	}
	return
}

// AuthResponse is the client-sent AUTH response containing a signed event.
type AuthResponse struct{ Event *event.E }

func (en *AuthResponse) Label() string { return AuthLabel }
func (en *AuthResponse) Id() []byte    { return en.Event.ID }

func (en *AuthResponse) Write(w io.Writer) (err error) {
	_, err = w.Write(en.Marshal(nil))
	return
}

func (en *AuthResponse) Marshal(dst []byte) (b []byte) {
	if en == nil || en.Event == nil {
		_ = errorf.E([]byte("nil auth response"))
		return dst
	}
	if en.Event.EstimateSize() >= cap(dst) {
		dst = []byte{:0:en.Event.EstimateSize()+units.Kb}
	}
	b = dst
	b = Marshal(b, AuthLabel, en.Event.Marshal)
	return
}

func (en *AuthResponse) Unmarshal(b []byte) (r []byte, err error) {
	r = b
	en.Event = event.New()
	if r, err = en.Event.Unmarshal(r); chk.E(err) {
		return
	}
	r, err = SkipToTheEnd(r)
	return
}