package services

import (
	"os"
	"path/filepath"
	"testing"
)

func TestRegisterAndGet(t *testing.T) {
	mgr := NewManager(t.TempDir())

	svc := Service{
		Domain: "my-api.payne.io",
		Source: "wild-works",
		Backend: Backend{
			Address: "192.168.8.60:9001",
			Type:    BackendHTTP,
		},
		// Public defaults to false
	}

	if err := mgr.Register(svc); err != nil {
		t.Fatalf("Register failed: %v", err)
	}

	got, err := mgr.Get("my-api.payne.io")
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}

	if got.Domain != "my-api.payne.io" {
		t.Errorf("expected domain my-api.payne.io, got %s", got.Domain)
	}
	if got.Backend.Address != "192.168.8.60:9001" {
		t.Errorf("expected backend 192.168.8.60:9001, got %s", got.Backend.Address)
	}
	if got.TLS != TLSTerminate {
		t.Errorf("expected TLS terminate (default for http), got %s", got.TLS)
	}
	if got.Source != "wild-works" {
		t.Errorf("expected source wild-works, got %s", got.Source)
	}
}

func TestRegisterTCPPassthrough(t *testing.T) {
	mgr := NewManager(t.TempDir())

	svc := Service{
		Domain: "cloud.payne.io",
		Source: "wild-cloud",
		Backend: Backend{
			Address: "192.168.8.240:443",
			Type:    BackendTCPPassthrough,
		},
		Subdomains: true,
		Public: true,
	}

	if err := mgr.Register(svc); err != nil {
		t.Fatalf("Register failed: %v", err)
	}

	got, err := mgr.Get("cloud.payne.io")
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}

	if got.TLS != TLSPassthrough {
		t.Errorf("expected TLS passthrough for tcp-passthrough, got %s", got.TLS)
	}
	if !got.Subdomains {
		t.Error("expected subdomains=true")
	}
	if !got.Public {
		t.Error("expected public=true")
	}
}

func TestListServices(t *testing.T) {
	mgr := NewManager(t.TempDir())

	for _, domain := range []string{"a.example.com", "b.example.com", "c.example.com"} {
		if err := mgr.Register(Service{
			Domain:  domain,
			Source:  "test",
			Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
			// Public defaults to false
		}); err != nil {
			t.Fatalf("Register %s failed: %v", domain, err)
		}
	}

	svcs, err := mgr.List()
	if err != nil {
		t.Fatalf("List failed: %v", err)
	}
	if len(svcs) != 3 {
		t.Errorf("expected 3 services, got %d", len(svcs))
	}
}

func TestDeregister(t *testing.T) {
	mgr := NewManager(t.TempDir())

	if err := mgr.Register(Service{
		Domain:  "temp.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
		// Public defaults to false
	}); err != nil {
		t.Fatalf("Register failed: %v", err)
	}

	if err := mgr.Deregister("temp.example.com"); err != nil {
		t.Fatalf("Deregister failed: %v", err)
	}

	if _, err := mgr.Get("temp.example.com"); err == nil {
		t.Error("expected error after deregister, got nil")
	}
}

func TestDeregisterBySource(t *testing.T) {
	mgr := NewManager(t.TempDir())

	// Register 3 services from wild-cloud with same backend
	for _, domain := range []string{"cloud.payne.io", "internal.cloud.payne.io", "payne.io"} {
		mgr.Register(Service{
			Domain:  domain,
			Source:  "wild-cloud",
			Backend: Backend{Address: "192.168.8.240:443", Type: BackendTCPPassthrough},
			Public: true,
		})
	}
	// Register 1 service from wild-works (different source)
	mgr.Register(Service{
		Domain:  "my-api.payne.io",
		Source:  "wild-works",
		Backend: Backend{Address: "127.0.0.1:9001", Type: BackendHTTP},
		// Public defaults to false
	})

	// Deregister all wild-cloud services with backend 192.168.8.240:443
	if err := mgr.DeregisterBySource("wild-cloud", "192.168.8.240:443"); err != nil {
		t.Fatalf("DeregisterBySource failed: %v", err)
	}

	svcs, _ := mgr.List()
	if len(svcs) != 1 {
		t.Errorf("expected 1 remaining service, got %d", len(svcs))
	}
	if svcs[0].Domain != "my-api.payne.io" {
		t.Errorf("expected wild-works service to remain, got %s", svcs[0].Domain)
	}
}

