package Common

/*
ParseIP.go - IP地址解析器（重构版）

此文件现在作为向后兼容的包装层，内部委托给新的parsers模块。
原有的复杂解析逻辑已迁移到parsers/TargetParser.go中，
提供更好的错误处理、线程安全和功能扩展。

向后兼容性：
- 保持原有函数签名不变
- 保持原有返回值格式
- 支持所有原有功能（IP范围、CIDR、网段简写等）
*/

import (
	"errors"
	"strings"
	
	"github.com/shadow1ng/fscan/Common/parsers"
)

// IP解析相关错误
var (
	ErrParseIP = errors.New(GetText("parse_ip_error")) // IP解析失败的统一错误
)

// ParseIP 解析各种格式的IP地址（向后兼容包装函数）
// 参数:
//   - host: 主机地址（可以是单个IP、IP范围、CIDR或常用网段简写）
//   - filename: 包含主机地址的文件名
//   - nohosts: 需要排除的主机地址列表
//
// 返回:
//   - []string: 解析后的IP地址列表
//   - error: 解析过程中的错误
func ParseIP(host string, filename string, nohosts ...string) (hosts []string, err error) {
	// 委托给新的parsers模块
	hosts, err = parsers.ParseIP(host, filename, nohosts...)
	if err != nil {
		LogError(GetText("parse_ip_error") + ": " + err.Error())
		return nil, ErrParseIP
	}

	// 处理主机和端口组合的情况 (格式: IP:PORT)
	// 这个逻辑需要保持向后兼容
	if filename == "" && len(hosts) > 0 {
		// 检查原始输入是否包含端口
		if strings.Contains(host, ":") {
			hostport := strings.Split(host, ":")
			if len(hostport) == 2 {
				Ports = hostport[1]
				LogBase(GetText("host_port_parsed", Ports))
			}
		}
	}

	LogBase(GetText("final_valid_hosts", len(hosts)))
	return hosts, nil
}

// parseIPList 解析逗号分隔的IP地址列表（已弃用，重定向到parsers模块）
// 保留此函数以确保向后兼容性
func parseIPList(ipList string) []string {
	hosts, err := parsers.ParseIP(ipList, "") 
	if err != nil {
		LogError(GetText("parse_ip_error") + ": " + err.Error())
		return nil
	}
	return hosts
}

// parseSingleIP 解析单个IP地址或IP范围（已弃用，重定向到parsers模块）
// 保留此函数以确保向后兼容性
func parseSingleIP(ip string) []string {
	hosts, err := parsers.ParseIP(ip, "")
	if err != nil {
		LogError(GetText("invalid_ip_format", ip))
		return nil
	}
	return hosts
}

// parseCIDR 解析CIDR格式的IP地址段（已弃用，重定向到parsers模块）
// 保留此函数以确保向后兼容性
func parseCIDR(cidr string) []string {
	hosts, err := parsers.ParseIP(cidr, "")
	if err != nil {
		LogError(GetText("cidr_parse_failed", cidr, err))
		return nil
	}
	LogBase(GetText("parse_cidr_to_range", cidr, ""))
	return hosts
}

// calculateIPRange 计算CIDR的起始IP和结束IP（已弃用）
// 此函数已迁移到parsers模块，保留以确保向后兼容性
func calculateIPRange(cidr interface{}) string {
	// 此函数已弃用，功能已集成到parsers模块中
	return ""
}

// parseIPRange 解析IP范围格式的地址（已弃用，重定向到parsers模块）
// 保留此函数以确保向后兼容性
func parseIPRange(ipRange string) []string {
	hosts, err := parsers.ParseIP(ipRange, "")
	if err != nil {
		LogError(GetText("ip_range_format_error", ipRange))
		return nil
	}
	return hosts
}

// parseShortIPRange 解析简写格式的IP范围（已弃用）
// 此函数已迁移到parsers模块，保留以确保向后兼容性
func parseShortIPRange(startIP, endSuffix string) []string {
	hosts, err := parsers.ParseIP(startIP+"-"+endSuffix, "")
	if err != nil {
		LogError(GetText("ip_range_format_error", startIP+"-"+endSuffix))
		return nil
	}
	return hosts
}

// parseFullIPRange 解析完整格式的IP范围（已弃用）
// 此函数已迁移到parsers模块，保留以确保向后兼容性
func parseFullIPRange(startIP, endIP string) []string {
	hosts, err := parsers.ParseIP(startIP+"-"+endIP, "")
	if err != nil {
		LogError(GetText("ip_format_error", startIP+"-"+endIP))
		return nil
	}
	return hosts
}

// parseSubnet8 解析/8网段的IP地址，生成采样IP列表（已弃用）
// 此函数已迁移到parsers模块，保留以确保向后兼容性
func parseSubnet8(subnet string) []string {
	hosts, err := parsers.ParseIP(subnet, "")
	if err != nil {
		LogError(GetText("invalid_ip_format", subnet))
		return nil
	}
	LogBase(GetText("sample_ip_generated", len(hosts)))
	return hosts
}

// readIPFile 从文件中按行读取IP地址（已弃用，重定向到parsers模块）
// 保留此函数以确保向后兼容性，但建议使用parsers模块的文件读取功能
func readIPFile(filename string) ([]string, error) {
	// 委托给parsers模块
	hosts, err := parsers.ParseIP("", filename)
	if err != nil {
		LogError(GetText("open_file_failed", filename, err))
		return nil, err
	}

	LogBase(GetText("file_parse_complete", len(hosts)))
	return hosts, nil
}

// excludeHosts 从主机列表中排除指定的主机（已弃用）
// 此函数已集成到parsers模块的解析过程中，保留以确保向后兼容性
func excludeHosts(hosts []string, nohosts []string) []string {
	// 如果没有需要排除的主机，直接返回原列表
	if len(nohosts) == 0 || nohosts[0] == "" {
		return hosts
	}

	// 使用parsers模块的功能
	result, err := parsers.ParseIP(strings.Join(hosts, ","), "", nohosts...)
	if err != nil {
		LogError(GetText("hosts_excluded", 0))
		return hosts
	}

	LogBase(GetText("hosts_excluded", len(hosts)-len(result)))
	return result
}

// removeDuplicateIPs 去除重复的IP地址（已弃用）
// 此功能已集成到parsers模块中，保留以确保向后兼容性
func removeDuplicateIPs(ips []string) []string {
	// 使用parsers模块的去重功能
	result, err := parsers.ParseIP(strings.Join(ips, ","), "")
	if err != nil {
		return ips
	}
	return result
}

// randomInt 生成指定范围内的随机整数（已弃用）
// 此函数已迁移到parsers模块，保留以确保向后兼容性
func randomInt(min, max int) int {
	if min >= max || min < 0 || max <= 0 {
		return max
	}
	return min + (max-min)/2 // 简化版本
}