package parsers

import (
	"reflect"
	"testing"
)

// TestParsePort 测试端口解析功能
func TestParsePort(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected []int
	}{
		{
			name:     "Simple ports",
			input:    "80,443,22",
			expected: []int{22, 80, 443}, // sorted
		},
		{
			name:     "Port range",
			input:    "80-85",
			expected: []int{80, 81, 82, 83, 84, 85},
		},
		{
			name:     "Mixed ports and ranges",
			input:    "22,80-82,443",
			expected: []int{22, 80, 81, 82, 443}, // sorted
		},
		{
			name:     "Predefined group",
			input:    "web",
			expected: []int{80, 443, 8080, 8443}, // subset of web ports
		},
		{
			name:     "Empty string",
			input:    "",
			expected: nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := ParsePort(tt.input)
			
			// For predefined groups, we just check if common ports are included
			if tt.name == "Predefined group" {
				hasExpectedPorts := false
				for _, expectedPort := range tt.expected {
					for _, resultPort := range result {
						if resultPort == expectedPort {
							hasExpectedPorts = true
							break
						}
					}
					if !hasExpectedPorts {
						break
					}
				}
				if !hasExpectedPorts {
					t.Errorf("ParsePort(%s) does not contain expected common web ports %v", tt.input, tt.expected)
				}
			} else {
				if !reflect.DeepEqual(result, tt.expected) {
					t.Errorf("ParsePort(%s) = %v, expected %v", tt.input, result, tt.expected)
				}
			}
		})
	}
}

// TestParseIP 测试IP解析功能
func TestParseIP(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected int // expected number of IPs
	}{
		{
			name:     "Single IP",
			input:    "192.168.1.1",
			expected: 1,
		},
		{
			name:     "CIDR notation",
			input:    "192.168.1.0/30",
			expected: 4, // 192.168.1.0-3
		},
		{
			name:     "IP range",
			input:    "192.168.1.1-192.168.1.3",
			expected: 3,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ParseIP(tt.input, "", "")
			if err != nil {
				t.Errorf("ParseIP(%s) returned error: %v", tt.input, err)
				return
			}
			if len(result) != tt.expected {
				t.Errorf("ParseIP(%s) returned %d IPs, expected %d", tt.input, len(result), tt.expected)
			}
		})
	}
}

// TestParsePortsFromString 测试端口字符串解析功能
func TestParsePortsFromString(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected []int
	}{
		{
			name:     "Valid ports",
			input:    "80,443,22",
			expected: []int{22, 80, 443}, // sorted
		},
		{
			name:     "Empty string",
			input:    "",
			expected: []int{},
		},
		{
			name:     "With spaces",
			input:    " 80 , 443 , 22 ",
			expected: []int{22, 80, 443},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := ParsePortsFromString(tt.input)
			if !reflect.DeepEqual(result, tt.expected) {
				t.Errorf("ParsePortsFromString(%s) = %v, expected %v", tt.input, result, tt.expected)
			}
		})
	}
}