// Package types provides fixed-size cryptographic types for Nostr.
package types

import (
	"encoding/hex"
)

const (
	EventIDSize   = 32
	PubkeySize    = 32
	SignatureSize = 64
	SecretKeySize = 32
)

type EventID [EventIDSize]byte
type Pubkey [PubkeySize]byte
type Signature [SignatureSize]byte
type SecretKey [SecretKeySize]byte

// --- EventID ---

func (id *EventID) Bytes() []byte { return id[:] }

func (id EventID) Copy() []byte {
	b := []byte{:EventIDSize}
	copy(b, id[:])
	return b
}

func (id EventID) Hex() []byte {
	b := []byte{:EventIDSize*2}
	hex.Encode(b, id[:])
	return b
}

func (id EventID) IsZero() bool { return id == EventID{} }

func EventIDFromBytes(src []byte) (id EventID) {
	copy(id[:], src)
	return
}

func EventIDFromHex(s []byte) (id EventID, err error) {
	if len(s) != EventIDSize*2 {
		return id, hex.InvalidByteError(0)
	}
	_, err = hex.Decode(id[:], s)
	return
}

// --- Pubkey ---

func (pk *Pubkey) Bytes() []byte { return pk[:] }

func (pk Pubkey) Copy() []byte {
	b := []byte{:PubkeySize}
	copy(b, pk[:])
	return b
}

func (pk Pubkey) Hex() []byte {
	b := []byte{:PubkeySize*2}
	hex.Encode(b, pk[:])
	return b
}

func (pk Pubkey) IsZero() bool { return pk == Pubkey{} }

func PubkeyFromBytes(src []byte) (pk Pubkey) {
	copy(pk[:], src)
	return
}

func PubkeyFromHex(s []byte) (pk Pubkey, err error) {
	if len(s) != PubkeySize*2 {
		return pk, hex.InvalidByteError(0)
	}
	_, err = hex.Decode(pk[:], s)
	return
}

// --- Signature ---

func (sig *Signature) Bytes() []byte { return sig[:] }

func (sig Signature) Copy() []byte {
	b := []byte{:SignatureSize}
	copy(b, sig[:])
	return b
}

func (sig Signature) Hex() []byte {
	b := []byte{:SignatureSize*2}
	hex.Encode(b, sig[:])
	return b
}

func (sig Signature) IsZero() bool { return sig == Signature{} }

func SignatureFromBytes(src []byte) (sig Signature) {
	copy(sig[:], src)
	return
}

func SignatureFromHex(s []byte) (sig Signature, err error) {
	if len(s) != SignatureSize*2 {
		return sig, hex.InvalidByteError(0)
	}
	_, err = hex.Decode(sig[:], s)
	return
}

// --- SecretKey ---

func (sk *SecretKey) Bytes() []byte { return sk[:] }

func (sk SecretKey) Copy() []byte {
	b := []byte{:SecretKeySize}
	copy(b, sk[:])
	return b
}

func (sk SecretKey) Hex() []byte {
	b := []byte{:SecretKeySize*2}
	hex.Encode(b, sk[:])
	return b
}

func (sk SecretKey) IsZero() bool { return sk == SecretKey{} }

func SecretKeyFromBytes(src []byte) (sk SecretKey) {
	copy(sk[:], src)
	return
}

func SecretKeyFromHex(s []byte) (sk SecretKey, err error) {
	if len(s) != SecretKeySize*2 {
		return sk, hex.InvalidByteError(0)
	}
	_, err = hex.Decode(sk[:], s)
	return
}

func (sk *SecretKey) Zero() {
	for i := range sk {
		sk[i] = 0
	}
}