package main

import (
	"encoding/hex"
	"errors"
	"github.com/tjfoc/gmsm/sm3"
	"reflect"
)

func main() {

	s := new(string)
	if s == nil {
		VarAssignment(s, "/home")
	}
	VarAssignment(s, "/")
	println(*s)
}

// VarAssignment 变量赋值
func VarAssignment(to, from any) error {
	var oldTv, oldFv, tv, fv reflect.Value
	tv = reflect.ValueOf(to)
	fv = reflect.ValueOf(from)
	if _, ok := to.(reflect.Value); ok {
		tv = to.(reflect.Value)
	}
	if _, ok := from.(reflect.Value); ok {
		fv = from.(reflect.Value)
	}
	if _, ok := to.(*reflect.Value); ok {
		tv = *(to.(*reflect.Value))
	}
	if _, ok := from.(*reflect.Value); ok {
		fv = *(from.(*reflect.Value))
	}

	oldTv = tv
	oldFv = fv

	if tv.IsNil() {
		return errors.New("The target data cannot be nil\n")
	}
	// 判断目标变量类型是否为指针类型，非指针类型返回错误
	if tv.Kind() == reflect.Ptr {
		tv = tv.Elem()
	} else {
		return errors.New("The target variable must be of pointer type ")
	}
	if fv.Kind() == reflect.Ptr {
		fv = fv.Elem()
	}

	// 判断目标变量类型和原变量类型是否一致
	if oldTv.Type().Elem().Kind() != fv.Kind() {
		return errors.New("Inconsistent data types ")
	}

	// 判断来源变量是否为空指针，如果为空指针则直接退出
	if oldFv.IsZero() && oldFv.Kind() == reflect.Ptr {
		return nil
	}

	// 判断目标变量是否为空，如果为空则创建内存空间
	if oldTv.IsZero() {
		val := reflect.New(oldTv.Type().Elem())
		oldTv.Set(val)
	}
	oldTv.Elem().Set(fv)
	return nil
}
func SM3SUM(in string) string {
	sm3Sum := sm3.Sm3Sum([]byte(in))
	return hex.EncodeToString(sm3Sum)
}

//package main
//
//import (
//	"fmt"
//	"net"
//)
//
//func main() {
//	netInterfaces, err := net.Interfaces()
//	if err != nil {
//		fmt.Println("net.Interfaces failed, err:", err.Error())
//		return
//	}
//
//	for i := 0; i < len(netInterfaces); i++ {
//		if (netInterfaces[i].Flags & net.FlagUp) != 0 {
//			addrs, _ := netInterfaces[i].Addrs()
//			for _, address := range addrs {
//				if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
//					if ipnet.IP.To4() != nil {
////						fmt.Println(netInterfaces[i].Name)
//						fmt.Println(ipnet.IP.String())
//					}
//				}
//			}
//		}
//	}
//
//	return
//}

//import (
//	"fmt"
//	"github.com/gin-gonic/gin"
//	"github.com/xuri/excelize/v2"
//	"net/http"
//)
//
//func main() {
//	r := gin.Default()
//	r.POST("/upload", func(c *gin.Context) {
//		file, err := c.FormFile("file") // 假设表单字段名为"file"
//		if err != nil {
//			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
//			return
//		}
//
//		// 保存上传的文件到本地临时目录
//		tempFile, err := file.Open()
//		if err != nil {
//			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
//			return
//		}
//		defer tempFile.Close()
//
//		// 使用excelize解析Excel文件
//		f, err := excelize.OpenReader(tempFile)
//		if err != nil {
//			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to open Excel file."})
//			return
//		}
//
//		// 示例：读取第一个工作表的第一行数据
//		sheetName := f.GetSheetName(0)
//		rows, err := f.GetRows(sheetName)
//		if err != nil {
//			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read rows from Excel."})
//			return
//		}
//
//		// 处理数据，这里简单打印出来
//		for _, row := range rows {
//			fmt.Println(row)
//		}
//
//		c.JSON(http.StatusOK, gin.H{"message": "File uploaded and parsed successfully!"})
//	})
//
//	r.Run(":8080") // 启动服务器
//}