func TestUpdate(t *testing.T) {
	mgr := NewManager(t.TempDir())

	mgr.Register(Service{
		Domain:  "updatable.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
		// Public defaults to false
	})

	if err := mgr.Update("updatable.example.com", map[string]any{
		"public":     true,
		"subdomains": true,
	}); err != nil {
		t.Fatalf("Update failed: %v", err)
	}

	got, _ := mgr.Get("updatable.example.com")
	if !got.Public {
		t.Error("expected public=true after update")
	}
	if !got.Subdomains {
		t.Error("expected subdomains=true after update")
	}
}

func TestRegisterValidation(t *testing.T) {
	mgr := NewManager(t.TempDir())

	// Missing domain
	if err := mgr.Register(Service{Backend: Backend{Address: "127.0.0.1:80", Type: BackendHTTP}}); err == nil {
		t.Error("expected error for missing domain")
	}

	// Missing backend address
	if err := mgr.Register(Service{Domain: "x.com", Backend: Backend{Type: BackendHTTP}}); err == nil {
		t.Error("expected error for missing backend address")
	}

	// Missing backend type
	if err := mgr.Register(Service{Domain: "x.com", Backend: Backend{Address: "127.0.0.1:80"}}); err == nil {
		t.Error("expected error for missing backend type")
	}
}

func TestDefaultSource(t *testing.T) {
	mgr := NewManager(t.TempDir())

	mgr.Register(Service{
		Domain:  "test.com",
		Backend: Backend{Address: "127.0.0.1:80", Type: BackendHTTP},
		// Public defaults to false
	})

	got, _ := mgr.Get("test.com")
	if got.Source != "manual" {
		t.Errorf("expected default source 'manual', got %s", got.Source)
	}
}

func TestRegisterIdempotent(t *testing.T) {
	mgr := NewManager(t.TempDir())

	svc := Service{
		Domain:  "idempotent.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
		// Public defaults to false
	}

	// Register twice with same domain
	if err := mgr.Register(svc); err != nil {
		t.Fatalf("first Register failed: %v", err)
	}

	// Update the backend address on second registration
	svc.Backend.Address = "127.0.0.1:9090"
	if err := mgr.Register(svc); err != nil {
		t.Fatalf("second Register failed: %v", err)
	}

	// Should still have only one service
	svcs, err := mgr.List()
	if err != nil {
		t.Fatalf("List failed: %v", err)
	}
	if len(svcs) != 1 {
		t.Errorf("expected 1 service after idempotent register, got %d", len(svcs))
	}

	// Should have the updated address
	got, err := mgr.Get("idempotent.example.com")
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}
	if got.Backend.Address != "127.0.0.1:9090" {
		t.Errorf("expected updated backend address 127.0.0.1:9090, got %s", got.Backend.Address)
	}
}

func TestListNoDuplicates(t *testing.T) {
	mgr := NewManager(t.TempDir())

	domains := []string{
		"alpha.example.com",
		"beta.example.com",
		"gamma.example.com",
	}

	// Register each domain
	for _, domain := range domains {
		if err := mgr.Register(Service{
			Domain:  domain,
			Source:  "test",
			Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
			// Public defaults to false
		}); err != nil {
			t.Fatalf("Register %s failed: %v", domain, err)
		}
	}

	// Re-register one domain to verify no duplication
	if err := mgr.Register(Service{
		Domain:  "beta.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:9090", Type: BackendHTTP},
		// Public defaults to false
	}); err != nil {
		t.Fatalf("Re-register beta failed: %v", err)
	}

	svcs, err := mgr.List()
	if err != nil {
		t.Fatalf("List failed: %v", err)
	}

	if len(svcs) != 3 {
		t.Errorf("expected 3 unique services, got %d", len(svcs))
	}

	// Verify no duplicate domains
	seen := make(map[string]bool)
	for _, svc := range svcs {
		if seen[svc.Domain] {
			t.Errorf("duplicate domain in List(): %s", svc.Domain)
		}
		seen[svc.Domain] = true
	}
}

func TestDomainToFilename(t *testing.T) {
	tests := []struct {
		domain   string
		expected string
	}{
		{"cloud.payne.io", "cloud_payne_io.yaml"},
		{"internal.cloud.payne.io", "internal_cloud_payne_io.yaml"},
		{"payne.io", "payne_io.yaml"},
		{"example.com", "example_com.yaml"},
	}
	for _, tt := range tests {
		got := domainToFilename(tt.domain)
		if got != tt.expected {
			t.Errorf("domainToFilename(%q) = %q, want %q", tt.domain, got, tt.expected)
		}
	}
}

