package webauthn

import (
	"context"
	"crypto/ed25519"
	"errors"
	"fmt"
	"os"
	"testing"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
	"gitea.perlbach24.de/scripte/nexarch/internal/user"
)

func setupTest(t *testing.T) (*Store, *user.TenantUserStore, string, func()) {
	t.Helper()
	adminDSN := os.Getenv("TEST_ADMIN_DSN")
	if adminDSN == "" {
		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	ctx := context.Background()

	pool, err := pgxpool.New(ctx, adminDSN)
	if err != nil {
		t.Fatalf("pool: %v", err)
	}
	if _, err := pool.Exec(ctx, `
		CREATE TABLE IF NOT EXISTS users (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE IF NOT EXISTS webauthn_credentials (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
			device_name TEXT NOT NULL, public_key BYTEA NOT NULL, sign_count INT NOT NULL DEFAULT 0,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE IF NOT EXISTS webauthn_challenges (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL REFERENCES users(id),
			challenge TEXT NOT NULL UNIQUE, purpose TEXT NOT NULL CHECK (purpose IN ('register','login')),
			expires_at TIMESTAMPTZ NOT NULL, used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
	`); err != nil {
		t.Fatalf("schema: %v", err)
	}

	userStore := user.NewTenantUserStore(pool)
	email := fmt.Sprintf("webauthn-test-%d@example.com", time.Now().UnixNano())
	u, err := userStore.Create(ctx, email, "WebAuthn Test")
	if err != nil {
		t.Fatalf("create user: %v", err)
	}

	cleanup := func() { pool.Close() }
	return NewStore(pool), userStore, u.ID, cleanup
}

// simulateAuthenticator erzeugt ein neues Schluesselpaar und "unterschreibt"
// eine Challenge — steht fuer einen echten Hardware-/Plattform-Authenticator
// im Test (siehe Paket-Dokumentation zur vereinfachten Zeremonie).
func simulateAuthenticator(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
	t.Helper()
	pub, priv, err := ed25519.GenerateKey(nil)
	if err != nil {
		t.Fatalf("schluesselpaar erzeugen: %v", err)
	}
	return pub, priv
}

// Akzeptanzkriterium 1 + Pruefung 1: Registrierung und Anmeldung mit
// simuliertem Authenticator erfolgreich, ganz ohne Passworteingabe.
func TestRegisterAndLogin_WithoutPassword(t *testing.T) {
	store, _, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	pub, priv := simulateAuthenticator(t)

	regChallenge, err := store.BeginRegistration(ctx, userID)
	if err != nil {
		t.Fatalf("begin registration: %v", err)
	}
	sig := ed25519.Sign(priv, []byte(regChallenge))
	credentialID, err := store.FinishRegistration(ctx, userID, regChallenge, "Yubikey 1", pub, sig)
	if err != nil {
		t.Fatalf("finish registration: %v", err)
	}

	loginChallenge, err := store.BeginLogin(ctx, userID)
	if err != nil {
		t.Fatalf("begin login: %v", err)
	}
	loginSig := ed25519.Sign(priv, []byte(loginChallenge))

	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
	token, err := CompleteLogin(ctx, store, issuer, "acme", userID, loginChallenge, credentialID, loginSig)
	if err != nil {
		t.Fatalf("complete login: %v", err)
	}
	if token == "" {
		t.Fatal("erwartet nicht-leeres sitzungs-token")
	}
}

func TestFinishRegistration_RejectsWrongSignature(t *testing.T) {
	store, _, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	pub, _ := simulateAuthenticator(t)
	_, otherPriv := simulateAuthenticator(t) // falscher privater schluessel

	challenge, err := store.BeginRegistration(ctx, userID)
	if err != nil {
		t.Fatalf("begin registration: %v", err)
	}
	wrongSig := ed25519.Sign(otherPriv, []byte(challenge))

	if _, err := store.FinishRegistration(ctx, userID, challenge, "Faelscher", pub, wrongSig); !errors.Is(err, ErrSignatureInvalid) {
		t.Fatalf("erwartet ErrSignatureInvalid, habe %v", err)
	}
}

func TestChallenge_CannotBeReplayed(t *testing.T) {
	store, _, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	pub, priv := simulateAuthenticator(t)
	challenge, err := store.BeginRegistration(ctx, userID)
	if err != nil {
		t.Fatalf("begin registration: %v", err)
	}
	sig := ed25519.Sign(priv, []byte(challenge))

	if _, err := store.FinishRegistration(ctx, userID, challenge, "Geraet 1", pub, sig); err != nil {
		t.Fatalf("erste registrierung: %v", err)
	}
	if _, err := store.FinishRegistration(ctx, userID, challenge, "Geraet 2 (replay)", pub, sig); !errors.Is(err, ErrChallengeInvalid) {
		t.Fatalf("erwartet ErrChallengeInvalid bei wiederverwendeter challenge, habe %v", err)
	}
}

// Akzeptanzkriterium 2 + Pruefung 2: mehrere Authenticatoren pro Benutzer,
// beide funktionsfaehig (Geraetewechsel/-verlust).
func TestMultipleCredentials_BothWork(t *testing.T) {
	store, _, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	pub1, priv1 := simulateAuthenticator(t)
	pub2, priv2 := simulateAuthenticator(t)

	reg1, _ := store.BeginRegistration(ctx, userID)
	cred1, err := store.FinishRegistration(ctx, userID, reg1, "Laptop", pub1, ed25519.Sign(priv1, []byte(reg1)))
	if err != nil {
		t.Fatalf("register cred1: %v", err)
	}
	reg2, _ := store.BeginRegistration(ctx, userID)
	cred2, err := store.FinishRegistration(ctx, userID, reg2, "Handy", pub2, ed25519.Sign(priv2, []byte(reg2)))
	if err != nil {
		t.Fatalf("register cred2: %v", err)
	}

	creds, err := store.ListCredentials(ctx, userID)
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(creds) != 2 {
		t.Fatalf("erwartet 2 credentials, habe %d", len(creds))
	}

	// Beide Authenticatoren koennen sich unabhaengig voneinander anmelden.
	login1, _ := store.BeginLogin(ctx, userID)
	if err := store.FinishLogin(ctx, userID, login1, cred1, ed25519.Sign(priv1, []byte(login1))); err != nil {
		t.Fatalf("login mit cred1: %v", err)
	}
	login2, _ := store.BeginLogin(ctx, userID)
	if err := store.FinishLogin(ctx, userID, login2, cred2, ed25519.Sign(priv2, []byte(login2))); err != nil {
		t.Fatalf("login mit cred2: %v", err)
	}
}

// Akzeptanzkriterium 3 + Pruefung 3: Login mit Passwort+TOTP funktioniert
// weiterhin unveraendert, kein Zwang auf WebAuthn.
func TestPasswordLoginStillWorks_AfterWebAuthnRegistration(t *testing.T) {
	store, userStore, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	u, err := userStore.Get(ctx, userID)
	if err != nil {
		t.Fatalf("get user: %v", err)
	}
	hash, err := auth.HashPassword("korrektes-passwort")
	if err != nil {
		t.Fatalf("hash: %v", err)
	}
	if err := userStore.SetPasswordHash(ctx, userID, hash); err != nil {
		t.Fatalf("set password: %v", err)
	}

	// WebAuthn zusaetzlich registrieren.
	pub, priv := simulateAuthenticator(t)
	reg, _ := store.BeginRegistration(ctx, userID)
	if _, err := store.FinishRegistration(ctx, userID, reg, "Geraet", pub, ed25519.Sign(priv, []byte(reg))); err != nil {
		t.Fatalf("register: %v", err)
	}

	// Passwort-Login (IAM-02) bleibt unveraendert funktionsfaehig.
	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
	loginService := auth.NewLoginService(userStore, issuer, "acme")
	token, err := loginService.Login(ctx, u.Email, "korrektes-passwort")
	if err != nil {
		t.Fatalf("passwort-login sollte trotz registriertem webauthn weiterhin funktionieren: %v", err)
	}
	if token == "" {
		t.Fatal("erwartet gueltiges token")
	}
}

func TestBeginLogin_RejectsUserWithoutCredentials(t *testing.T) {
	store, _, userID, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

	if _, err := store.BeginLogin(ctx, userID); !errors.Is(err, ErrNoCredentials) {
		t.Fatalf("erwartet ErrNoCredentials, habe %v", err)
	}
}