package rest

import (
	"fmt"
	"log"
	"reflect"
	"testing"

	"git.ali33.ru/fcg-xvii/go-tools/json"
)

type Child struct {
	ID   int64
	Name string
}

func NewTFielder() *TFielder {
	res := &TFielder{}
	res.Fielder = NewFielder(res)
	return res
}

type TFielder struct {
	*Fielder
	ID       int64
	Name     string
	NumArr   []int64
	FloatArr []float64
	StrArr   []string
	AnyArr   []any
	ChildArr []*Child
	//MapInt   map[string]int64
}

func TestParse(t *testing.T) {
	// int8 в int64
	lInt, rInt := byte(10), int64(0)
	if err := parseVal(reflect.ValueOf(lInt), reflect.ValueOf(&rInt), "int"); err != nil {
		t.Fatal(err)
	}
	// из строки в строку
	lStr, rStr := "copy message", ""
	if err := parseVal(reflect.ValueOf(lStr), reflect.ValueOf(&rStr), "string"); err != nil {
		t.Fatal(err)
	}
	// массивы
	lArr := []any{"one", "two"}
	rArr := []string{}
	if err := parseSlice(reflect.ValueOf(lArr), reflect.ValueOf(&rArr), "slice"); err != nil {
		t.Fatal(err)
	}
	// map -> объект
	lMap := json.Map{
		"id":      10,
		"name":    "Fielder-Name",
		"num_arr": []any{1, 2, 3, 4, 5},
		"any_arr": []any{"one", "two", 3, 4},
		"child_arr": []json.Map{
			{
				"id":   11,
				"name": "Name-77",
			},
		},
	}
	var rObj TFielder
	if err := parseStruct(reflect.ValueOf(lMap), reflect.ValueOf(&rObj), "struct"); err != nil {
		t.Fatal(err)
	}
	log.Println(rObj)
}

func TestParse2(t *testing.T) {
	//var val []int
	//val = 20
	val := []any{1, 2, 3, 4, 5}
	log.Println(val)
	var val2 []*float64
	//val2 := []int{1, 2, 3}
	if err := parseType(reflect.ValueOf(&val), reflect.ValueOf(&val2), "val"); err != nil {
		t.Fatal(err)
	}
	log.Println("KK", val2, val)
	for _, p := range val2 {
		t.Log(*p)
	}
}

func TestParseMap(t *testing.T) {
	//var val map[string]int
	//val := map[string]int{"a": 1, "b": 2, "c": 3}
	val := struct {
		Name   string
		AgeNum int
	}{
		Name:   "Иван",
		AgeNum: 30,
	}
	var val2 map[string]any
	if err := parseType(reflect.ValueOf(&val), reflect.ValueOf(&val2), "val"); err != nil {
		t.Fatal(err)
	}
	log.Println("KK", val2, val)
}

type Person struct {
	Name   *string
	AgeNum int
	Child  *Person
	Childs []*Person
}

func (s *Person) String() string {
	return fmt.Sprintf("Person{Name: %v, AgeNum: %d, Child: %v}", *s.Name, s.AgeNum, s.Child)
}

func TestParseStruct(t *testing.T) {
	val := json.Map{
		"name":    "Иван",
		"age_num": 30,
		"child": json.Map{
			"name":    "OOO",
			"age_num": 10,
		},
		"childs": []json.Map{
			{
				"name":    "OOO",
				"age_num": 10,
			},
			{
				"name":    "OOO1",
				"age_num": 10,
			},
			{
				"name":    "OOO2",
				"age_num": 10,
			},
		},
	}
	var val2 Person
	if err := parseType(reflect.ValueOf(&val), reflect.ValueOf(&val2), "val"); err != nil {
		t.Fatal(err)
	}
	t.Log(val2)
	t.Log(*val2.Name)
}