// 獲取[]int切片的第一個(gè)元素
func FirstInt(s []int) (int, error) {
    if len(s) == 0 {
        return 0, errors.New("slice is empty")
    }
    return s[0], nil
}

// 獲取[]string切片的第一個(gè)元素
func FirstString(s []string) (string, error) {
    if len(s) == 0 {
        return "", errors.New("slice is empty")
    }
    return s[0], nil
}

// 獲取[]float64切片的第一個(gè)元素
func FirstFloat64(s []float64) (float64, error) {
    if len(s) == 0 {
        return 0, errors.New("slice is empty")
    }
    return s[0], nil
}

// MyInt的底層類型是int
type MyInt int

// UserName的底層類型是string
type UserName string

// EmptyStruct的底層類型是struct{}
type EmptyStruct struct{}

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 空結(jié)構(gòu)體變量
    var s struct{}
    // 空結(jié)構(gòu)體指針
    var p *struct{}

    fmt.Printf("struct{} 大小：%d 字節(jié)\n", unsafe.Sizeof(s))
    fmt.Printf("*struct{} 大?。?d 字節(jié)\n", unsafe.Sizeof(p))
}

struct{} 大小：0 字節(jié)
*struct{} 大?。? 字節(jié)

package main

import "fmt"

// 定義兩個(gè)底層類型為struct{}的衍生類型
type Empty1 struct{}
type Empty2 struct{}

// 精確約束：類型參數(shù)必須是struct{}
func ExactConstraint[T struct{}](t T) {
    fmt.Printf("ExactConstraint: 類型=%T, 大小=%d\n", t, unsafe.Sizeof(t))
}

// 近似約束：類型參數(shù)底層類型為struct{}
func ApproxConstraint[T ~struct{}](t T) {
    fmt.Printf("ApproxConstraint: 類型=%T, 大小=%d\n", t, unsafe.Sizeof(t))
}

func main() {
    // 原始struct{}類型變量
    var s struct{}
    // 衍生類型變量
    var e1 Empty1
    var e2 Empty2

    // 調(diào)用精確約束函數(shù)
    ExactConstraint(s)  // 正常運(yùn)行：類型=struct {}, 大小=0
    // ExactConstraint(e1) // 編譯錯(cuò)誤：Empty1 does not implement struct{} (type mismatch)
    // ExactConstraint(e2) // 編譯錯(cuò)誤：Empty2 does not implement struct{} (type mismatch)

    // 調(diào)用近似約束函數(shù)
    ApproxConstraint(s) // 正常運(yùn)行：類型=struct {}, 大小=0
    ApproxConstraint(e1) // 正常運(yùn)行：類型=main.Empty1, 大小=0
    ApproxConstraint(e2) // 正常運(yùn)行：類型=main.Empty2, 大小=0
}

package main

import "fmt"

// 定義衍生自struct{}的類型
type Empty struct{}
type Signal struct{}
type Flag struct{}

// 泛型集合：元素類型底層必須是struct{}
type EmptySet[T ~struct{}] struct {
    items map[string]T // key為自定義標(biāo)識(shí)，value為約束類型
}

// 初始化集合
func NewEmptySet[T ~struct{}]() *EmptySet[T] {
    return &EmptySet[T]{
        items: make(map[string]T),
    }
}

// 向集合中添加元素（通過key標(biāo)識(shí)，value為任意~struct{}類型）
func (s *EmptySet[T]) Add(key string, val T) {
    s.items[key] = val
}

// 從集合中刪除元素
func (s *EmptySet[T]) Remove(key string) {
    delete(s.items, key)
}

// 判斷元素是否存在
func (s *EmptySet[T]) Exists(key string) bool {
    _, ok := s.items[key]
    return ok
}

// 獲取集合大小
func (s *EmptySet[T]) Size() int {
    return len(s.items)
}

func main() {
    // 初始化一個(gè)存儲(chǔ)Empty類型的集合
    emptySet := NewEmptySet[Empty]()
    emptySet.Add("a", Empty{})
    emptySet.Add("b", Empty{})
    fmt.Printf("emptySet 大?。?d, 'a'是否存在：%t\n", emptySet.Size(), emptySet.Exists("a"))

    // 初始化一個(gè)存儲(chǔ)Signal類型的集合
    signalSet := NewEmptySet[Signal]()
    signalSet.Add("signal1", Signal{})
    signalSet.Remove("signal1")
    fmt.Printf("signalSet 大?。?d, 'signal1'是否存在：%t\n", signalSet.Size(), signalSet.Exists("signal1"))

    // 初始化一個(gè)存儲(chǔ)原始struct{}類型的集合
    rawSet := NewEmptySet[struct{}]()
    rawSet.Add("raw1", struct{}{})
    fmt.Printf("rawSet 大?。?d, 'raw1'是否存在：%t\n", rawSet.Size(), rawSet.Exists("raw1"))
}

package main

import (
    "fmt"
    "time"
)

// 定義不同的信號(hào)類型（底層均為struct{}）
type StartSignal struct{}
type StopSignal struct{}
type PauseSignal struct{}

// 通用信號(hào)處理器：接收任意底層為struct{}的信號(hào)
func ProcessSignal[T ~struct{}](signalChan <-chan T, signalName string) {
    go func() {
        for {
            select {
            case <-signalChan:
                fmt.Printf("收到信號(hào)：%s, 時(shí)間：%v\n", signalName, time.Now().Format("2006-01-02 15:04:05"))
            case <-time.After(5 * time.Second):
                fmt.Printf("5秒內(nèi)未收到%s信號(hào)，退出監(jiān)聽\n", signalName)
                return
            }
        }
    }()
}

