package auth

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

func TestStableAuthID(t *testing.T) {
	a := StableAuthID("tenant-a", "oid-1")
	b := StableAuthID("tenant-a", "oid-1")
	c := StableAuthID("tenant-a", "oid-2")
	if a <= 0 || a != b || a == c {
		t.Fatalf("%d %d %d", a, b, c)
	}
}

func TestEntraUsername(t *testing.T) {
	u, err := entraUsername("Ada.Lovelace@contoso.example", "", "", "oid")
	if err != nil || u != "ada-lovelace" {
		t.Fatalf("%q %v", u, err)
	}
	u, err = entraUsername("", "", "!!!", "deadbeef-oid")
	if err != nil || !strings.HasPrefix(u, "u") {
		t.Fatalf("%q %v", u, err)
	}
}

func TestEntraExchangeWithFakeOIDC(t *testing.T) {
	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)
	}

	var issuer string
	mux := http.NewServeMux()
	srv := httptest.NewServer(mux)
	defer srv.Close()
	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) {
		if err := r.ParseForm(); err != nil {
			t.Error(err)
		}
		if r.Form.Get("code") != "good-code" || r.Form.Get("client_id") != clientID || r.Form.Get("code_verifier") != verifier {
			http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
			return
		}
		idTok, err := signIDToken(key, kid, map[string]any{
			"iss":                issuer,
			"aud":                clientID,
			"exp":                time.Now().Add(time.Hour).Unix(),
			"nbf":                time.Now().Add(-time.Minute).Unix(),
			"nonce":              nonce,
			"oid":                oid,
			"sub":                oid,
			"tid":                tenant,
			"preferred_username": "ada@contoso.example",
			"name":               "Ada Lovelace",
		})
		if err != nil {
			t.Error(err)
			http.Error(w, err.Error(), 500)
			return
		}
		_ = json.NewEncoder(w).Encode(map[string]any{
			"access_token": "entra-access",
			"id_token":     idTok,
			"expires_in":   3600,
			"token_type":   "Bearer",
		})
	})

	client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
	client.HTTP = srv.Client()

	challenge := PKCEChallenge(verifier)
	url := client.AuthorizeURL("state-1", nonce, "https://git.example.test/auth/callback", challenge)
	if !strings.Contains(url, "/authorize?") || !strings.Contains(url, "nonce="+nonce) || !strings.Contains(url, "scope=openid+profile+email+User.Read") {
		t.Fatal(url)
	}
	if !strings.Contains(url, "code_challenge="+challenge) || !strings.Contains(url, "code_challenge_method=S256") {
		t.Fatal(url)
	}

	id, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", nonce, verifier)
	if err != nil {
		t.Fatal(err)
	}
	if id.AuthID != StableAuthID(tenant, oid) || id.Username != "ada" || id.AccessToken != "entra-access" {
		t.Fatalf("%+v", id)
	}
	if id.IsAdmin || id.AvatarURL != "" || id.ExpiresIn != 86400 {
		t.Fatalf("degradatie verwacht: %+v", id)
	}
	sec, err := client.Extend(context.Background(), id.AccessToken)
	if err != nil || sec != 86400 {
		t.Fatalf("extend %d %v", sec, err)
	}
	if err := client.Logout(context.Background(), id.AccessToken); err != nil {
		t.Fatal(err)
	}
	if _, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", "andere", verifier); err == nil {
		t.Fatal("verwacht nonce-fout")
	}
}

func TestEntraRejectsBadAudience(t *testing.T) {
	key, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		t.Fatal(err)
	}
	kid := "k1"
	mux := http.NewServeMux()
	srv := httptest.NewServer(mux)
	defer srv.Close()
	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 + "/a",
			"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) {
		tok, _ := signIDToken(key, kid, map[string]any{
			"iss": issuer, "aud": "andere-app", "exp": time.Now().Add(time.Hour).Unix(),
			"nonce": "n", "oid": "o", "sub": "o", "tid": "t",
		})
		_ = json.NewEncoder(w).Encode(map[string]any{"access_token": "x", "id_token": tok})
	})
	client := NewEntra(issuer, "t", "mijn-app", "geheim", "")
	client.HTTP = srv.Client()
	_, err = client.Exchange(context.Background(), "c", "https://cb", "n", "pkce-verifier")
	if err == nil || !strings.Contains(err.Error(), "audience") {
		t.Fatalf("verwacht audience-fout, kreeg %v", err)
	}
}

func testJWK(key *rsa.PrivateKey, kid string) map[string]string {
	n := base64.RawURLEncoding.EncodeToString(key.N.Bytes())
	eb := make([]byte, 8)
	binary.BigEndian.PutUint64(eb, uint64(key.E))
	for len(eb) > 1 && eb[0] == 0 {
		eb = eb[1:]
	}
	return map[string]string{
		"kty": "RSA", "kid": kid, "use": "sig", "alg": "RS256",
		"n": n, "e": base64.RawURLEncoding.EncodeToString(eb),
	}
}

func signIDToken(key *rsa.PrivateKey, kid string, claims map[string]any) (string, error) {
	hdr, err := json.Marshal(map[string]string{"alg": "RS256", "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
	sum := sha256.Sum256([]byte(signing))
	sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, sum[:])
	if err != nil {
		return "", err
	}
	return signing + "." + base64.RawURLEncoding.EncodeToString(sig), nil
}