//package main
//
//import (
//	"os"
//	"text/template"
//)
//
//type Config struct {
//	ImageURL  string
//	ScriptURL string
//	ISO       string
//}
//
//func main() {
//	// 创建一个Config对象，用于替换模板中的字段
//	config := Config{
//		ImageURL:  "http://example.com/images",
//		ScriptURL: "http://example.com/scripts",
//		ISO:       "ubuntu.iso",
//	}
//
//	// 模板字符串
//	templateStr := `#!ipxe
//dhcp
//
//set base-url {{ .ImageURL }} #请替换为镜像所在的HTTP文件服务器地址
//
//set ks-file {{ .ScriptURL }}  # 替换为你的 Kickstart 文件所在的 HTTP 服务器地址
//
//set iso {{.ISO}}
//
//kernel ${base-url}/images/pxeboot/vmlinuz initrd=initrd.img inst.repo=${base-url} ip=dhcp  ks=${ks-url}  # 指定 Kickstart 文件的位置和参数
//initrd ${base-url}/images/pxeboot/initrd.img
//boot
//`
//
//	// 创建模板对象
//	tmpl, err := template.New("ipxeTemplate").Parse(templateStr)
//	if err != nil {
//		panic(err)
//	}
//	create, _ := os.Create("auto.ipxe")
//	// 执行模板并输出结果
//	if err := tmpl.Execute(create, config); err != nil {
//		panic(err)
//	}
//}

//	func main() {
//		nums := []int{}
//		for _, num := range nums {
//			println(num)
//		}
//	}
/*package main

import (
	"fmt"
	"os"
)

// FileContent 结构体用于存储文件名和内容
type FileContent struct {
	FileName string
	Content  string
}

func main() {
	dir := "D:\\GolandProjects\\demo3\\demo3.8" // 替换为实际的文件夹路径

	files, err := os.ReadDir(dir)
	if err != nil {
		fmt.Println("Error reading directory:", err)
		return
	}

	var fileContents []FileContent

	for _, file := range files {
		if file.IsDir() {
			continue // 忽略文件夹
		}

		fileName := file.Name()
		filePath := dir + "/" + fileName

		content, err := os.ReadFile(filePath)
		if err != nil {
			fmt.Println("Error reading file:", err)
			continue
		}

		fileContents = append(fileContents, FileContent{
			FileName: fileName,
			Content:  string(content),
		})
	}

	// 打印文件名和内容
	for _, fc := range fileContents {
		fmt.Println("File Name:", fc.FileName)
		fmt.Println("Content:", fc.Content)
		fmt.Println()
	}
}*/

//package main
//
//import (
//	"fmt"
//	"strings"
//)
//
//func main() {
//	baseURL := "http://172.17.103.111:8080/file/images/ipxe/centos-min/cas.ipxe"
//	lastSlashIndex := strings.LastIndex(baseURL, "/")
//	if lastSlashIndex != -1 {
//		baseURL = baseURL[:lastSlashIndex]
//	}
//	fmt.Println(baseURL)
//}

//package main
//
//import (
//	"fmt"
//	"net"
//)
//
//func main() {
//	// 获取所有网络接口
//	ifaces, err := net.Interfaces()
//	if err != nil {
//		fmt.Println("Failed to get interfaces:", err)
//		return
//	}
//
//	// 遍历网络接口
//	for _, iface := range ifaces {
//		fmt.Printf("Interface: %s\n", iface.Name)
//
//		// 获取接口的所有地址
//		addrs, err := iface.Addrs()
//		if err != nil {
//			fmt.Println("Failed to get interface addresses:", err)
//			continue
//		}
//
//		// 遍历并打印每个地址
//		for _, addr := range addrs {
//			var ip net.IP
//			switch v := addr.(type) {
//			case *net.IPNet:
//				ip = v.IP
//			case *net.IPAddr:
//				ip = v.IP
//			}
//
//			// 排除IPv6地址和回环地址
//			if ip == nil || ip.IsLoopback() {
//				continue
//			}
//
//			// 打印IP地址和MAC地址
//			fmt.Printf("  IP: %s\tMAC: %s\n", ip.String(), iface.HardwareAddr.String())
//		}
//	}
//}