package core

import (
	"database/sql"
	"fmt"
	"testing"
)

// TestGetFieldValue 测试获取字段值的基本功能
func TestGetFieldValue(t *testing.T) {
	fmt.Println("\n=== 测试 getFieldValue 基本功能 ===")

	tests := []struct {
		name      string
		model     interface{}
		fieldName string
		expected  int64
	}{
		{"int 类型", &TestModelInt{ID: 123}, "ID", 123},
		{"int64 类型", &TestModelInt64{ID: 456}, "ID", 456},
		{"uint 类型", &TestModelUint{ID: 789}, "ID", 789},
		{"float 类型", &TestModelFloat{ID: 999.5}, "ID", 999},
		{"指针为 nil", (*TestModelInt)(nil), "ID", 0},
		{"model 为 nil", nil, "ID", 0},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := getFieldValue(tt.model, tt.fieldName)
			if result != tt.expected {
				t.Errorf("期望 %d, 得到 %d", tt.expected, result)
			}
		})
	}

	fmt.Println("✓ 基本功能测试通过")
}

// TestGetFieldValueAlternativeNames 测试字段名变体查找
func TestGetFieldValueAlternativeNames(t *testing.T) {
	fmt.Println("\n=== 测试字段名变体查找 ===")

	// 测试 Id 字段（驼峰）
	model1 := &TestModelId{Id: 111}
	result1 := getFieldValue(model1, "ID")
	if result1 != 111 {
		t.Errorf("期望 111, 得到 %d", result1)
	}

	fmt.Println("✓ 字段名变体查找测试通过")
}

// TestGetFieldValueEdgeCases 测试边界情况
func TestGetFieldValueEdgeCases(t *testing.T) {
	fmt.Println("\n=== 测试边界情况 ===")

	// 测试非结构体类型
	nonStruct := 123
	result := getFieldValue(nonStruct, "ID")
	if result != 0 {
		t.Errorf("非结构体应该返回 0, 得到 %d", result)
	}

	// 测试不存在的字段（没有 ID/Id/id 等变体）
	type ModelNoID struct {
		Name string `json:"name" db:"name"`
	}
	model := &ModelNoID{Name: "test"}
	result = getFieldValue(model, "NonExistentField")
	if result != 0 {
		t.Errorf("不存在的字段应该返回 0, 得到 %d", result)
	}

	fmt.Println("✓ 边界情况测试通过")
}

// TestGetFieldValueSpecialTypes 测试特殊类型
func TestGetFieldValueSpecialTypes(t *testing.T) {
	fmt.Println("\n=== 测试特殊类型 ===")

	// 注意：sql.NullInt64 等数据库特殊类型目前不支持
	// 如果需要支持，可以在 convertToInteger 中添加专门的处理逻辑

	fmt.Println("✓ 特殊类型测试通过（当前版本不支持 sql.NullInt64）")
}

// TestGetFieldValueInUpdate 测试在 Update 场景中的使用
func TestGetFieldValueInUpdate(t *testing.T) {
	fmt.Println("\n=== 测试 Update 场景 ===")

	user := &UserModel{
		ID:       1,
		Username: "test",
	}

	pkValue := getFieldValue(user, "ID")
	if pkValue != 1 {
		t.Errorf("期望主键值为 1, 得到 %d", pkValue)
	}

	// 测试主键为 0 的情况
	user2 := &UserModel{
		ID:       0,
		Username: "test2",
	}

	pkValue2 := getFieldValue(user2, "ID")
	if pkValue2 != 0 {
		t.Errorf("期望主键值为 0, 得到 %d", pkValue2)
	}

	fmt.Println("✓ Update 场景测试通过")
}

// TestGetFieldValueLargeNumbers 测试大数字
func TestGetFieldValueLargeNumbers(t *testing.T) {
	fmt.Println("\n=== 测试大数字 ===")

	// 测试最大 int64
	maxInt := int64(9223372036854775807)
	model1 := &TestModelInt64{ID: maxInt}
	result1 := getFieldValue(model1, "ID")
	if result1 != maxInt {
		t.Errorf("期望 %d, 得到 %d", maxInt, result1)
	}

	// 测试 uint64 转 int64
	largeUint := uint64(18446744073709551615) // 这会导致溢出
	model2 := &TestModelUint64{ID: largeUint}
	result2 := getFieldValue(model2, "ID")
	// 注意：这里会发生溢出，但这是预期的行为
	if result2 == 0 {
		t.Error("uint64 转换不应该返回 0")
	}

	fmt.Println("✓ 大数字测试通过")
}

// 测试模型定义
type TestModelInt struct {
	ID int `json:"id" db:"id"`
}

type TestModelInt64 struct {
	ID int64 `json:"id" db:"id"`
}

type TestModelUint struct {
	ID uint `json:"id" db:"id"`
}

type TestModelUint64 struct {
	ID uint64 `json:"id" db:"id"`
}

type TestModelFloat struct {
	ID float64 `json:"id" db:"id"`
}

type TestModelId struct {
	Id int64 `json:"id" db:"id"`
}

type TestModelid struct {
	id int64 `json:"id" db:"id"`
}

type TestModelPrivate struct {
	privateField int64
}

type TestModelNullInt struct {
	ID sql.NullInt64 `json:"id" db:"id"`
}

type UserModel struct {
	ID       int64  `json:"id" db:"id"`
	Username string `json:"username" db:"username"`
}