package account

import (
	"bytes"
	"context"
	"crypto/sha512"
	"errors"
	"math/big"
	"testing"
	"time"

	"golang.org/x/crypto/pbkdf2"

	"telesrv/internal/domain"
	"telesrv/internal/store/memory"
)

func TestPasswordSRPRoundTrip(t *testing.T) {
	ctx := context.Background()
	const userID int64 = 1001
	svc := NewService(memory.NewPasswordStore())

	initial, err := svc.GetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("GetPassword initial: %v", err)
	}
	algo := initial.NewAlgo
	algo.Salt1 = append(append([]byte(nil), algo.Salt1...), bytes.Repeat([]byte{0xA5}, 32)...)
	input := domain.PasswordInputSettings{
		NewAlgo:         &algo,
		NewPasswordHash: verifierForPassword(algo, []byte("correct horse")),
		Hint:            "horse",
		HasHint:         true,
		Email:           "alice@example.com",
		HasEmail:        true,
	}
	if err := svc.UpdatePasswordSettings(ctx, userID, domain.PasswordCheck{Empty: true}, input); err != nil {
		t.Fatalf("UpdatePasswordSettings set password: %v", err)
	}

	challenge, err := svc.GetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("GetPassword challenge: %v", err)
	}
	if !challenge.HasPassword || challenge.SRPID == 0 || len(challenge.SRPB) == 0 {
		t.Fatalf("challenge = %+v, want srp password challenge", challenge)
	}
	check := clientPasswordCheck(t, challenge, []byte("correct horse"))
	if err := svc.CheckPassword(ctx, userID, check); err != nil {
		t.Fatalf("CheckPassword valid SRP: %v", err)
	}

	private, err := svc.GetPasswordSettings(ctx, userID, check)
	if err != nil {
		t.Fatalf("GetPasswordSettings valid SRP: %v", err)
	}
	if private.Email != "alice@example.com" {
		t.Fatalf("private email = %q, want alice@example.com", private.Email)
	}

	bad := check
	bad.M1 = append([]byte(nil), check.M1...)
	bad.M1[0] ^= 0xFF
	if err := svc.CheckPassword(ctx, userID, bad); !errors.Is(err, domain.ErrPasswordHashInvalid) {
		t.Fatalf("CheckPassword bad M1 err = %v, want ErrPasswordHashInvalid", err)
	}
}

func TestRecoverPasswordClearsTwoFactorPassword(t *testing.T) {
	ctx := context.Background()
	const userID int64 = 1002
	svc := NewService(memory.NewPasswordStore())

	initial, err := svc.GetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("GetPassword initial: %v", err)
	}
	algo := initial.NewAlgo
	algo.Salt1 = append(append([]byte(nil), algo.Salt1...), bytes.Repeat([]byte{0x5C}, 32)...)
	if err := svc.UpdatePasswordSettings(ctx, userID, domain.PasswordCheck{Empty: true}, domain.PasswordInputSettings{
		NewAlgo:         &algo,
		NewPasswordHash: verifierForPassword(algo, []byte("old password")),
		Email:           "bob@example.com",
		HasEmail:        true,
	}); err != nil {
		t.Fatalf("UpdatePasswordSettings set password: %v", err)
	}

	pattern, err := svc.RequestPasswordRecovery(ctx, userID)
	if err != nil {
		t.Fatalf("RequestPasswordRecovery: %v", err)
	}
	if pattern != "b***b@example.com" {
		t.Fatalf("recovery pattern = %q, want masked email", pattern)
	}
	if err := svc.RecoverPassword(ctx, userID, recoveryCode, nil); err != nil {
		t.Fatalf("RecoverPassword clear: %v", err)
	}
	cleared, err := svc.GetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("GetPassword cleared: %v", err)
	}
	if cleared.HasPassword || cleared.HasRecovery {
		t.Fatalf("cleared settings = %+v, want no password/recovery", cleared)
	}
}

