import (
	"fmt"
	"unsafe"
)

type Struct1 struct {
	c bool
	a float64
	b int16
}

type Struct2 struct {
	a float64
	b int16
	c bool
}

type Struct3 struct {
	c bool
	b int16
	a float64
}

var boolTest bool

var stringTest string

var mapTest map[int]int

var funcTest  func()

var chanTest chan int

var interfaceTest interface{}


func SizeOf()  {

	fmt.Println("Size of float64: ", unsafe.Sizeof(float64(0)))

	fmt.Println("Size of bool: ", unsafe.Sizeof(boolTest))

	fmt.Println("Size of string: ", unsafe.Sizeof(stringTest))

	fmt.Println("Size of map: ", unsafe.Sizeof(mapTest))

	fmt.Println("Size of func: ", unsafe.Sizeof(funcTest))

	fmt.Println("Size of channel: ", unsafe.Sizeof(chanTest))

	fmt.Println("Size of interface: ", unsafe.Sizeof(interfaceTest))

	s1 := Struct1{}
	fmt.Println("Size of struct1: ", unsafe.Sizeof(Struct1{}),
		"\n Alignof struct1: ", unsafe.Alignof(Struct1{}),
		"\n\n Alignof struct1.a: ", unsafe.Alignof(s1.a),
		"\n Alignof struct1.b: ", unsafe.Alignof(s1.b),
		"\n Alignof struct1.c: ", unsafe.Alignof(s1.c),
		"\n\n Offsetof struct1.a: ", unsafe.Offsetof(s1.a),
		"\n Offsetof struct1.b: ", unsafe.Offsetof(s1.b),
		"\n Offsetof struct1.c: ", unsafe.Offsetof(s1.c))

	fmt.Println("Size of struct2: ", unsafe.Sizeof(Struct2{}),
		"\n Alignof struct1: ", unsafe.Alignof(Struct1{}),
		"\n\n Alignof struct1.a: ", unsafe.Alignof(s1.a),
		"\n Alignof struct1.b: ", unsafe.Alignof(s1.b),
		"\n Alignof struct1.c: ", unsafe.Alignof(s1.c),
		"\n\n Offsetof struct1.a: ", unsafe.Offsetof(s1.a),
		"\n Offsetof struct1.b: ", unsafe.Offsetof(s1.b),
		"\n Offsetof struct1.c: ", unsafe.Offsetof(s1.c))

	fmt.Println("Size of struct3: ", unsafe.Sizeof(Struct3{}),
		"\n Alignof struct1: ", unsafe.Alignof(Struct1{}),
		"\n\n Alignof struct1.a: ", unsafe.Alignof(s1.a),
		"\n Alignof struct1.b: ", unsafe.Alignof(s1.b),
		"\n Alignof struct1.c: ", unsafe.Alignof(s1.c),
		"\n\n Offsetof struct1.a: ", unsafe.Offsetof(s1.a),
		"\n Offsetof struct1.b: ", unsafe.Offsetof(s1.b),
		"\n Offsetof struct1.c: ", unsafe.Offsetof(s1.c))
}

// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
	Data uintptr
	Len  int
}

// stringHeader is a safe version of StringHeader used within this package.
type stringHeader struct {
	Data unsafe.Pointer
	Len  int
}

// SliceHeader is the runtime representation of a slice.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

// sliceHeader is a safe version of SliceHeader used within this package.
type sliceHeader struct {
	Data unsafe.Pointer
	Len  int
	Cap  int
}

import (
	"reflect"
	"unsafe"
)

func StringToBytes(s string) []byte {

	stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
	sliceHeader := reflect.SliceHeader{
		Data:stringHeader.Data,
		Len:stringHeader.Len,
		Cap:stringHeader.Len,
	}

	return *(*[]byte)(unsafe.Pointer(&sliceHeader))
}

func BytesToString(b []byte)string  {
	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
	stringHeader := reflect.StringHeader{
		Data:sliceHeader.Data,
		Len:sliceHeader.Len,
	}

	return *(*string)(unsafe.Pointer(&stringHeader))

}

func TestBytesToString(t *testing.T) {
	s := "abcdefg"
	res := StringToBytes(s)
	stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))

	fmt.Printf("%+v, %+v\n", &s, &stringHeader.Data)
	fmt.Println(res)

	bytes := []byte(s)
	res1 := BytesToString(bytes)
	fmt.Println(res1)
}

func IsEqual()  {

	var map1, map2 map[string]int = nil, make(map[string]int)
	res := reflect.DeepEqual(map1, map2)
	fmt.Println(res)

	var slice1, slice2 []int = nil, []int{}
	res1 := reflect.DeepEqual(slice1, slice2)
	fmt.Println(res1)
}