package pwpolicy

import (
	"context"
	"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"
)

// Akzeptanzkriterium 1 + Pruefung 1: zu kurzes/zu einfaches Passwort abgelehnt.
func TestValidate_RejectsTooShortOrSimple(t *testing.T) {
	policy := DefaultPolicy()

	if err := Validate(policy, "kurz1A"); !errors.Is(err, ErrPasswordTooWeak) {
		t.Fatalf("erwartet ErrPasswordTooWeak fuer zu kurzes passwort, habe %v", err)
	}
	if err := Validate(policy, "alleskleingeschriebenundlang123"); !errors.Is(err, ErrPasswordTooWeak) {
		t.Fatalf("erwartet ErrPasswordTooWeak ohne grossbuchstaben, habe %v", err)
	}
	if err := Validate(policy, "GutesPasswort2026!"); err != nil {
		t.Fatalf("erwartet gueltig, habe %v", err)
	}
}

// Akzeptanzkriterium 2 + Pruefung 2: Passwort aus Sperrliste abgelehnt.
func TestValidate_RejectsBlocklistedPassword(t *testing.T) {
	policy := Policy{MinLength: 4} // absichtlich schwach, damit NUR die sperrliste greift

	if err := Validate(policy, "password"); !errors.Is(err, ErrPasswordTooWeak) {
		t.Fatalf("erwartet ErrPasswordTooWeak fuer sperrlisten-passwort, habe %v", err)
	}
	if err := Validate(policy, "PASSWORD"); !errors.Is(err, ErrPasswordTooWeak) {
		t.Fatalf("erwartet case-insensitive treffer auf der sperrliste, habe %v", err)
	}
	if err := Validate(policy, "ein-eher-unueblicher-satz"); err != nil {
		t.Fatalf("nicht-sperrlisten-passwort sollte hier gueltig sein: %v", err)
	}
}

func setupTest(t *testing.T) (*Store, *pgxpool.Pool, 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 password_policy (
			id BOOLEAN PRIMARY KEY DEFAULT true CHECK (id), min_length INT NOT NULL DEFAULT 12,
			require_upper BOOLEAN NOT NULL DEFAULT true, require_lower BOOLEAN NOT NULL DEFAULT true,
			require_digit BOOLEAN NOT NULL DEFAULT true, require_special BOOLEAN NOT NULL DEFAULT false,
			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
	`); err != nil {
		t.Fatalf("schema: %v", err)
	}

	// Singleton-Tabelle: vor jedem Test leeren, falls ein vorheriger Lauf
	// (in dieser geteilten Registry-Tabelle) eine Zeile hinterlassen hat.
	if _, err := pool.Exec(ctx, `DELETE FROM password_policy`); err != nil {
		t.Fatalf("vorab-bereinigung: %v", err)
	}

	cleanup := func() {
		_, _ = pool.Exec(ctx, `DELETE FROM password_policy`)
		pool.Close()
	}
	return NewStore(pool), pool, cleanup
}

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

	got, err := store.Get(ctx)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got != DefaultPolicy() {
		t.Fatalf("erwartet default policy, habe %+v", got)
	}
}

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

	custom := Policy{MinLength: 16, RequireUpper: true, RequireLower: true, RequireDigit: true, RequireSpecial: true}
	if err := store.Set(ctx, custom); err != nil {
		t.Fatalf("set: %v", err)
	}
	got, err := store.Get(ctx)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got != custom {
		t.Fatalf("erwartet %+v, habe %+v", custom, got)
	}
}

// Akzeptanzkriterium 3 + Pruefung 3: bestehender Nutzer mit altem,
// nicht-konformem Passwort kann sich noch einloggen, wird aber zur
// Aenderung aufgefordert — kein rueckwirkendes Aussperren.
func TestLoginAndCheckPolicy_FlagsNonConformantExistingPassword(t *testing.T) {
	store, pool, cleanup := setupTest(t)
	defer cleanup()
	ctx := context.Background()

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

	// Altes Passwort, das VOR der heutigen Richtlinie gesetzt wurde — erfuellt
	// die aktuelle DefaultPolicy() nicht (kein Grossbuchstabe, zu kurz).
	oldPassword := "altespasswort"
	hash, err := auth.HashPassword(oldPassword)
	if err != nil {
		t.Fatalf("hash: %v", err)
	}
	if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil {
		t.Fatalf("set password hash: %v", err)
	}

	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
	loginService := auth.NewLoginService(userStore, issuer, "acme")

	token, mustChange, err := LoginAndCheckPolicy(ctx, store, loginService, email, oldPassword)
	if err != nil {
		t.Fatalf("login sollte trotz schwachem altpasswort gelingen: %v", err)
	}
	if token == "" {
		t.Fatal("erwartet gueltiges token")
	}
	if !mustChange {
		t.Fatal("erwartet mustChangePassword=true fuer nicht-konformes altpasswort")
	}

	// Konformes Passwort -> kein Aenderungszwang.
	strongPassword := "EinStarkesPasswort2026!"
	hash2, err := auth.HashPassword(strongPassword)
	if err != nil {
		t.Fatalf("hash 2: %v", err)
	}
	if err := userStore.SetPasswordHash(ctx, u.ID, hash2); err != nil {
		t.Fatalf("set password hash 2: %v", err)
	}
	_, mustChange, err = LoginAndCheckPolicy(ctx, store, loginService, email, strongPassword)
	if err != nil {
		t.Fatalf("login mit starkem passwort: %v", err)
	}
	if mustChange {
		t.Fatal("erwartet mustChangePassword=false fuer konformes passwort")
	}
}