func TestResetPasswordWaitAndDecline(t *testing.T) {
	ctx := context.Background()
	const userID int64 = 1003
	passwords := memory.NewPasswordStore()
	svc := NewService(passwords)

	if err := passwords.Save(ctx, userID, domain.PasswordSettings{HasPassword: true}); err != nil {
		t.Fatalf("save password settings: %v", err)
	}
	result, err := svc.ResetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("ResetPassword request: %v", err)
	}
	if result.Kind != domain.PasswordResetRequestedWait || result.UntilDate <= int(time.Now().Unix()) {
		t.Fatalf("reset result = %+v, want requested future wait", result)
	}
	pending, _, err := passwords.GetByUser(ctx, userID)
	if err != nil || pending.PendingResetDate != result.UntilDate {
		t.Fatalf("pending reset = %+v found err=%v, want until date", pending, err)
	}

	if err := svc.DeclinePasswordReset(ctx, userID); err != nil {
		t.Fatalf("DeclinePasswordReset: %v", err)
	}
	declined, _, err := passwords.GetByUser(ctx, userID)
	if err != nil || declined.PendingResetDate != 0 {
		t.Fatalf("declined settings = %+v err=%v, want no pending reset", declined, err)
	}

	declined.PendingResetDate = int(time.Now().Add(-time.Second).Unix())
	if err := passwords.Save(ctx, userID, declined); err != nil {
		t.Fatalf("save expired reset: %v", err)
	}
	result, err = svc.ResetPassword(ctx, userID)
	if err != nil {
		t.Fatalf("ResetPassword finalize: %v", err)
	}
	if result.Kind != domain.PasswordResetOK {
		t.Fatalf("final reset result = %+v, want ok", result)
	}
	cleared, _, err := passwords.GetByUser(ctx, userID)
	if err != nil || cleared.HasPassword || cleared.PendingResetDate != 0 {
		t.Fatalf("cleared settings = %+v err=%v, want password cleared", cleared, err)
	}
}

func clientPasswordCheck(t *testing.T, settings domain.PasswordSettings, password []byte) domain.PasswordCheck {
	t.Helper()
	algo := settings.NewAlgo
	if settings.CurrentAlgo != nil {
		algo = *settings.CurrentAlgo
	}
	p := new(big.Int).SetBytes(algo.P)
	g := big.NewInt(int64(algo.G))
	a := new(big.Int).SetBytes(bytes.Repeat([]byte{0x23}, passwordHashSize))
	A := new(big.Int).Exp(g, a, p)
	aForHash := padToHash(A.Bytes())
	bForHash := padToHash(settings.SRPB)
	x := new(big.Int).SetBytes(passwordDigest(algo, password))
	u := new(big.Int).SetBytes(hashBytes(aForHash, bForHash))
	k := new(big.Int).SetBytes(hashBytes(padToHash(algo.P), padToHash(g.Bytes())))
	gx := new(big.Int).Exp(g, x, p)
	kgx := new(big.Int).Mul(k, gx)
	kgx.Mod(kgx, p)
	b := new(big.Int).SetBytes(settings.SRPB)
	base := new(big.Int).Sub(b, kgx)
	base.Mod(base, p)
	exp := new(big.Int).Mul(u, x)
	exp.Add(exp, a)
	s := new(big.Int).Exp(base, exp, p)
	kBytes := hashBytes(padToHash(s.Bytes()))
	m1 := hashBytes(
		xorBytes(hashBytes(padToHash(algo.P)), hashBytes(padToHash(g.Bytes()))),
		hashBytes(algo.Salt1),
		hashBytes(algo.Salt2),
		aForHash,
		bForHash,
		kBytes,
	)
	return domain.PasswordCheck{SRPID: settings.SRPID, A: aForHash, M1: m1}
}

// passwordDigest 与 verifierForPassword 是客户端侧（明文口令 → verifier）的模拟助手，
// 服务端从不执行明文口令路径，仅供这里的客户端 SRP helper 构造测试输入。
func passwordDigest(algo domain.PasswordKDFAlgo, password []byte) []byte {
	hash1 := hashBytes(algo.Salt1, password, algo.Salt1)
	hash2 := hashBytes(algo.Salt2, hash1, algo.Salt2)
	hash3 := pbkdf2.Key(hash2, algo.Salt1, 100000, 64, sha512.New)
	return hashBytes(algo.Salt2, hash3, algo.Salt2)
}

func verifierForPassword(algo domain.PasswordKDFAlgo, password []byte) []byte {
	p := new(big.Int).SetBytes(algo.P)
	g := big.NewInt(int64(algo.G))
	x := new(big.Int).SetBytes(passwordDigest(algo, password))
	return padToHash(new(big.Int).Exp(g, x, p).Bytes())
}