import (
	"encoding/json"
	"fmt"
	"testing"
)
type TestJson struct {
	UserId       int    `json:"user_id"` // 使用結構體標簽可以指定字段在 JSON 中的鍵名
	UserNickname string // 如果沒有指定標簽，則默認使用字段名。
	UserAge      int    `json:"age,omitempty"` // 使用omitempty可以在序列化時忽略空值
}
func Test1(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := json.Marshal(tJson1)
	jsonStr2, _ := json.Marshal(tJson2)
	fmt.Println(string(jsonStr1))
	fmt.Println(string(jsonStr2))
}

func Test2(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	jsonStr1, _ := json.MarshalIndent(tJson1, "", "\t")
	fmt.Println(string(jsonStr1))
}

func Test3(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson TestJson
	// 將字符串轉為字節(jié)數(shù)組，再傳入解析后的對象指針
	// 第二個參數(shù)必須是指向目標數(shù)據類型變量的指針，以便函數(shù)能夠修改該變量。
	err := json.Unmarshal([]byte(jsonStr), &tJson)
	if err != nil {
		fmt.Println("解析錯誤：", err)
	} else {
		fmt.Println(tJson)
	}
}

func Test5(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["地址1","地址2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson TestJson
	err := json.Unmarshal([]byte(jsonStr), &tJson)
	if err != nil {
		fmt.Println("解析錯誤：", err)
	} else {
		fmt.Println(tJson)
	}
}

func Test4(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["地址1","地址2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson map[string]any
	err := json.Unmarshal([]byte(jsonStr), &tJson)
	if err != nil {
		fmt.Println("解析錯誤：", err)
	} else {
		fmt.Println(tJson)
	}
}

func serializeSimple(data interface{}) string {
	var resultStr string = "{"
	//1、反射傳入的結構體
	reflectDataValue := reflect.ValueOf(data)
	reflectDataType := reflectDataValue.Type()
	if reflectDataValue.Kind() == reflect.Ptr {
		reflectDataValue = reflectDataValue.Elem()
	}
	if reflectDataType.Kind() == reflect.Ptr {
		reflectDataType = reflectDataType.Elem()
	}
	//2、獲取字段
	for i := 0; i < reflectDataType.NumField(); i++ {
		field := reflectDataType.Field(i)
		// 字段名
		var filedName = field.Name
		// 字段的值
		filedValue := reflectDataValue.Field(i).Interface()
		//3、判斷字段的標簽
		if value, ok := field.Tag.Lookup("json"); ok {
			// 如果有json標簽，則使用其定義的命名
			filedName = strings.ReplaceAll(value, ",omitempty", "")
			// 是否忽略空值
			if strings.Contains(value, "omitempty") {
				if filedValue == "" || filedValue == 0 {
					continue
				}
			}
		}
		// 拼接json
		resultStr += fmt.Sprintf("\"%s\":\"%v\"", filedName, filedValue)
		resultStr += ","
	}
	//4、拼接字符串
	resultStr += "}"
	// 去掉結尾的,號
	return strings.ReplaceAll(resultStr, ",}", "}")
}
func Test6(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := json.Marshal(tJson1)
	jsonStr2, _ := json.Marshal(tJson2)
	fmt.Println(string(jsonStr1))
	fmt.Println(string(jsonStr2))
	fmt.Println("=========自定義實現(xiàn)=========")
	fmt.Println(serializeSimple(tJson1))
	fmt.Println(serializeSimple(tJson2))
}

func parseSimple(str string, dataTemp interface{}) {
	// 判斷是否標準的json格式數(shù)據
	if str != "" && str[0] == '{' && str[len(str)-1] == '}' {
		// 替換掉前后的{}
		str = strings.ReplaceAll(strings.ReplaceAll(str, "{", ""), "}", "")
		// 將結構體的標簽解析后，塞入map中備用 ：map [字段名] 字段地址
		structMap := map[string]reflect.Value{}
		// 通過反射獲取字段名
		rValue := reflect.ValueOf(dataTemp)
		if rValue.Kind() == reflect.Ptr {
			rValue = rValue.Elem()
		}
		rType := rValue.Type()
		for i := 0; i < rType.NumField(); i++ {
			name := rType.Field(i).Name
			// 如果有定義標簽，則使用標簽的字段名
			if lookup, ok := rType.Field(i).Tag.Lookup("json"); ok {
				name = strings.ReplaceAll(lookup, ",omitempty", "")
			}
			// 將字段名和值映射起來
			structMap[name] = rValue.Field(i)
		}
		// 按照,切割每個鍵值對
		splitList := strings.Split(str, ",")
		for i := range splitList {
			s := splitList[i]
			// 按照:切割出key 和 value
			keyValue := strings.Split(s, ":")
			key := keyValue[0]
			key = strings.ReplaceAll(strings.TrimSpace(key), "\"", "") // 去除前后的空格
			value := keyValue[1]
			value = strings.ReplaceAll(strings.TrimSpace(value), "\"", "")
			// 按照key將value塞回結構體
			switch structMap[key].Type().Kind() {
			// 注意判斷類型，目前只寫int和string，其他的類似
			case reflect.Int:
				intValue, _ := strconv.Atoi(value)
				structMap[key].SetInt(int64(intValue))
			case reflect.String:
				structMap[key].SetString(value)
			default:
				panic("暫不支持的數(shù)據類型")
			}
		}
	}
}
func Test7(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson1 TestJson
	var tJson2 TestJson
	err := json.Unmarshal([]byte(jsonStr), &tJson1)
	if err != nil {
		fmt.Println("解析錯誤：", err)
	} else {
		fmt.Println(tJson1)
	}
	fmt.Println("=========自定義實現(xiàn)=========")
	parseSimple(jsonStr, &tJson2)
	fmt.Println(tJson2)
}

func Test8(t *testing.T) {
	str := "123"
	// 第二個參數(shù)是基數(shù)，10表示十進制
	// 第三個參數(shù)是位大小，0表示int64，32表示int32，使用32或64取決于你的系統(tǒng)架構
	num, err := strconv.ParseInt(str, 10, 0)
	if err != nil {
		fmt.Println("轉換錯誤:", err)
	} else {
		fmt.Println("轉換結果:", num)
		// 如果你需要int32，可以這樣轉換
		num32 := int32(num)
		fmt.Println("轉換為int32結果:", num32)
		// 如果你需要int，可以這樣轉換（注意：在32位系統(tǒng)上這將是int32，在64位系統(tǒng)上這將是int64）
		numInt := int(num)
		fmt.Println("轉換為int結果:", numInt)
	}
}