package rui

import (
	"fmt"
	"net"
	"net/http"
	"net/netip"
	"reflect"
	"strconv"
	"strings"
)

// getLocationIP 获取本地IP地址
func getLocationIP(scheme string, host string, port uint) string {
	if host != "" {
		return fmt.Sprint(scheme, "://", host, ":", port)
	}
	interfaces, err := net.Interfaces()
	if err != nil {
		return fmt.Sprint(scheme, "://", "127.0.0.1", ":", port)
	}
	for _, d := range interfaces {
		addrs, err := d.Addrs()
		if d.Name == "以太网" {
			if err != nil {
				return fmt.Sprint(scheme, "://", "127.0.0.1", ":", port)
			}
			for _, dip := range addrs {
				if strings.Contains(dip.String(), ".") {
					cut, _, _ := strings.Cut(dip.String(), "/")
					if cut != "" {
						return fmt.Sprint(scheme, "://", cut, ":", port)
					}
					return fmt.Sprint(scheme, "://", dip.String(), ":", port)
				}
			}
		} else {
			for _, dip := range addrs {
				if strings.HasPrefix(dip.String(), "192.168.") {
					if strings.Contains(dip.String(), ".") {
						cut, _, _ := strings.Cut(dip.String(), "/")
						if cut != "" {
							return fmt.Sprint(scheme, "://", cut, ":", port)
						}
						return fmt.Sprint(scheme, "://", dip.String(), ":", port)
					}
				}
			}
		}
	}
	return fmt.Sprint(scheme, "://", "127.0.0.1", ":", port)
}

//getIP 获取相对真实的IP地址，获取顺序X-Real-IP、X-Forwarded-For、RemoteAddr
func getIP(r *http.Request) string {
	xriIP := r.Header.Get("X-Real-IP")
	addr, err := netip.ParseAddr(xriIP)
	if err == nil {
		if len(addr.String()) > 6 {
			return addr.String()
		}
	}
	xffIP := r.Header.Get("X-Forwarded-For")
	cut, _, found := strings.Cut(xffIP, ",")
	if found {
		if len(cut) > 6 {
			return cut
		}
	}
	if len(xffIP) > 6 {
		return xffIP
	}
	remoteAddr, _ := netip.ParseAddrPort(r.RemoteAddr)
	return remoteAddr.Addr().String()
}

// isPointerType 判断是否为地址类型（结构体指针类型）
func isPointerType(v any) bool {
	tf := reflect.TypeOf(v)
	if tf.Kind() != reflect.Ptr || tf.Elem().Kind() != reflect.Struct {
		return false
	}
	return true
}

// autoSetValue 自动为字段赋值value
func autoSetValue(field *reflect.Value, value string) {
	if len(value) <= 0 {
		return
	}
	switch field.Kind() {
	case reflect.Bool:
		rt, err := strconv.ParseBool(value)
		if err == nil {
			field.SetBool(rt)
		}
	case reflect.Int:
		rt, err := strconv.Atoi(value)
		if err == nil {
			field.SetInt(int64(rt))
		}
	case reflect.Int8:
		rt, err := strconv.ParseInt(value, 10, 8)
		if err == nil {
			field.SetInt(rt)
		}
	case reflect.Int16:
		rt, err := strconv.ParseInt(value, 10, 16)
		if err == nil {
			field.SetInt(rt)
		}
	case reflect.Int32:
		rt, err := strconv.ParseInt(value, 10, 32)
		if err == nil {
			field.SetInt(rt)
		}
	case reflect.Int64:
		rt, err := strconv.ParseInt(value, 10, 64)
		if err == nil {
			field.SetInt(rt)
		}
	case reflect.Uint:
		rt, err := strconv.ParseUint(value, 10, 64)
		if err == nil {
			field.SetUint(rt)
		}
	case reflect.Uint8:
		rt, err := strconv.ParseUint(value, 10, 8)
		if err == nil {
			field.SetUint(rt)
		}
	case reflect.Uint16:
		rt, err := strconv.ParseUint(value, 10, 16)
		if err == nil {
			field.SetUint(rt)
		}
	case reflect.Uint32:
		rt, err := strconv.ParseUint(value, 10, 32)
		if err == nil {
			field.SetUint(rt)
		}
	case reflect.Uint64:
		rt, err := strconv.ParseUint(value, 10, 64)
		if err == nil {
			field.SetUint(rt)
		}
	case reflect.Float32:
		rt, err := strconv.ParseFloat(value, 32)
		if err == nil {
			field.SetFloat(rt)
		}
	case reflect.Float64:
		rt, err := strconv.ParseFloat(value, 64)
		if err == nil {
			field.SetFloat(rt)
		}
	case reflect.String:
		field.SetString(value)
	}
}

// fieldDecode 将src的值，解码到dst上面
func fieldDecode(dst any, src map[string][]string) error {
	tf := reflect.TypeOf(dst)
	vf := reflect.ValueOf(dst)
	for i := 0; i < tf.Elem().NumField(); i++ {

		tag := tf.Elem().Field(i).Tag.Get("form")
		if tag == "" {
			tag = tf.Elem().Field(i).Tag.Get("json")
			if tag == "" {
				continue
			}
		}
		if v, ok := src[tag]; ok {
			val := ""
			if len(v) > 0 {
				val = v[0]
			} else {
				continue
			}
			field := vf.Elem().Field(i)
			autoSetValue(&field, val)
		}
	}
	return nil
}