func TestGet_NotFound(t *testing.T) {
	mgr := NewManager(t.TempDir())

	_, err := mgr.Get("nonexistent.example.com")
	if err == nil {
		t.Error("expected error for non-existent domain, got nil")
	}
}

func TestDeregister_NotFound(t *testing.T) {
	mgr := NewManager(t.TempDir())

	err := mgr.Deregister("nonexistent.example.com")
	if err == nil {
		t.Error("expected error when deregistering non-existent domain, got nil")
	}
}

func TestDeregisterBySource_NoMatch(t *testing.T) {
	mgr := NewManager(t.TempDir())

	// Register some services
	mgr.Register(Service{
		Domain:  "a.example.com",
		Source:  "wild-cloud",
		Backend: Backend{Address: "10.0.0.1:443", Type: BackendTCPPassthrough},
		Public: true,
	})
	mgr.Register(Service{
		Domain:  "b.example.com",
		Source:  "wild-works",
		Backend: Backend{Address: "10.0.0.2:8080", Type: BackendHTTP},
		// Public defaults to false
	})

	// Deregister with a source that doesn't match anything
	err := mgr.DeregisterBySource("unknown-source", "10.0.0.99:443")
	if err != nil {
		t.Fatalf("DeregisterBySource with no matches should not error: %v", err)
	}

	// All services should still be present
	svcs, _ := mgr.List()
	if len(svcs) != 2 {
		t.Errorf("expected 2 services after no-match deregister, got %d", len(svcs))
	}
}

func TestDeregisterBySource_PartialMatch(t *testing.T) {
	mgr := NewManager(t.TempDir())

	// Same source, different backends
	mgr.Register(Service{
		Domain:  "a.example.com",
		Source:  "wild-cloud",
		Backend: Backend{Address: "10.0.0.1:443", Type: BackendTCPPassthrough},
		Public: true,
	})
	mgr.Register(Service{
		Domain:  "b.example.com",
		Source:  "wild-cloud",
		Backend: Backend{Address: "10.0.0.2:443", Type: BackendTCPPassthrough},
		Public: true,
	})

	// Deregister only the ones matching source AND backend
	err := mgr.DeregisterBySource("wild-cloud", "10.0.0.1:443")
	if err != nil {
		t.Fatalf("DeregisterBySource failed: %v", err)
	}

	svcs, _ := mgr.List()
	if len(svcs) != 1 {
		t.Errorf("expected 1 remaining service, got %d", len(svcs))
	}
	if svcs[0].Domain != "b.example.com" {
		t.Errorf("expected b.example.com to remain, got %s", svcs[0].Domain)
	}
}

func TestUpdate_NotFound(t *testing.T) {
	mgr := NewManager(t.TempDir())

	err := mgr.Update("nonexistent.example.com", map[string]any{
		"public": true,
	})
	if err == nil {
		t.Error("expected error when updating non-existent domain, got nil")
	}
}

func TestRegister_OverwritePreservesFile(t *testing.T) {
	dir := t.TempDir()
	mgr := NewManager(dir)

	svc := Service{
		Domain:  "overwrite.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
		// Public defaults to false
	}

	// Register first time
	if err := mgr.Register(svc); err != nil {
		t.Fatalf("first Register failed: %v", err)
	}

	// Register again with different backend
	svc.Backend.Address = "127.0.0.1:9090"
	if err := mgr.Register(svc); err != nil {
		t.Fatalf("second Register failed: %v", err)
	}

	// File count should be exactly 1
	entries, err := os.ReadDir(filepath.Join(dir, "services"))
	if err != nil {
		t.Fatalf("ReadDir failed: %v", err)
	}
	if len(entries) != 1 {
		t.Errorf("expected 1 file after overwrite, got %d", len(entries))
	}

	// Value should be updated
	got, _ := mgr.Get("overwrite.example.com")
	if got.Backend.Address != "127.0.0.1:9090" {
		t.Errorf("expected updated backend 127.0.0.1:9090, got %s", got.Backend.Address)
	}
}

