package ip_util

import (
	"fmt"
	"net"
	"net/netip"
	"slices"
	"strings"

	"github.com/pkg/errors"
)

// 10.0.0.10/24
func ParseCidrIP(cidrIP string) (net.IP, *net.IPNet, error) {
	ip, ipNet, err := net.ParseCIDR(cidrIP)
	if err != nil {
		return nil, nil, errors.Wrapf(err, "ParseCidrIP[%s] error", cidrIP)
	}

	return ip, ipNet, nil
}

// 10.0.0.10
func ParseIP(ip string) (*netip.Addr, error) {
	// if not cidr, please use netip.ParseAddr(...)
	addr, err := netip.ParseAddr(ip)
	if err != nil {
		return nil, errors.Wrapf(err, "ParseIP[%s] error", ip)
	}

	return &addr, nil
}

// Accepts an IP and a CIDR as strings and returns
// a string merging the two.
func GetIpCidrString(ip string, cidr string) (string, error) {
	_, ipNet, err := net.ParseCIDR(cidr)
	if err != nil {
		return "", errors.Wrapf(err, "GetIpCidrString[%s] error", cidr)
	}

	network := *ipNet
	network.IP = net.ParseIP(ip)

	return network.String(), nil
}

// This function accepts a list of strings and returns the next IP not in this
// list. If we overflow the server CIDR, an error is returned.
func GetAvailableIP(ips []string, cidr string) (string, *net.IPNet, error) {
	ip, ipNet, err := net.ParseCIDR(cidr)
	if err != nil {
		return "", nil, errors.Wrapf(err, "GetAvailableIP[%s] error", cidr)
	}

	for slices.Contains(ips, ip.String()) {
		ip = IterIP(ip)
	}

	if !ipNet.Contains(ip) {
		return "", nil, errors.New("exhausted ip addresses")
	}

	return ip.String(), ipNet, nil
}

// Increments an IP, skipping broadcast addresses.
// 这个函数会修改 ip
func IterIP(netIp net.IP) net.IP {
	ip := make(net.IP, len(netIp))
	copy(ip, netIp)

	// for 循环会修改 ip, 因此前面用copy
	for i := len(ip) - 1; i >= 0; i-- {
		ip[i]++
		if ip[i] == 255 {
			ip[i-1]++
			ip[i] = 1
		}
		if ip[i] > 0 {
			break
		}
	}
	return ip
}

func GetSubnetFirstIP(ip string) string {
	i := strings.Split(ip, "/")[0] // Remove CIDR.
	s := strings.Split(i, ".")
	peerIPStrings := []string{s[0], s[1], s[2], "1"} // RIP CIDR larger than a /24
	peerIP := strings.Join(peerIPStrings, ".")
	return peerIP
}

// if peerIP not empty return peerId, otherwise return the first ip of my ip subnet
func GetPeerIP(peerCidrIP string, myCidrIP string) string {
	if peerCidrIP != "" {
		i := strings.Split(peerCidrIP, "/")[0] // Remove CIDR.
		return i                               //
	}
	return GetSubnetFirstIP(myCidrIP)
}

// deprecated
// return 255.255.0.0
func IpMaskToIPv4StringOld(mask net.IPMask) string {
	// 将IPMask转换为net.IP类型
	ip := net.IP(mask)
	// 转换为4字节表示
	ipv4 := ip.To4()
	if ipv4 == nil {
		return "" // 非IPv4掩码
	}
	// 转换为点分十进制格式
	return fmt.Sprintf("%d.%d.%d.%d", ipv4[0], ipv4[1], ipv4[2], ipv4[3])
}

// return 255.255.0.0
func IpMaskToIPv4String(mask net.IPMask) string {
	return net.IP(mask).String()
}

// return 255.255.0.0
func IpNetToIPv4String(ipNet *net.IPNet) string {
	return IpMaskToIPv4String(ipNet.Mask)
}

// 将任意 IP/前缀转换为标准网段格式
// 如 10.64.0.1/16 → 10.64.0.0/16
func GetNetwork(cidrIp string) (string, error) {
	_, ipNet, err := net.ParseCIDR(cidrIp)
	if err != nil {
		return "", err
	}
	// ipNet.String() 就得到 10.64.0.0/16
	return ipNet.String(), nil
}