package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "strconv"
)

func printBytes(s string) {
    fmt.Println("Bytes:", s)
    for i := 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}
func printChars(s string) {
    fmt.Println("Chars: ", s)
    for i := 0; i < len(s); i++ {
        fmt.Printf("%c ", s[i])
    }
}

func test001() {
    const a int = 111
    fmt.Println(a)
    const b = "b"
    fmt.Println(b)
    const c = 'c'
    fmt.Println(c) // 99

    printBytes("迹忆客")
    printChars("迹忆客")
}

// 使用结构体

type Profile struct {
    name   string
    age    int
    gender string
    mother *Profile
    father *Profile
}

type company struct {
    name, addr string
}

type staff struct {
    name     string
    age      int
    gender   string
    position string
    company  // 匿名字段
}

func staffTest() {
    com := company{
        name: "阿里巴巴",
        addr: "杭州",
    }
    fmt.Println(com)
    s := staff{
        name:     "张三",
        age:      28,
        gender:   "男",
        position: "总经理",
        company:  com,
    }
    fmt.Println(s)
    fmt.Println(s.company.name)
    fmt.Println(s.company.addr)
}

// 绑定方法
// 以值做为方法接收者

func (p Profile) FmtProfile() {
    fmt.Println(p.name)
    fmt.Println(p.age)
    fmt.Println(p.gender)
}

// 以指针做为方法接收者
func (p *Profile) increase_age() {
    p.age += 1
}

func chanTest() {
    ch := make(chan int) // 创建channel
    go func() {
        ch <- 1 // 向channel中发送数据
    }()
    val := <-ch // 从channel中接收数据
    println(val)
}

func structTest001() {
    xm := Profile{
        name:   "小明",
        age:    19,
        gender: "男",
    }
    fmt.Println(xm)
    xm.FmtProfile()
    xm.increase_age()
    xm.FmtProfile()

    chanTest()
    staffTest()
}

func use_new_init_obj() {
    xm := new(Profile)
    fmt.Println(xm.name)
    fmt.Println(xm)
    xm.name = "iswbm"
    xm.age = 18
    xm.gender = "male"
    fmt.Println(xm)
}

func init_obj_2() {
    xm := &Profile{}
    xm.name = "老王"
    xm.age = 77
    xm.gender = "女"
    fmt.Println(xm)
}

type Phone interface {
    call()
}

type Nokia struct {
    name string
}

func (n Nokia) call() {
    fmt.Println("我是Nokia手机, 请开始通话。。。。")
}

//定义一个商品接口
//在 Go 语言中，是通过接口来实现的多态
type Good interface {
    settleAccount() int
    orderInfo() string
}

type Iphone struct {
    name     string
    quantity int
    price    int
}
type FreeGift struct {
    name     string
    quantity int
    price    int
}

func (phone Iphone) settleAccount() int {
    return phone.price * phone.quantity
}
func (phone Iphone) orderInfo() string {
    return "您要购买" + strconv.Itoa(phone.quantity) + "个" +
        phone.name + "计：" + strconv.Itoa(phone.settleAccount()) + "元"
}

func (gift FreeGift) settleAccount() int {
    return 0
}
func (gift FreeGift) orderInfo() string {
    return "您要购买" + strconv.Itoa(gift.quantity) + "个" +
        gift.name + "计：" + strconv.Itoa(gift.settleAccount()) + "元"
}

func calculateAllPrice(goods []Good) int {
    var allPrice int
    for _, good := range goods {
        fmt.Println(good.orderInfo())
        allPrice += good.settleAccount()
    }
    return allPrice
}

func useGood() {
    iphone := Iphone{
        name:     "Iphone",
        quantity: 1,
        price:    8000,
    }
    earphones := FreeGift{
        name:     "耳机",
        quantity: 1,
        price:    200,
    }
    goods := []Good{iphone, earphones}
    allPrice := calculateAllPrice(goods)
    fmt.Printf("该订单总共需要支付%d 元\n", allPrice)
}

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    Addr string `json:"addr,omitempty"`
}

