func IsValidIP(ip string) bool

package main

import (
    "fmt"
    "github.com/woodchen-ink/go-web-utils/iputil"
)

func main() {
    testIPs := []string{
        "192.168.1.1",      // ✅ 有效的 IPv4
        "2001:db8::1",      // ✅ 有效的 IPv6
        "::1",              // ✅ IPv6 回环地址
        "invalid-ip",       // ❌ 无效格式
        "192.168.1.256",    // ❌ 超出范围
        "",                 // ❌ 空字符串
        "192.168.1",        // ❌ 不完整的 IPv4
    }
    
    for _, ip := range testIPs {
        if iputil.IsValidIP(ip) {
            fmt.Printf("✅ %s 是有效的 IP 地址\n", ip)
        } else {
            fmt.Printf("❌ %s 不是有效的 IP 地址\n", ip)
        }
    }
}

✅ 192.168.1.1 是有效的 IP 地址
✅ 2001:db8::1 是有效的 IP 地址
✅ ::1 是有效的 IP 地址
❌ invalid-ip 不是有效的 IP 地址
❌ 192.168.1.256 不是有效的 IP 地址
❌  不是有效的 IP 地址
❌ 192.168.1 不是有效的 IP 地址

func validateIPInput(w http.ResponseWriter, r *http.Request) {
    ipStr := r.FormValue("ip")
    
    if !iputil.IsValidIP(ipStr) {
        http.Error(w, "无效的 IP 地址格式", http.StatusBadRequest)
        return
    }
    
    fmt.Fprintf(w, "有效的 IP 地址: %s", ipStr)
}

type ServerConfig struct {
    AllowedIPs []string `json:"allowed_ips"`
    BlockedIPs []string `json:"blocked_ips"`
}

func validateConfig(config *ServerConfig) error {
    // 验证允许的 IP 列表
    for _, ip := range config.AllowedIPs {
        if !iputil.IsValidIP(ip) {
            return fmt.Errorf("无效的允许 IP: %s", ip)
        }
    }
    
    // 验证阻止的 IP 列表
    for _, ip := range config.BlockedIPs {
        if !iputil.IsValidIP(ip) {
            return fmt.Errorf("无效的阻止 IP: %s", ip)
        }
    }
    
    return nil
}

type IPFilter struct {
    whitelist map[string]bool
    blacklist map[string]bool
}

func NewIPFilter() *IPFilter {
    return &IPFilter{
        whitelist: make(map[string]bool),
        blacklist: make(map[string]bool),
    }
}

func (f *IPFilter) AddToWhitelist(ip string) error {
    if !iputil.IsValidIP(ip) {
        return fmt.Errorf("无效的 IP 地址: %s", ip)
    }
    f.whitelist[ip] = true
    return nil
}

func (f *IPFilter) AddToBlacklist(ip string) error {
    if !iputil.IsValidIP(ip) {
        return fmt.Errorf("无效的 IP 地址: %s", ip)
    }
    f.blacklist[ip] = true
    return nil
}

func (f *IPFilter) IsAllowed(ip string) bool {
    // 先检查黑名单
    if f.blacklist[ip] {
        return false
    }
    
    // 如果白名单为空，默认允许
    if len(f.whitelist) == 0 {
        return true
    }
    
    // 检查白名单
    return f.whitelist[ip]
}

func secureHandler(w http.ResponseWriter, r *http.Request) {
    // 获取客户端 IP
    clientIP := iputil.GetClientIP(r)
    
    // 验证 IP 格式
    if !iputil.IsValidIP(clientIP) {
        log.Printf("获取到无效的客户端 IP: %s", clientIP)
        http.Error(w, "无法识别客户端 IP", http.StatusBadRequest)
        return
    }
    
    // 进一步处理
    if iputil.IsPrivateIP(clientIP) {
        fmt.Fprintf(w, "内网用户，IP: %s", clientIP)
    } else {
        fmt.Fprintf(w, "外网用户，IP: %s", clientIP)
    }
}

type IPRangeRequest struct {
    StartIP string `json:"start_ip"`
    EndIP   string `json:"end_ip"`
}

func validateIPRange(w http.ResponseWriter, r *http.Request) {
    var req IPRangeRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "无效的 JSON", http.StatusBadRequest)
        return
    }
    
    // 验证起始 IP
    if !iputil.IsValidIP(req.StartIP) {
        http.Error(w, "无效的起始 IP 地址", http.StatusBadRequest)
        return
    }
    
    // 验证结束 IP
    if !iputil.IsValidIP(req.EndIP) {
        http.Error(w, "无效的结束 IP 地址", http.StatusBadRequest)
        return
    }
    
    fmt.Fprintf(w, "IP 范围有效: %s - %s", req.StartIP, req.EndIP)
}

func processIPList(ips []string) ([]string, error) {
    var validIPs []string
    var invalidIPs []string
    
    for _, ip := range ips {
        if iputil.IsValidIP(ip) {
            validIPs = append(validIPs, ip)
        } else {
            invalidIPs = append(invalidIPs, ip)
        }
    }
    
    if len(invalidIPs) > 0 {
        return validIPs, fmt.Errorf("发现 %d 个无效的 IP 地址: %v", 
            len(invalidIPs), invalidIPs)
    }
    
    return validIPs, nil
}

func IsValidIP(ip string) bool {
    return net.ParseIP(ip) != nil
}