package auth

import (
	"context"
	"crypto"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"encoding/json"
	"fmt"
	"io"
	"math/big"
	"net/http"
	"strings"
	"sync"
	"time"
)

type jwtHeader struct {
	Alg string `json:"alg"`
	Kid string `json:"kid"`
	Typ string `json:"typ"`
}

// jsonAudience accepteert "aud" als string of als array.
type jsonAudience []string

func (a *jsonAudience) UnmarshalJSON(b []byte) error {
	var one string
	if err := json.Unmarshal(b, &one); err == nil {
		*a = []string{one}
		return nil
	}
	var many []string
	if err := json.Unmarshal(b, &many); err != nil {
		return err
	}
	*a = many
	return nil
}

func (a jsonAudience) includes(want string) bool {
	for _, v := range a {
		if v == want {
			return true
		}
	}
	return false
}

func parseJWT(raw string) (jwtHeader, []byte, error) {
	parts := strings.Split(raw, ".")
	if len(parts) != 3 {
		return jwtHeader{}, nil, fmt.Errorf("auth: ongeldig jwt")
	}
	hb, err := b64url(parts[0])
	if err != nil {
		return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err)
	}
	var hdr jwtHeader
	if err := json.Unmarshal(hb, &hdr); err != nil {
		return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err)
	}
	pb, err := b64url(parts[1])
	if err != nil {
		return jwtHeader{}, nil, fmt.Errorf("auth: jwt-payload: %w", err)
	}
	return hdr, pb, nil
}

func verifyRS256(raw string, key any) error {
	pub, ok := key.(*rsa.PublicKey)
	if !ok || pub == nil {
		return fmt.Errorf("auth: geen rsa-sleutel")
	}
	parts := strings.Split(raw, ".")
	if len(parts) != 3 {
		return fmt.Errorf("auth: ongeldig jwt")
	}
	sig, err := b64url(parts[2])
	if err != nil {
		return fmt.Errorf("auth: jwt-handtekening: %w", err)
	}
	sum := sha256.Sum256([]byte(parts[0] + "." + parts[1]))
	if err := rsa.VerifyPKCS1v15(pub, crypto.SHA256, sum[:], sig); err != nil {
		return fmt.Errorf("auth: jwt-handtekening ongeldig")
	}
	return nil
}

func b64url(s string) ([]byte, error) {
	return base64.RawURLEncoding.DecodeString(s)
}

type jwksCache struct {
	mu      sync.Mutex
	fetched time.Time
	keys    map[string]*rsa.PublicKey
	uri     string
}

func (c *jwksCache) key(ctx context.Context, httpc *http.Client, uri, kid string) (*rsa.PublicKey, error) {
	c.mu.Lock()
	if k := c.keys[kid]; k != nil && c.uri == uri && time.Since(c.fetched) < time.Hour {
		c.mu.Unlock()
		return k, nil
	}
	c.mu.Unlock()
	if err := c.refresh(ctx, httpc, uri); err != nil {
		return nil, err
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	k := c.keys[kid]
	if k == nil {
		return nil, fmt.Errorf("auth: jwks-sleutel %q ontbreekt", kid)
	}
	return k, nil
}

func (c *jwksCache) refresh(ctx context.Context, httpc *http.Client, uri string) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil)
	if err != nil {
		return err
	}
	res, err := httpc.Do(req)
	if err != nil {
		return fmt.Errorf("auth: jwks: %w", err)
	}
	defer res.Body.Close()
	raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
	if err != nil {
		return err
	}
	if res.StatusCode >= 400 {
		return fmt.Errorf("auth: jwks %s", res.Status)
	}
	var doc struct {
		Keys []jwk `json:"keys"`
	}
	if err := json.Unmarshal(raw, &doc); err != nil {
		return fmt.Errorf("auth: jwks: %w", err)
	}
	keys := make(map[string]*rsa.PublicKey, len(doc.Keys))
	for _, k := range doc.Keys {
		if k.Kty != "RSA" || k.Kid == "" || k.N == "" || k.E == "" {
			continue
		}
		pub, err := k.rsaPublic()
		if err != nil {
			continue
		}
		keys[k.Kid] = pub
	}
	if len(keys) == 0 {
		return fmt.Errorf("auth: jwks zonder bruikbare sleutels")
	}
	c.mu.Lock()
	c.keys = keys
	c.uri = uri
	c.fetched = time.Now()
	c.mu.Unlock()
	return nil
}

type jwk struct {
	Kty string `json:"kty"`
	Kid string `json:"kid"`
	N   string `json:"n"`
	E   string `json:"e"`
	Use string `json:"use"`
	Alg string `json:"alg"`
}

func (k jwk) rsaPublic() (*rsa.PublicKey, error) {
	nb, err := b64url(k.N)
	if err != nil {
		return nil, err
	}
	eb, err := b64url(k.E)
	if err != nil {
		return nil, err
	}
	var e int
	if len(eb) < 8 {
		pad := make([]byte, 8-len(eb))
		eb = append(pad, eb...)
	}
	e = int(binary.BigEndian.Uint64(eb[len(eb)-8:]))
	if e <= 0 {
		return nil, fmt.Errorf("ongeldige exponent")
	}
	return &rsa.PublicKey{N: new(big.Int).SetBytes(nb), E: e}, nil
}
