package bloat

import (
	"crypto/rand"
	"fmt"

	"aead.dev/minisign"
	"filippo.io/age"
)

type BloatPlain[T any] struct {
	SignPub  minisign.PublicKey
	SignPriv minisign.PrivateKey
}
type BloatEnc[T any] struct {
	BloatPlain[T]
	EncPub  age.X25519Recipient
	EncPriv age.X25519Identity // Scrypt is the password one?
}

func NewPlainBloat[T any]() (BloatPlain[T], error) {
	pub, sign, err := minisign.GenerateKey(rand.Reader)
	if err != nil {
		fmt.Println("problem generating minisign")
		fmt.Println(err)
		return BloatPlain[T]{}, err
	}
	res := BloatPlain[T]{
		SignPub:  pub,
		SignPriv: sign,
	}
	return res, nil
}
func NewEncBloat[T any]() (BloatEnc[T], error) {
	var res BloatEnc[T]
	pubres, err := NewPlainBloat[T]()
	if err != nil {
		fmt.Println("problem generating signing part")
	}
	enc, err := age.GenerateX25519Identity()
	if err != nil {
		fmt.Println("unable to generate")
		fmt.Println(err)
		return BloatEnc[T]{}, err
	}
	res.SignPub = pubres.SignPub
	res.SignPriv = pubres.SignPriv

	res.EncPriv = *enc
	res.EncPub = *enc.Recipient()
	// fmt.Printf("made age key: %s\n", enc.Recipient().String())
	return res, nil

}
func plainFromEnc[T any](p BloatEnc[T]) BloatPlain[T] {
	var r BloatPlain[T]
	r.SignPriv = p.SignPriv
	r.SignPub = p.SignPub
	return r
}