package csrf

import (
	"testing"
	"time"

	"dk/internal/auth"

	"github.com/valyala/fasthttp"
)

func TestGenerateToken(t *testing.T) {
	// Create a mock session
	session := &auth.Session{
		ID:        "test-session",
		UserID:    1,
		Username:  "testuser",
		Email:     "test@example.com",
		CreatedAt: time.Now(),
		ExpiresAt: time.Now().Add(time.Hour),
		LastSeen:  time.Now(),
		Data:      make(map[string]any),
	}
	
	// Create mock context
	ctx := &fasthttp.RequestCtx{}
	ctx.SetUserValue(SessionCtxKey, session)
	
	// Generate token
	token := GenerateToken(ctx, nil)
	
	if token == "" {
		t.Error("Expected non-empty token")
	}
	
	// Check that token was stored in session
	storedToken := GetStoredToken(session)
	if storedToken != token {
		t.Errorf("Expected stored token %s, got %s", token, storedToken)
	}
}

func TestValidateToken(t *testing.T) {
	// Create session with token
	session := &auth.Session{
		ID:       "test-session",
		UserID:   1,
		Username: "testuser",
		Email:    "test@example.com",
		Data:     map[string]any{SessionKey: "test-token"},
	}
	
	ctx := &fasthttp.RequestCtx{}
	ctx.SetUserValue(SessionCtxKey, session)
	
	// Valid token should pass
	if !ValidateToken(ctx, nil, "test-token") {
		t.Error("Expected valid token to pass validation")
	}
	
	// Invalid token should fail
	if ValidateToken(ctx, nil, "wrong-token") {
		t.Error("Expected invalid token to fail validation")
	}
	
	// Empty token should fail
	if ValidateToken(ctx, nil, "") {
		t.Error("Expected empty token to fail validation")
	}
}

func TestValidateTokenNoSession(t *testing.T) {
	ctx := &fasthttp.RequestCtx{}
	
	// No session should fail validation
	if ValidateToken(ctx, nil, "any-token") {
		t.Error("Expected validation to fail with no session")
	}
}

func TestHiddenField(t *testing.T) {
	session := &auth.Session{
		ID:       "test-session",
		UserID:   1,
		Username: "testuser", 
		Email:    "test@example.com",
		Data:     map[string]any{SessionKey: "test-token"},
	}
	
	ctx := &fasthttp.RequestCtx{}
	ctx.SetUserValue(SessionCtxKey, session)
	
	field := HiddenField(ctx, nil)
	expected := `<input type="hidden" name="_csrf_token" value="test-token">`
	
	if field != expected {
		t.Errorf("Expected %s, got %s", expected, field)
	}
}

func TestHiddenFieldNoSession(t *testing.T) {
	ctx := &fasthttp.RequestCtx{}
	
	field := HiddenField(ctx, nil)
	if field != "" {
		t.Errorf("Expected empty field with no session, got %s", field)
	}
}

func TestTokenMeta(t *testing.T) {
	session := &auth.Session{
		ID:       "test-session",
		UserID:   1,
		Username: "testuser",
		Email:    "test@example.com", 
		Data:     map[string]any{SessionKey: "test-token"},
	}
	
	ctx := &fasthttp.RequestCtx{}
	ctx.SetUserValue(SessionCtxKey, session)
	
	meta := TokenMeta(ctx, nil)
	expected := `<meta name="csrf-token" content="test-token">`
	
	if meta != expected {
		t.Errorf("Expected %s, got %s", expected, meta)
	}
}

func TestStoreAndGetToken(t *testing.T) {
	session := &auth.Session{
		Data: make(map[string]any),
	}
	
	token := "test-token"
	StoreToken(session, token)
	
	retrieved := GetStoredToken(session)
	if retrieved != token {
		t.Errorf("Expected %s, got %s", token, retrieved)
	}
}

func TestGetStoredTokenNoData(t *testing.T) {
	session := &auth.Session{}
	
	token := GetStoredToken(session)
	if token != "" {
		t.Errorf("Expected empty token, got %s", token)
	}
}

func TestValidateFormToken(t *testing.T) {
	session := &auth.Session{
		ID:       "test-session",
		UserID:   1,
		Username: "testuser",
		Email:    "test@example.com",
		Data:     map[string]any{SessionKey: "test-token"},
	}
	
	ctx := &fasthttp.RequestCtx{}
	ctx.SetUserValue(SessionCtxKey, session)
	
	// Set form data
	ctx.PostArgs().Set(TokenFieldName, "test-token")
	
	if !ValidateFormToken(ctx, nil) {
		t.Error("Expected form token validation to pass")
	}
	
	// Test with wrong token
	ctx.PostArgs().Set(TokenFieldName, "wrong-token")
	
	if ValidateFormToken(ctx, nil) {
		t.Error("Expected form token validation to fail with wrong token")
	}
}