package config

import (
	"testing"
	"time"
)

const validConfig = `
maglev:
  frontend:
    probe-ipv4-src: 10.0.0.1
    probe-ipv6-src: 2001:db8:1::1
    healthcheck-netns: dataplane
    healthchecker:
      transition-history: 5
    vips:
      web4:
        description: "IPv4 VIP"
        address: 192.0.2.1
        protocol: tcp
        port: 80
        backends: [2001:db8:2::1, 2001:db8:2::2]
        healthcheck:
          type: http
          params:
            path: /healthz
            host: example.com
            response-code: "200"
          interval: 2s
          timeout: 3s
          rise: 2
          fall: 3
      web6:
        description: "IPv6 VIP"
        address: 2001:db8::1
        protocol: tcp
        port: 443
        backends: [2001:db8:2::1, 2001:db8:2::2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 3s
          fall: 5
`

func TestValidConfig(t *testing.T) {
	f, err := parse([]byte(validConfig))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if f.ProbeIPv4Src.String() != "10.0.0.1" {
		t.Errorf("probe-ipv4-src: got %s, want 10.0.0.1", f.ProbeIPv4Src)
	}
	if f.ProbeIPv6Src.String() != "2001:db8:1::1" {
		t.Errorf("probe-ipv6-src: got %s, want 2001:db8:1::1", f.ProbeIPv6Src)
	}
	if f.HealthCheckNetns != "dataplane" {
		t.Errorf("healthcheck-netns: got %q, want %q", f.HealthCheckNetns, "dataplane")
	}
	if f.HealthChecker.TransitionHistory != 5 {
		t.Errorf("transition-history: got %d, want 5", f.HealthChecker.TransitionHistory)
	}
	if len(f.VIPs) != 2 {
		t.Fatalf("vips: got %d, want 2", len(f.VIPs))
	}
	web4 := f.VIPs["web4"]
	if web4.HealthCheck.Type != "http" {
		t.Errorf("web4 healthcheck type: got %q, want http", web4.HealthCheck.Type)
	}
	if web4.HealthCheck.Fall != 3 {
		t.Errorf("web4 fall: got %d, want 3", web4.HealthCheck.Fall)
	}
	if web4.HealthCheck.Rise != 2 {
		t.Errorf("web4 rise: got %d, want 2", web4.HealthCheck.Rise)
	}
	if web4.HealthCheck.HTTP == nil {
		t.Fatal("web4 HTTP params should not be nil")
	}
	if web4.HealthCheck.HTTP.Path != "/healthz" {
		t.Errorf("web4 params.path: got %q, want /healthz", web4.HealthCheck.HTTP.Path)
	}
	if web4.HealthCheck.HTTP.Host != "example.com" {
		t.Errorf("web4 params.host: got %q, want example.com", web4.HealthCheck.HTTP.Host)
	}
	if web4.HealthCheck.HTTP.ResponseCodeMin != 200 || web4.HealthCheck.HTTP.ResponseCodeMax != 200 {
		t.Errorf("web4 response-code: got %d-%d, want 200-200",
			web4.HealthCheck.HTTP.ResponseCodeMin, web4.HealthCheck.HTTP.ResponseCodeMax)
	}
	web6 := f.VIPs["web6"]
	if web6.HealthCheck.Fall != 5 {
		t.Errorf("web6 fall: got %d, want 5", web6.HealthCheck.Fall)
	}
}

func TestDefaults(t *testing.T) {
	cfg := `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`
	f, err := parse([]byte(cfg))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if f.HealthCheckNetns != "" {
		t.Errorf("default healthcheck-netns: got %q, want empty (default netns)", f.HealthCheckNetns)
	}
	if f.HealthChecker.TransitionHistory != 5 {
		t.Errorf("default transition-history: got %d, want 5", f.HealthChecker.TransitionHistory)
	}
	hc := f.VIPs["v"].HealthCheck
	if hc.Rise != 2 {
		t.Errorf("default rise: got %d, want 2", hc.Rise)
	}
	if hc.Fall != 3 {
		t.Errorf("default fall: got %d, want 3", hc.Fall)
	}
	if f.ProbeIPv4Src != nil {
		t.Errorf("probe-ipv4-src should be nil when omitted, got %s", f.ProbeIPv4Src)
	}
}

