package auth

import (
	"context"
	"crypto/hmac"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"
)

func TestPKCEChallengeRFC7636(t *testing.T) {
	got := PKCEChallenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk")
	if got != "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" {
		t.Fatal(got)
	}
}

type tokenHarness struct {
	client   *Entra
	key      *rsa.PrivateKey
	kid      string
	nonce    string
	verifier string
	close    func()
}

func newTokenHarness(t *testing.T) *tokenHarness {
	t.Helper()
	key, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		t.Fatal(err)
	}
	kid := "test-key-1"
	tenant := "00000000-0000-0000-0000-000000000099"
	clientID := "11111111-1111-1111-1111-111111111199"
	oid := "22222222-2222-2222-2222-222222222299"
	nonce := "nonce-abc"
	verifier, err := NewPKCEVerifier()
	if err != nil {
		t.Fatal(err)
	}
	mux := http.NewServeMux()
	srv := httptest.NewServer(mux)
	issuer := srv.URL
	mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
		_ = json.NewEncoder(w).Encode(map[string]string{
			"issuer":                 issuer,
			"authorization_endpoint": issuer + "/authorize",
			"token_endpoint":         issuer + "/token",
			"jwks_uri":               issuer + "/jwks",
		})
	})
	mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
		_ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
	})
	mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
		_ = r.ParseForm()
		if r.Form.Get("code_verifier") != verifier {
			http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
			return
		}
		tok, err := signIDToken(key, kid, validTokenClaims(issuer, nonce, tenant, clientID, oid))
		if err != nil {
			http.Error(w, err.Error(), 500)
			return
		}
		_ = json.NewEncoder(w).Encode(map[string]any{"access_token": "entra-access", "id_token": tok, "expires_in": 3600})
	})
	client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
	client.HTTP = srv.Client()
	return &tokenHarness{client: client, key: key, kid: kid, nonce: nonce, verifier: verifier, close: srv.Close}
}

func validTokenClaims(issuer, nonce, tenant, clientID, oid string) map[string]any {
	now := time.Now()
	return map[string]any{
		"iss": issuer, "aud": clientID, "exp": now.Add(time.Hour).Unix(),
		"iat": now.Unix(), "nbf": now.Add(-time.Minute).Unix(),
		"nonce": nonce, "oid": oid, "sub": oid, "tid": tenant,
		"preferred_username": "ada@contoso.example",
	}
}

func signIDTokenAlg(alg, kid string, claims map[string]any, signer func(signing string) (string, error)) (string, error) {
	hdr, err := json.Marshal(map[string]string{"alg": alg, "typ": "JWT", "kid": kid})
	if err != nil {
		return "", err
	}
	payload, err := json.Marshal(claims)
	if err != nil {
		return "", err
	}
	h := base64.RawURLEncoding.EncodeToString(hdr)
	p := base64.RawURLEncoding.EncodeToString(payload)
	signing := h + "." + p
	if signer == nil {
		return signing + ".", nil
	}
	sig, err := signer(signing)
	if err != nil {
		return "", err
	}
	return signing + "." + sig, nil
}

func TestEntraRequiresPKCE(t *testing.T) {
	h := newTokenHarness(t)
	defer h.close()
	if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, ""); err == nil || !strings.Contains(err.Error(), "PKCE") {
		t.Fatalf("lege verifier: %v", err)
	}
	if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, "andere-verifier"); err == nil {
		t.Fatal("verkeerde verifier moest falen")
	}
	if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, h.verifier); err != nil {
		t.Fatal(err)
	}
}

func TestEntraRejectsForeignEndpointHost(t *testing.T) {
	mux := http.NewServeMux()
	srv := httptest.NewServer(mux)
	defer srv.Close()
	mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
		_ = json.NewEncoder(w).Encode(map[string]string{
			"issuer":                 srv.URL,
			"authorization_endpoint": srv.URL + "/authorize",
			"token_endpoint":         srv.URL + "/token",
			"jwks_uri":               "https://evil.example/jwks",
		})
	})
	client := NewEntra(srv.URL, "t", "c", "s", "")
	client.HTTP = srv.Client()
	err := client.ensureDiscovery(context.Background())
	if err == nil || !strings.Contains(err.Error(), "host") {
		t.Fatalf("vreemde jwks-host moest falen, kreeg %v", err)
	}
}

func TestEntraIDTokenChecks(t *testing.T) {
	h := newTokenHarness(t)
	defer h.close()
	if err := h.client.ensureDiscovery(context.Background()); err != nil {
		t.Fatal(err)
	}
	tenant := h.client.TenantID
	clientID := h.client.ClientID
	oid := "22222222-2222-2222-2222-222222222299"
	issuer := h.client.Issuer
	nonce := h.nonce

	mustOK := func(t *testing.T, claims map[string]any) {
		t.Helper()
		tok, err := signIDToken(h.key, h.kid, claims)
		if err != nil {
			t.Fatal(err)
		}
		if _, err := h.client.verifyIDToken(context.Background(), tok, nonce); err != nil {
			t.Fatal(err)
		}
	}
	mustErr := func(t *testing.T, tok, sub string) {
		t.Helper()
		_, err := h.client.verifyIDToken(context.Background(), tok, nonce)
		if err == nil || (sub != "" && !strings.Contains(err.Error(), sub)) {
			t.Fatalf("verwacht %q, kreeg %v", sub, err)
		}
	}

	t.Run("ok", func(t *testing.T) { mustOK(t, validTokenClaims(issuer, nonce, tenant, clientID, oid)) })

	t.Run("verlopen", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["exp"] = time.Now().Add(-2 * time.Minute).Unix()
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "verlopen")
	})
	t.Run("geen exp", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		delete(c, "exp")
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "exp")
	})
	t.Run("klokverschuiving exp", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["exp"] = time.Now().Add(-30 * time.Second).Unix()
		mustOK(t, c)
	})
	t.Run("geen tid", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		delete(c, "tid")
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "tenant")
	})
	t.Run("verkeerde tid", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["tid"] = "andere-tenant"
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "tenant")
	})
	t.Run("tid hoofdletters", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["tid"] = strings.ToUpper(tenant)
		mustOK(t, c)
	})
	t.Run("verkeerde issuer", func(t *testing.T) {
		c := validTokenClaims("https://evil.example/t/v2.0", nonce, tenant, clientID, oid)
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "issuer")
	})
	t.Run("slechte handtekening", func(t *testing.T) {
		tok, err := signIDToken(h.key, h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid))
		if err != nil {
			t.Fatal(err)
		}
		tok = tok[:len(tok)-4] + "AAAA"
		mustErr(t, tok, "handtekening")
	})
	t.Run("alg none", func(t *testing.T) {
		tok, err := signIDTokenAlg("none", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), nil)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "algorithme")
	})
	t.Run("alg HS256", func(t *testing.T) {
		tok, err := signIDTokenAlg("HS256", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), func(signing string) (string, error) {
			mac := hmac.New(sha256.New, []byte("geheim"))
			_, _ = mac.Write([]byte(signing))
			return base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
		})
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "algorithme")
	})
	t.Run("nbf toekomst", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["nbf"] = time.Now().Add(2 * time.Minute).Unix()
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "geldig")
	})
	t.Run("iat toekomst", func(t *testing.T) {
		c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
		c["iat"] = time.Now().Add(2 * time.Minute).Unix()
		tok, err := signIDToken(h.key, h.kid, c)
		if err != nil {
			t.Fatal(err)
		}
		mustErr(t, tok, "iat")
	})
}
