package selfsigned

import (
	"bytes"
	"crypto/ecdsa"
	"crypto/ed25519"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"math/big"
	"net"
	"time"

	"forge.cadoles.com/arcad/arcast/pkg/network"
	"github.com/pkg/errors"
)

func NewLANKeyPair() ([]byte, []byte, error) {
	hosts, err := network.GetLANIPv4Addrs()
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	hosts = append(hosts, "127.0.0.1")

	rawCert, rawKey, err := NewCertKeyPair(hosts...)
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	return rawCert, rawKey, nil
}

func NewLANCert() (*tls.Certificate, error) {
	rawCert, rawKey, err := NewLANKeyPair()
	if err != nil {
		return nil, errors.WithStack(err)
	}

	cert, err := tls.X509KeyPair(rawCert, rawKey)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	return &cert, nil
}

func NewCertKeyPair(hosts ...string) ([]byte, []byte, error) {
	priv, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	keyUsage := x509.KeyUsageDigitalSignature

	notBefore := time.Now()
	notAfter := notBefore.Add(365 * 24 * time.Hour)

	template := x509.Certificate{
		SerialNumber: serialNumber,
		Subject: pkix.Name{
			Organization: []string{"Arcast Org"},
		},
		NotBefore: notBefore,
		NotAfter:  notAfter,

		KeyUsage:              keyUsage,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
		BasicConstraintsValid: true,
	}

	for _, h := range hosts {
		if ip := net.ParseIP(h); ip != nil {
			template.IPAddresses = append(template.IPAddresses, ip)
		} else {
			template.DNSNames = append(template.DNSNames, h)
		}
	}

	template.IsCA = true
	template.KeyUsage |= x509.KeyUsageCertSign

	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv)
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	var cert bytes.Buffer

	if err := pem.Encode(&cert, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
		return nil, nil, errors.WithStack(err)
	}

	var key bytes.Buffer

	privBytes, err := x509.MarshalPKCS8PrivateKey(priv)
	if err != nil {
		return nil, nil, errors.WithStack(err)
	}

	if err := pem.Encode(&key, &pem.Block{Type: "PRIVATE KEY", Bytes: privBytes}); err != nil {
		return nil, nil, errors.WithStack(err)
	}

	return cert.Bytes(), key.Bytes(), nil
}

func publicKey(priv any) any {
	switch k := priv.(type) {
	case *rsa.PrivateKey:
		return &k.PublicKey
	case *ecdsa.PrivateKey:
		return &k.PublicKey
	case ed25519.PrivateKey:
		return k.Public().(ed25519.PublicKey)
	default:
		return nil
	}
}