func main() {
    // 初始化不同類型的信號(hào)通道
    startChan := make(chan StartSignal)
    stopChan := make(chan StopSignal)

    // 啟動(dòng)信號(hào)處理器
    ProcessSignal(startChan, "Start")
    ProcessSignal(stopChan, "Stop")

    // 發(fā)送信號(hào)
    startChan <- StartSignal{}
    time.Sleep(2 * time.Second)
    stopChan <- StopSignal{}

    // 等待信號(hào)處理完成
    time.Sleep(3 * time.Second)
}

package main

import "fmt"

// 衍生類型：底層類型為int
type MyInt int
// 衍生類型：底層類型為string
type UserID string

// 泛型函數(shù)：支持所有底層類型為int的類型
func Sum[T ~int](a, b T) T {
    return a + b
}

// 泛型函數(shù)：支持所有底層類型為string的類型
func Concat[T ~string](a, b T) T {
    return a + b
}

func main() {
    var a int = 10
    var b MyInt = 20
    fmt.Println(Sum(a, int(b))) // 30：MyInt可轉(zhuǎn)換為int，滿足～int約束

    var id1 UserID = "user_"
    var id2 string = "123"
    fmt.Println(Concat(id1, UserID(id2))) // user_123：string可轉(zhuǎn)換為UserID，滿足～string約束
}

package main

import "fmt"

// 定義一個(gè)接口
type Writer interface {
    Write([]byte) (int, error)
}

// 定義一個(gè)底層類型為*File的衍生類型（假設(shè)File實(shí)現(xiàn)了Writer接口）
type MyFile *File

// 泛型函數(shù)：支持所有底層類型實(shí)現(xiàn)Writer接口的類型
func WriteData[T ~Writer](w T, data []byte) error {
    _, err := w.Write(data)
    return err
}

// 模擬File類型（實(shí)現(xiàn)Writer接口）
type File struct{}
func (f *File) Write(data []byte) (int, error) {
    fmt.Printf("寫入數(shù)據(jù)：%s\n", string(data))
    return len(data), nil
}

func main() {
    var f *File = &File{}
    var mf MyFile = &File{}

    WriteData(f, []byte("hello"))  // 正常運(yùn)行：寫入數(shù)據(jù)：hello
    WriteData(mf, []byte("world")) // 正常運(yùn)行：寫入數(shù)據(jù)：world
}

package main

import "fmt"

// 衍生類型
type MyInt int
type MyFloat float64

// 泛型函數(shù)：支持底層類型為int或float64的類型
func Add[T ~int | ~float64](a, b T) T {
    return a + b
}

func main() {
    var a int = 10
    var b MyInt = 20
    var c float64 = 3.14
    var d MyFloat = 2.86

    fmt.Println(Add(a, int(b)))   // 30
    fmt.Println(Add(c, float64(d))) // 6.0
}

package router

import (
	"reflect"
	"strings"
	"unicode"

	"github.com/gin-gonic/gin"
)

/*
	路由方法介紹：
		1、GET_PingPong  	請求方法：GET   接口路徑：/ping/pong
		2、PingPong  	 	請求方法：POST  接口路徑：/ping/pong
		3、PUT_PingPong  	請求方法：PUT   接口路徑：/ping/pong
*/

func routerInit2Gin[T ~struct{}](r *gin.RouterGroup, this T) {
	methodNames := getMethodNamesFromStruct(this)

	for _, methodName := range methodNames {
		// 使用局部變量捕獲當(dāng)前方法值
		methodVal := reflect.ValueOf(this).MethodByName(methodName)

		// 判斷方法是否存在
		if !methodVal.IsValid() {
			continue
		}

		// 創(chuàng)建一個(gè)匿名函數(shù)來捕獲methodVal， 這里是為了防止 閉包內(nèi)使用局部變量methodVal而不是循環(huán)變量
		handler := func(method reflect.Value) gin.HandlerFunc {
			return func(c *gin.Context) {
				// 在這里調(diào)用實(shí)際的方法
				method.Call([]reflect.Value{reflect.ValueOf(c)})
			}
		}(methodVal)

		// 若 methodName 以 _ 分割字符，判斷 請求方法
		res := strings.Split(methodName, "_")

		switch strings.ToUpper(res[0]) {
		case "GET":
			if len(res) >= 2 {
				r.GET(methodNameTranstoUrl(res[1]), handler)
			}
		case "DELETE":
			if len(res) >= 2 {
				r.DELETE(methodNameTranstoUrl(res[1]), handler)
			}

		case "PUT":
			if len(res) >= 2 {
				r.PUT(methodNameTranstoUrl(res[1]), handler)
			}

		default:
			r.POST(methodNameTranstoUrl(methodName), handler)
		}
	}
}

// 獲取 結(jié)構(gòu)體中的所有方法名
func getMethodNamesFromStruct(obj any) []string {
	val := reflect.ValueOf(obj)
	if val.Kind() == reflect.Ptr {
		val = val.Elem() // 如果是指針，解引用
	}

	// 確保傳入的是一個(gè)結(jié)構(gòu)體類型
	if val.Kind() != reflect.Struct {
		return nil
	}

	typ := val.Type()
	methodNames := make([]string, 0)

	// 遍歷類型的方法集
	for i := 0; i < typ.NumMethod(); i++ {
		method := typ.Method(i)
		methodNames = append(methodNames, method.Name)
	}

	return methodNames
}

// 將 方法名 轉(zhuǎn)換為 GIN路由 規(guī)格的 url
func methodNameTranstoUrl(methedname string) (url string) {

	for _, char := range methedname {
		if char >= 'A' && char <= 'Z' {
			url += "/" + string(unicode.ToLower(char))

		} else {
			url += string(char)
		}
	}

	return strings.TrimSpace(url)
}