package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"

	"git.x2erp.com/qdy/go-base/sdk/configure"
)

func main() {
	fmt.Println("=== 演示登录功能测试 ===")

	// 配置服务地址
	configureURL := "http://localhost:8080"
	svcCodeURL := "http://localhost:8020"

	fmt.Printf("配置中心地址: %s\n", configureURL)
	fmt.Printf("svc-code地址: %s\n", svcCodeURL)

	// 测试凭证
	userID := "test-user-001"
	password := "password123"

	fmt.Printf("\n使用测试用户: %s\n", userID)

	// 1. 直接使用SDK登录配置中心
	fmt.Println("\n--- 方法1: 直接使用SDK登录配置中心 ---")
	token1, err := loginWithSDK(configureURL, userID, password)
	if err != nil {
		fmt.Printf("SDK登录失败: %v\n", err)
	} else {
		fmt.Printf("✅ SDK登录成功!\n")
		fmt.Printf("Token (前100字符): %s...\n", token1[:min(100, len(token1))])
		fmt.Printf("Token长度: %d 字符\n", len(token1))

		// 验证token
		if err := validateTokenWithSDK(configureURL, token1); err != nil {
			fmt.Printf("Token验证失败: %v\n", err)
		} else {
			fmt.Printf("✅ Token验证通过\n")
		}
	}

	// 2. 通过svc-code API登录
	fmt.Println("\n--- 方法2: 通过svc-code API登录 ---")
	token2, err := loginWithAPI(svcCodeURL, userID, password)
	if err != nil {
		fmt.Printf("API登录失败: %v\n", err)
	} else {
		fmt.Printf("✅ API登录成功!\n")
		fmt.Printf("Token (前100字符): %s...\n", token2[:min(100, len(token2))])
		fmt.Printf("Token长度: %d 字符\n", len(token2))

		// 比较两个token是否相同
		if token1 != "" && token2 != "" {
			if token1 == token2 {
				fmt.Printf("✅ 两个方法返回的Token相同\n")
			} else {
				fmt.Printf("⚠️  两个方法返回的Token不同（可能是不同的JWT有效期）\n")
			}
		}
	}

	// 3. 测试无效凭证
	fmt.Println("\n--- 测试无效凭证 ---")
	testInvalidCredentials(svcCodeURL)

	fmt.Println("\n=== 测试完成 ===")
}

// loginWithSDK 使用SDK直接登录配置中心
func loginWithSDK(configureURL, userID, password string) (string, error) {
	// 创建SDK客户端
	client, err := configure.NewBasicAuthClient(configureURL, "test", "test")
	if err != nil {
		return "", fmt.Errorf("创建SDK客户端失败: %w", err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	req := &configure.UserLoginRequest{
		UserID:   userID,
		Password: password,
	}

	startTime := time.Now()
	token, err := client.LoginUser(ctx, req)
	elapsed := time.Since(startTime)

	if err != nil {
		return "", fmt.Errorf("登录失败: %w (耗时: %v)", err, elapsed)
	}

	fmt.Printf("登录耗时: %v\n", elapsed)
	return token, nil
}

// validateTokenWithSDK 使用SDK验证token
func validateTokenWithSDK(configureURL, token string) error {
	// 使用token创建配置中心客户端
	client, err := configure.NewTokenAuthClient(configureURL, token)
	if err != nil {
		return fmt.Errorf("创建Token客户端失败: %w", err)
	}

	fmt.Printf("Token客户端创建成功，BaseURL: %s\n", client.GetConfig().BaseURL)
	return nil
}

// loginWithAPI 通过svc-code API登录
func loginWithAPI(svcCodeURL, userID, password string) (string, error) {
	client := &http.Client{
		Timeout: 30 * time.Second,
	}

	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
	loginData := map[string]string{
		"user_id":  userID,
		"password": password,
	}

	loginJSON, err := json.Marshal(loginData)
	if err != nil {
		return "", fmt.Errorf("JSON序列化失败: %w", err)
	}

	startTime := time.Now()
	req, err := http.NewRequest("POST", loginURL, bytes.NewReader(loginJSON))
	if err != nil {
		return "", fmt.Errorf("创建HTTP请求失败: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("发送登录请求失败: %w", err)
	}
	defer resp.Body.Close()

	elapsed := time.Since(startTime)
	fmt.Printf("API调用耗时: %v\n", elapsed)

	if resp.StatusCode != 200 {
		body, _ := io.ReadAll(resp.Body)
		return "", fmt.Errorf("API返回非200状态码: %d, 响应: %s", resp.StatusCode, string(body))
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("读取响应体失败: %w", err)
	}

	var result map[string]interface{}
	if err := json.Unmarshal(body, &result); err != nil {
		return "", fmt.Errorf("解析响应JSON失败: %w, 响应体: %s", err, string(body))
	}

	if !result["success"].(bool) {
		return "", fmt.Errorf("登录失败: %v", result)
	}

	token, ok := result["data"].(string)
	if !ok || token == "" {
		return "", fmt.Errorf("响应中未找到有效token: %v", result)
	}

	return token, nil
}

// testInvalidCredentials 测试无效凭证
func testInvalidCredentials(svcCodeURL string) {
	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
	invalidData := map[string]string{
		"user_id":  "invalid-user",
		"password": "wrong-password",
	}

	invalidJSON, _ := json.Marshal(invalidData)

	resp, err := client.Post(loginURL, "application/json", bytes.NewReader(invalidJSON))
	if err != nil {
		fmt.Printf("无效凭证测试失败: %v\n", err)
		return
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	var result map[string]interface{}
	json.Unmarshal(body, &result)

	if !result["success"].(bool) {
		fmt.Printf("✅ 无效凭证登录失败（预期）: %s\n", result["message"])
	} else {
		fmt.Printf("❌ 无效凭证登录不应该成功\n")
	}
}

// min 返回两个整数的最小值
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}