package starcrypto

import (
	"crypto"
	"crypto/ecdsa"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"errors"
	"golang.org/x/crypto/ssh"
)

func EncodePrivateKey(private crypto.PrivateKey, secret string) ([]byte, error) {
	switch private.(type) {
	case *rsa.PrivateKey:
		return EncodeRsaPrivateKey(private.(*rsa.PrivateKey), secret)
	case *ecdsa.PrivateKey:
		return EncodeEcdsaPrivateKey(private.(*ecdsa.PrivateKey), secret)
	default:
		return nil, errors.New("private key type error")
	}
}

func EncodePublicKey(public crypto.PublicKey) ([]byte, error) {
	switch public.(type) {
	case *rsa.PublicKey:
		return EncodeRsaPublicKey(public.(*rsa.PublicKey))
	case *ecdsa.PublicKey:
		return EncodeEcdsaPublicKey(public.(*ecdsa.PublicKey))
	default:
		return nil, errors.New("public key type error")
	}
}

func DecodePrivateKey(private []byte, password string) (crypto.PrivateKey, error) {
	blk, _ := pem.Decode(private)
	if blk == nil {
		return nil, errors.New("private key error")
	}
	switch blk.Type {
	case "RSA PRIVATE KEY":
		return DecodeRsaPrivateKey(private, password)
	case "EC PRIVATE KEY":
		return DecodeEcdsaPrivateKey(private, password)
	default:
		return nil, errors.New("private key type error")
	}
}

func DecodePublicKey(pubStr []byte) (crypto.PublicKey, error) {
	blk, _ := pem.Decode(pubStr)
	if blk == nil {
		return nil, errors.New("public key error")
	}
	pub, err := x509.ParsePKIXPublicKey(blk.Bytes)
	if err != nil {
		return nil, err
	}
	return pub, nil
}

func EncodeSSHPublicKey(public crypto.PublicKey) ([]byte, error) {
	publicKey, err := ssh.NewPublicKey(public)
	if err != nil {
		return nil, err
	}
	return ssh.MarshalAuthorizedKey(publicKey), nil
}