func TestOptionalIntervals(t *testing.T) {
	cfg := `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 2s
          fast-interval: 500ms
          down-interval: 30s
          timeout: 1s
`
	f, err := parse([]byte(cfg))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	hc := f.VIPs["v"].HealthCheck
	if hc.Interval != 2*time.Second {
		t.Errorf("interval: got %v, want 2s", hc.Interval)
	}
	if hc.FastInterval != 500*time.Millisecond {
		t.Errorf("fast-interval: got %v, want 500ms", hc.FastInterval)
	}
	if hc.DownInterval != 30*time.Second {
		t.Errorf("down-interval: got %v, want 30s", hc.DownInterval)
	}
}

func TestTCPType(t *testing.T) {
	cfg := `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        protocol: tcp
        port: 80
        backends: [10.0.0.2]
        healthcheck:
          type: tcp
          interval: 1s
          timeout: 2s
`
	f, err := parse([]byte(cfg))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if f.VIPs["v"].HealthCheck.Type != "tcp" {
		t.Errorf("type: got %q, want tcp", f.VIPs["v"].HealthCheck.Type)
	}
}

func TestValidationErrors(t *testing.T) {
	// Minimal valid base to build error cases on top of.
	base := func(override string) string {
		return `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
` + override
	}
	_ = base

	tests := []struct {
		name   string
		yaml   string
		errSub string
	}{
		{
			name: "wrong family probe-ipv4-src",
			yaml: `
maglev:
  frontend:
    probe-ipv4-src: 2001:db8::1
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`,
			errSub: "probe-ipv4-src",
		},
		{
			name: "mixed backend families",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2, 2001:db8::1]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`,
			errSub: "address family",
		},
		{
			name: "port without protocol",
			yaml: validPortWithoutProtocol,

			errSub: "port requires protocol",
		},
		{
			name: "protocol without port",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        protocol: tcp
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`,
			errSub: "requires port",
		},
		{
			name: "invalid healthcheck type",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: dns
          interval: 1s
          timeout: 2s
`,
			errSub: "type must be",
		},
		{
			name: "http missing path",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: http
          interval: 1s
          timeout: 2s
`,
			errSub: "params.path",
		},
		{
			name: "negative interval",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: -1s
          timeout: 2s
`,
			errSub: "positive duration",
		},
		{
			name: "invalid fast-interval",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          fast-interval: -1s
          timeout: 2s
`,
			errSub: "positive duration",
		},
		{
			name: "fall zero becomes default",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
          fall: 0
`,
			// fall: 0 is treated as omitted → default 3; no error
			errSub: "",
		},
		{
			name: "empty backends",
			yaml: `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        backends: []
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`,
			errSub: "backends must not be empty",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := parse([]byte(tt.yaml))
			if tt.errSub == "" {
				if err != nil {
					t.Fatalf("expected no error, got: %v", err)
				}
				return
			}
			if err == nil {
				t.Fatalf("expected error containing %q, got nil", tt.errSub)
			}
			if !contains(err.Error(), tt.errSub) {
				t.Errorf("error %q does not contain %q", err.Error(), tt.errSub)
			}
		})
	}
}

const validPortWithoutProtocol = `
maglev:
  frontend:
    vips:
      v:
        address: 192.0.2.1
        port: 80
        backends: [10.0.0.2]
        healthcheck:
          type: icmp
          interval: 1s
          timeout: 2s
`

func contains(s, sub string) bool {
	return len(s) >= len(sub) && (s == sub || len(sub) == 0 ||
		func() bool {
			for i := 0; i <= len(s)-len(sub); i++ {
				if s[i:i+len(sub)] == sub {
					return true
				}
			}
			return false
		}())
}