func TestList_EmptyDir(t *testing.T) {
	mgr := NewManager(t.TempDir())

	svcs, err := mgr.List()
	if err != nil {
		t.Fatalf("List on empty dir should not error: %v", err)
	}
	if len(svcs) != 0 {
		t.Errorf("expected 0 services from empty dir, got %d", len(svcs))
	}
}

func TestRegisterWithL7Fields(t *testing.T) {
	mgr := NewManager(t.TempDir())

	svc := Service{
		Domain: "keila.cloud.payne.io",
		Source: "wild-cloud",
		Routes: []Route{{
			Paths: []string{"/.well-known/matrix", "/_matrix"},
			Backend: Backend{
				Address: "192.168.8.80:80",
				Type:    BackendHTTP,
			},
			Headers: &HeaderConfig{
				Response: map[string]string{
					"Access-Control-Allow-Origin": "https://payne.io",
				},
				Request: map[string]string{
					"X-Forwarded-Proto": "https",
				},
			},
			IPAllow: []string{"10.0.0.0/8", "192.168.0.0/16"},
		}},
	}

	if err := mgr.Register(svc); err != nil {
		t.Fatalf("Register failed: %v", err)
	}

	got, err := mgr.Get("keila.cloud.payne.io")
	if err != nil {
		t.Fatalf("Get failed: %v", err)
	}

	if len(got.Routes) != 1 {
		t.Fatalf("expected 1 route, got %d", len(got.Routes))
	}
	r := got.Routes[0]
	if len(r.Paths) != 2 || r.Paths[0] != "/.well-known/matrix" {
		t.Errorf("expected 2 paths, got %v", r.Paths)
	}
	if r.Headers == nil {
		t.Fatal("expected headers, got nil")
	}
	if r.Headers.Response["Access-Control-Allow-Origin"] != "https://payne.io" {
		t.Errorf("expected response header, got %v", r.Headers.Response)
	}
	if r.Headers.Request["X-Forwarded-Proto"] != "https" {
		t.Errorf("expected request header, got %v", r.Headers.Request)
	}
	if len(r.IPAllow) != 2 || r.IPAllow[0] != "10.0.0.0/8" {
		t.Errorf("expected 2 ipAllow CIDRs, got %v", r.IPAllow)
	}
}

func TestUpdateL7Fields(t *testing.T) {
	mgr := NewManager(t.TempDir())

	mgr.Register(Service{
		Domain: "updatable.example.com",
		Source: "test",
		Routes: []Route{{
			Paths:   []string{"/api", "/webhook"},
			Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
			IPAllow: []string{"10.0.0.0/8"},
			Headers: &HeaderConfig{
				Response: map[string]string{
					"X-Custom": "value",
				},
			},
		}},
	})

	got, _ := mgr.Get("updatable.example.com")
	if len(got.Routes) != 1 {
		t.Fatalf("expected 1 route, got %d", len(got.Routes))
	}
	r := got.Routes[0]
	if len(r.Paths) != 2 || r.Paths[0] != "/api" {
		t.Errorf("expected paths [/api /webhook], got %v", r.Paths)
	}
	if len(r.IPAllow) != 1 || r.IPAllow[0] != "10.0.0.0/8" {
		t.Errorf("expected ipAllow [10.0.0.0/8], got %v", r.IPAllow)
	}
	if r.Headers == nil || r.Headers.Response["X-Custom"] != "value" {
		t.Errorf("expected response header X-Custom=value, got %v", r.Headers)
	}
}

func TestList_IgnoresNonYAML(t *testing.T) {
	dir := t.TempDir()
	mgr := NewManager(dir)

	// Register one real service
	mgr.Register(Service{
		Domain:  "real.example.com",
		Source:  "test",
		Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
		// Public defaults to false
	})

	// Create non-YAML files in the services directory
	servicesDir := filepath.Join(dir, "services")
	os.WriteFile(filepath.Join(servicesDir, "README.md"), []byte("# ignore me"), 0644)
	os.WriteFile(filepath.Join(servicesDir, "notes.txt"), []byte("some notes"), 0644)
	os.WriteFile(filepath.Join(servicesDir, ".gitkeep"), []byte(""), 0644)

	svcs, err := mgr.List()
	if err != nil {
		t.Fatalf("List failed: %v", err)
	}
	if len(svcs) != 1 {
		t.Errorf("expected 1 service (ignoring non-YAML files), got %d", len(svcs))
	}
	if svcs[0].Domain != "real.example.com" {
		t.Errorf("expected real.example.com, got %s", svcs[0].Domain)
	}
}