package config

import (
	"errors"
	"testing"
)

func TestParseQueryTypeValid(t *testing.T) {
	cases := []struct {
		input    string
		wantType uint16
	}{
		{"A", 1},
		{"aaaa", 28},
		{"NS", 2},
		{"CNAME", 5},
		{"MX", 15},
		{"TXT", 16},
		{"SOA", 6},
		{"PTR", 12},
		{"ANY", 255},
	}
	for _, tc := range cases {
		got, err := ParseQueryType(tc.input)
		if err != nil {
			t.Errorf("ParseQueryType(%q) unexpected error: %v", tc.input, err)
		}
		if got != tc.wantType {
			t.Errorf("ParseQueryType(%q) = %d, want %d", tc.input, got, tc.wantType)
		}
	}
}

func TestParseQueryTypeInvalid(t *testing.T) {
	_, err := ParseQueryType("BOGUS")
	if err == nil {
		t.Fatal("expected error for invalid query type")
	}
	if !errors.Is(err, ErrInvalidQueryType) {
		t.Errorf("expected ErrInvalidQueryType, got %v", err)
	}
}

func TestValidateOK(t *testing.T) {
	cfg := DefaultConfig()
	if err := cfg.Validate(); err != nil {
		t.Fatalf("DefaultConfig should be valid, got: %v", err)
	}
}

func TestValidateAlwaysTCPRequiresAllowTCP(t *testing.T) {
	cfg := DefaultConfig()
	cfg.AlwaysTCP = true
	cfg.AllowTCP = false
	err := cfg.Validate()
	if err == nil {
		t.Fatal("expected error when AlwaysTCP=true and AllowTCP=false")
	}
	if !errors.Is(err, ErrAlwaysTCPRequiresTCP) {
		t.Errorf("expected ErrAlwaysTCPRequiresTCP, got %v", err)
	}
}

func TestValidateAlwaysTCPWithAllowTCP(t *testing.T) {
	cfg := DefaultConfig()
	cfg.AlwaysTCP = true
	cfg.AllowTCP = true
	if err := cfg.Validate(); err != nil {
		t.Errorf("AlwaysTCP=true, AllowTCP=true should be valid, got: %v", err)
	}
}

func TestValidateBadUDPSize(t *testing.T) {
	cfg := DefaultConfig()
	cfg.UDPSize = 100
	if err := cfg.Validate(); !errors.Is(err, ErrInvalidUDPSize) {
		t.Errorf("expected ErrInvalidUDPSize, got %v", err)
	}
}

func TestValidateBadMaxDepth(t *testing.T) {
	cfg := DefaultConfig()
	cfg.MaxDepth = 0
	if err := cfg.Validate(); !errors.Is(err, ErrInvalidMaxDepth) {
		t.Errorf("expected ErrInvalidMaxDepth, got %v", err)
	}
}

func TestValidateBadRetries(t *testing.T) {
	cfg := DefaultConfig()
	cfg.Retries = 11
	if err := cfg.Validate(); !errors.Is(err, ErrInvalidRetries) {
		t.Errorf("expected ErrInvalidRetries, got %v", err)
	}
}

func TestGetDomainOK(t *testing.T) {
	cfg := DefaultConfig()
	d, err := cfg.GetDomain([]string{"example.com"})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if d != "example.com" {
		t.Errorf("got %q, want %q", d, "example.com")
	}
}

func TestGetDomainMissing(t *testing.T) {
	cfg := DefaultConfig()
	_, err := cfg.GetDomain([]string{})
	if err == nil {
		t.Fatal("expected error for missing domain")
	}
	if !errors.Is(err, ErrMissingDomain) {
		t.Errorf("expected ErrMissingDomain, got %v", err)
	}
}

func TestParseDebugLevel(t *testing.T) {
	cases := []struct {
		d, dd bool
		want  int
	}{
		{false, false, 0},
		{true, false, 1},
		{false, true, 2},
		{true, true, 2}, // dd takes precedence
	}
	for _, tc := range cases {
		got := ParseDebugLevel(tc.d, tc.dd)
		if got != tc.want {
			t.Errorf("ParseDebugLevel(d=%v, dd=%v) = %d, want %d", tc.d, tc.dd, got, tc.want)
		}
	}
}

func TestPrintUsage(t *testing.T) {
	// PrintUsage writes to stderr; just ensure it doesn't panic.
	PrintUsage()
}

func TestValidateBadQueryType(t *testing.T) {
	cfg := DefaultConfig()
	cfg.QueryType = "BOGUS"
	if err := cfg.Validate(); !errors.Is(err, ErrInvalidQueryType) {
		t.Errorf("expected ErrInvalidQueryType, got %v", err)
	}
}

func TestDefaultConfigIsValid(t *testing.T) {
	cfg := DefaultConfig()
	if cfg.QueryType != "a" {
		t.Errorf("QueryType = %q, want a", cfg.QueryType)
	}
	if cfg.ShowResolves || cfg.ShowServers || cfg.ShowAllStats {
		t.Error("show-resolves/show-servers/show-all-stats must default to false")
	}
	if !cfg.ShowProgress || !cfg.ShowVersions || !cfg.ShowResults || !cfg.ShowSummaryResults {
		t.Error("show-progress/show-versions/show-results/show-summary-results must default to true")
	}
	if cfg.MaxDepth != 20 {
		t.Errorf("MaxDepth = %d, want 20", cfg.MaxDepth)
	}
	if cfg.Retries != 2 {
		t.Errorf("Retries = %d, want 2", cfg.Retries)
	}
}