func use_tag() {
    p1 := Person{
        Name: "Jack",
        Age:  28,
    }
    data1, err := json.Marshal(p1)
    if err != nil {
        panic(err)
    }
    //没有Addr不打印 {"name":"Jack","age":28}
    fmt.Printf("%s\n", data1)

    p2 := Person{
        Name: "json",
        Age:  16,
        Addr: "USA",
    }
    data2, err := json.Marshal(p2)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s \n", data2)
}

func tag_use_reflect() {
    p := reflect.TypeOf(Person{})
    name, _ := p.FieldByName("Name")
    fmt.Printf("%q\n", name.Tag)

}

type PersonLabel struct {
    Name   string `label:"Name is: "`
    Age    int    `label:"Age is: "`
    Gender string `label:"Gender is: " default:"unknown"`
}

func Print(obj interface{}) error {
    v := reflect.ValueOf(obj)
    for i := 0; i < v.NumField(); i++ {
        //获取tag
        field := v.Type().Field(i)
        tag := field.Tag
        // 解析lable和default
        label := tag.Get("label")
        defaultValue := tag.Get("default")
        value := fmt.Sprintf("%v", v.Field(i))
        if value == "" {
            value = defaultValue
        }
        fmt.Println(label + value)
    }
    return nil
}

func use_tab_label() {
    p := PersonLabel{
        Name: "Alex",
        Age:  29,
    }
    Print(p)
}

func TypeAssertion() {
    var i interface{} = 10
    t1 := i.(int)
    fmt.Println(t1)

    // t2 := i.(string)
    // fmt.Println(t2)
    //panic: interface conversion: interface {} is int, not string
    t2, ok := i.(string)
    fmt.Println(t2, ok)
    fmt.Println("=====分隔线2=====")

    var k interface{} // nil
    t3, ok := k.(interface{})
    fmt.Println(t3, "3-", ok)

    fmt.Println("=====分隔线3=====")
    k = 10
    t4, ok := k.(interface{})
    fmt.Printf("t4  %d-%t\n", t4, ok)

    t5, ok := k.(int)
    fmt.Printf("t5 %d-%t\n", t5, ok)

}

func findType(i interface{}) {
    switch x := i.(type) {
    case int:
        fmt.Println(x, "is int...")
    case string:
        fmt.Println(x, "is string")
    case nil:
        fmt.Println(x, "is nil")
    default:
        fmt.Println(x, "not type matched.")
    }
}

/* 空接口是特殊形式的接口类型，普通的接口都有方法，而空接口没有定义任何方法口，
也因此，我们可以说所有类型都至少实现了空接口
每一个接口都包含两个属性，一个是值，一个是类型。

而对于空接口来说，这两者都是 nil，可以使用 fmt 来验证一下*/

type empty_interface interface {
}

func use_empty_interface() {
    var i interface{}
    fmt.Printf("type %T, value:%v", i, i)

    //1.使用空接口接收任意类型的值

    i = 1
    fmt.Println(i)
    i = "hello"
    fmt.Println(i)
    i = false
    fmt.Println(i)
}

// 空接口： 函数接收任意类型的值，
func myPrint(i interface{}) {
    fmt.Println(i)
}

// 接收多个任意类型的值

func myList(values ...interface{}) {
    for _, value := range values {
        fmt.Println(value)
    }
}

// 定义一个可以接收任意类型的 array、slice、map、strcut

func anySlice() {
    any := make([]interface{}, 5)
    any[0] = 1
    any[1] = "hello world"
    any[2] = []int{1, 2, 3, 4}
    for _, value := range any {
        if value != nil {
            fmt.Println(value)
        }
    }

}
func main() {
    use_new_init_obj()
    init_obj_2()
    n := Nokia{name: "nokia"}
    n.call()
    useGood()
    use_tag()
    tag_use_reflect()
    use_tab_label()
    TypeAssertion()
    findType(10)
    findType("hello")
    var k interface{} // nil
    findType(k)
    findType(10.24)
    use_empty_interface()

    a := 10
    b := "hello"
    c := true
    myPrint(a)
    myPrint(b)
    myPrint(c)
    myList(a, b, c)
    anySlice()
}