package v1

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gorilla/mux"
)

func TestServicesRegister(t *testing.T) {
	api, _ := setupTestAPI(t)

	body, _ := json.Marshal(map[string]any{
		"name":   "my-api",
		"source": "wild-works",
		"domain": "my-api.payne.io",
		"backend": map[string]any{
			"address": "192.168.8.60:9001",
			"type":    "http",
			"health":  "/health",
		},
		"reach": "internal",
	})

	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()

	api.ServicesRegister(w, req)

	if w.Code != http.StatusCreated {
		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
	}

	var resp map[string]any
	json.Unmarshal(w.Body.Bytes(), &resp)

	svc, ok := resp["service"].(map[string]any)
	if !ok {
		t.Fatal("expected service in response")
	}
	if svc["name"] != "my-api" {
		t.Errorf("expected name my-api, got %v", svc["name"])
	}
	if svc["tls"] != "terminate" {
		t.Errorf("expected tls=terminate default for http backend, got %v", svc["tls"])
	}
}

func TestServicesListAll_Empty(t *testing.T) {
	api, _ := setupTestAPI(t)

	req := httptest.NewRequest("GET", "/api/v1/services", nil)
	w := httptest.NewRecorder()

	api.ServicesListAll(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp map[string]any
	json.Unmarshal(w.Body.Bytes(), &resp)

	svcs, ok := resp["services"].([]any)
	if !ok {
		t.Fatal("expected services array")
	}
	if len(svcs) != 0 {
		t.Errorf("expected empty services, got %d", len(svcs))
	}
}

func TestServicesListAll_WithServices(t *testing.T) {
	api, _ := setupTestAPI(t)

	// Register two services
	for _, name := range []string{"svc-a", "svc-b"} {
		body, _ := json.Marshal(map[string]any{
			"name":    name,
			"source":  "test",
			"domain":  name + ".example.com",
			"backend": map[string]any{"address": "127.0.0.1:8080", "type": "http"},
			"reach":   "internal",
		})
		req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
		w := httptest.NewRecorder()
		api.ServicesRegister(w, req)
		if w.Code != http.StatusCreated {
			t.Fatalf("register %s failed: %d", name, w.Code)
		}
	}

	req := httptest.NewRequest("GET", "/api/v1/services", nil)
	w := httptest.NewRecorder()

	api.ServicesListAll(w, req)

	var resp map[string]any
	json.Unmarshal(w.Body.Bytes(), &resp)

	svcs := resp["services"].([]any)
	if len(svcs) != 2 {
		t.Errorf("expected 2 services, got %d", len(svcs))
	}
}

func TestServicesGet(t *testing.T) {
	api, _ := setupTestAPI(t)

	// Register
	body, _ := json.Marshal(map[string]any{
		"name":    "get-test",
		"source":  "test",
		"domain":  "get-test.example.com",
		"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
		"reach":   "internal",
	})
	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()
	api.ServicesRegister(w, req)

	// Get
	req = httptest.NewRequest("GET", "/api/v1/services/get-test", nil)
	req = mux.SetURLVars(req, map[string]string{"name": "get-test"})
	w = httptest.NewRecorder()

	api.ServicesGet(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}

	var svc map[string]any
	json.Unmarshal(w.Body.Bytes(), &svc)

	if svc["domain"] != "get-test.example.com" {
		t.Errorf("expected domain get-test.example.com, got %v", svc["domain"])
	}
}

func TestServicesGet_NotFound(t *testing.T) {
	api, _ := setupTestAPI(t)

	req := httptest.NewRequest("GET", "/api/v1/services/nonexistent", nil)
	req = mux.SetURLVars(req, map[string]string{"name": "nonexistent"})
	w := httptest.NewRecorder()

	api.ServicesGet(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("expected 404, got %d", w.Code)
	}
}

func TestServicesUpdate(t *testing.T) {
	api, _ := setupTestAPI(t)

	// Register
	body, _ := json.Marshal(map[string]any{
		"name":    "update-test",
		"source":  "test",
		"domain":  "update-test.example.com",
		"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
		"reach":   "internal",
	})
	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()
	api.ServicesRegister(w, req)

	// Update reach to public
	update, _ := json.Marshal(map[string]any{"reach": "public"})
	req = httptest.NewRequest("PATCH", "/api/v1/services/update-test", bytes.NewReader(update))
	req = mux.SetURLVars(req, map[string]string{"name": "update-test"})
	w = httptest.NewRecorder()

	api.ServicesUpdate(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}

	var resp map[string]any
	json.Unmarshal(w.Body.Bytes(), &resp)

	svc := resp["service"].(map[string]any)
	if svc["reach"] != "public" {
		t.Errorf("expected reach=public after update, got %v", svc["reach"])
	}
}

func TestServicesDeregister(t *testing.T) {
	api, _ := setupTestAPI(t)

	// Register
	body, _ := json.Marshal(map[string]any{
		"name":    "delete-me",
		"source":  "test",
		"domain":  "delete-me.example.com",
		"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
		"reach":   "internal",
	})
	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()
	api.ServicesRegister(w, req)

	// Delete
	req = httptest.NewRequest("DELETE", "/api/v1/services/delete-me", nil)
	req = mux.SetURLVars(req, map[string]string{"name": "delete-me"})
	w = httptest.NewRecorder()

	api.ServicesDeregister(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	// Verify it's gone
	req = httptest.NewRequest("GET", "/api/v1/services/delete-me", nil)
	req = mux.SetURLVars(req, map[string]string{"name": "delete-me"})
	w = httptest.NewRecorder()
	api.ServicesGet(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("expected 404 after delete, got %d", w.Code)
	}
}

func TestServicesRegister_TCPPassthrough(t *testing.T) {
	api, _ := setupTestAPI(t)

	body, _ := json.Marshal(map[string]any{
		"name":   "cloud-instance",
		"source": "wild-cloud",
		"domain": "cloud.payne.io",
		"backend": map[string]any{
			"address": "192.168.8.100:443",
			"type":    "tcp-passthrough",
		},
		"reach": "internal",
	})

	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()

	api.ServicesRegister(w, req)

	if w.Code != http.StatusCreated {
		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
	}

	var resp map[string]any
	json.Unmarshal(w.Body.Bytes(), &resp)

	svc := resp["service"].(map[string]any)
	if svc["tls"] != "passthrough" {
		t.Errorf("expected tls=passthrough for tcp-passthrough, got %v", svc["tls"])
	}
}

func TestServicesRegister_Validation(t *testing.T) {
	api, _ := setupTestAPI(t)

	// Missing name
	body, _ := json.Marshal(map[string]any{
		"domain":  "x.com",
		"backend": map[string]any{"address": "127.0.0.1:80", "type": "http"},
	})
	req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
	w := httptest.NewRecorder()
	api.ServicesRegister(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("expected 400 for missing name, got %d", w.Code)
	}
}