package service

import (
	"testing"
	"time"
)

// TestTokenService_Constants 测试Token服务相关常量
func TestTokenService_Constants(t *testing.T) {
	if ExtendedTimeout != 10*time.Second {
		t.Errorf("ExtendedTimeout = %v, want 10 seconds", ExtendedTimeout)
	}

	if TokensMaxCount != 10 {
		t.Errorf("TokensMaxCount = %d, want 10", TokensMaxCount)
	}
}

// TestTokenService_Timeout 测试超时常量
func TestTokenService_Timeout(t *testing.T) {
	if DefaultTimeout != 5*time.Second {
		t.Errorf("DefaultTimeout = %v, want 5 seconds", DefaultTimeout)
	}

	if ExtendedTimeout <= DefaultTimeout {
		t.Errorf("ExtendedTimeout (%v) should be greater than DefaultTimeout (%v)", ExtendedTimeout, DefaultTimeout)
	}
}

// TestTokenService_Validation 测试Token验证逻辑
func TestTokenService_Validation(t *testing.T) {
	tests := []struct {
		name        string
		accessToken string
		wantValid   bool
	}{
		{
			name:        "空token无效",
			accessToken: "",
			wantValid:   false,
		},
		{
			name:        "非空token可能有效",
			accessToken: "valid-token-string",
			wantValid:   true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// 测试空token检查逻辑
			isValid := tt.accessToken != ""
			if isValid != tt.wantValid {
				t.Errorf("Token validation failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestTokenService_ClientTokenLogic 测试ClientToken逻辑
func TestTokenService_ClientTokenLogic(t *testing.T) {
	tests := []struct {
		name           string
		clientToken    string
		shouldGenerate bool
	}{
		{
			name:           "空的clientToken应该生成新的",
			clientToken:    "",
			shouldGenerate: true,
		},
		{
			name:           "非空的clientToken应该使用提供的",
			clientToken:    "existing-client-token",
			shouldGenerate: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			shouldGenerate := tt.clientToken == ""
			if shouldGenerate != tt.shouldGenerate {
				t.Errorf("ClientToken logic failed: got %v, want %v", shouldGenerate, tt.shouldGenerate)
			}
		})
	}
}

// TestTokenService_ProfileSelection 测试Profile选择逻辑
func TestTokenService_ProfileSelection(t *testing.T) {
	tests := []struct {
		name             string
		profileCount     int
		shouldAutoSelect bool
	}{
		{
			name:             "只有一个profile时自动选择",
			profileCount:     1,
			shouldAutoSelect: true,
		},
		{
			name:             "多个profile时不自动选择",
			profileCount:     2,
			shouldAutoSelect: false,
		},
		{
			name:             "没有profile时不自动选择",
			profileCount:     0,
			shouldAutoSelect: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			shouldAutoSelect := tt.profileCount == 1
			if shouldAutoSelect != tt.shouldAutoSelect {
				t.Errorf("Profile selection logic failed: got %v, want %v", shouldAutoSelect, tt.shouldAutoSelect)
			}
		})
	}
}

// TestTokenService_CleanupLogic 测试清理逻辑
func TestTokenService_CleanupLogic(t *testing.T) {
	tests := []struct {
		name          string
		tokenCount    int
		maxCount      int
		shouldCleanup bool
		cleanupCount  int
	}{
		{
			name:          "token数量未超过上限，不需要清理",
			tokenCount:    5,
			maxCount:      10,
			shouldCleanup: false,
			cleanupCount:  0,
		},
		{
			name:          "token数量超过上限，需要清理",
			tokenCount:    15,
			maxCount:      10,
			shouldCleanup: true,
			cleanupCount:  5,
		},
		{
			name:          "token数量等于上限，不需要清理",
			tokenCount:    10,
			maxCount:      10,
			shouldCleanup: false,
			cleanupCount:  0,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			shouldCleanup := tt.tokenCount > tt.maxCount
			if shouldCleanup != tt.shouldCleanup {
				t.Errorf("Cleanup decision failed: got %v, want %v", shouldCleanup, tt.shouldCleanup)
			}

			if shouldCleanup {
				expectedCleanupCount := tt.tokenCount - tt.maxCount
				if expectedCleanupCount != tt.cleanupCount {
					t.Errorf("Cleanup count failed: got %d, want %d", expectedCleanupCount, tt.cleanupCount)
				}
			}
		})
	}
}

// TestTokenService_UserIDValidation 测试UserID验证
func TestTokenService_UserIDValidation(t *testing.T) {
	tests := []struct {
		name    string
		userID  int64
		isValid bool
	}{
		{
			name:    "有效的UserID",
			userID:  1,
			isValid: true,
		},
		{
			name:    "UserID为0时无效",
			userID:  0,
			isValid: false,
		},
		{
			name:    "负数UserID无效",
			userID:  -1,
			isValid: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := tt.userID > 0
			if isValid != tt.isValid {
				t.Errorf("UserID validation failed: got %v, want %v", isValid, tt.isValid)
			}
		})
	}
}