package test

import (
	"fmt"
	"log"
	"reflect"
	"strconv"
	"strings"
	"testing"
)

// 实现: 使用反射实现json.marshal json.unmarshal
type User2 struct {
	Id        int    `json:"Id"`
	Username  string `json:"Username"`
	Email     string `json:"Email"`
	Birthdate string `json:"Birthdate"`
	IsActive  bool   `json:"IsActive"`
}

func Marshal(v interface{}) ([]byte, error) {
	typ := reflect.TypeOf(v)
	if typ.Kind() != reflect.Pointer {
		return nil, fmt.Errorf("请传入 %s", reflect.Pointer)
	}
	typ = typ.Elem()

	val := reflect.ValueOf(v).Elem()

	var conf []byte
	for i := range typ.NumField() {
		f := typ.Field(i)
		tag := f.Tag.Get("json")
		if tag == "" {
			tag = f.Name
		}

		fieldVal := val.Field(i).Interface()
		str := fmt.Sprintf("%s=%v\n", tag, fieldVal)
		conf = append(conf, []byte(str)...)
	}

	return conf, nil
}

func UnMarshal(data []byte, v interface{}) error {
	val := string(data)
	valArr := strings.Split(val, "\n")
	valArr = valArr[:len(valArr)-2]

	typ := reflect.TypeOf(v)
	if typ.Kind() != reflect.Pointer {
		return fmt.Errorf("请传入 %s", reflect.Pointer)
	}

	typ = typ.Elem()
	valEl := reflect.ValueOf(v).Elem()

	for _, valStr := range valArr {
		kv := strings.Split(valStr, "=")
		f := valEl.FieldByName(kv[0])
		k := f.Kind()
		switch k {
		case reflect.Int:
			intVal, err := strconv.Atoi(kv[1])
			if err != nil {
				return err
			}
			f.SetInt(int64(intVal))
		case reflect.String:
			f.SetString(kv[1])
		case reflect.Bool:
			boolVal, err := strconv.ParseBool(kv[1])
			if err != nil {
				return err
			}
			f.SetBool(boolVal)
		default:
			return fmt.Errorf("无法识别： %s\n", k)
		}
	}

	return nil
}

// Marshal、UnMarshal 只支持字段为基础类型，不支持字段为struct
func TestMarshalAndUnmarshal(t *testing.T) {
	user := &User2{Id: 1, Username: "zly", Email: "123456"}

	data, err := Marshal(user)
	if err != nil {
		log.Println(err)
		return
	}
	fmt.Println(data)

	user2 := &User2{}
	err = UnMarshal(data, user2)
	if err != nil {
		log.Println(err)
		return
	}
	fmt.Println(user2)
}