package tenantengine_test

import (
	"context"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/netkingdom/flex-auth/internal/adapters/tenantengine"
)

func TestLiveRolesReturnsRolesOnSuccess(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/tenants/t-1/roles/live" {
			t.Fatalf("unexpected path %s", r.URL.Path)
		}
		w.Header().Set("Content-Type", "application/json")
		w.Write([]byte(`{"tenant_id":"t-1","roles":["CUS","VEN"]}`))
	}))
	defer server.Close()

	client, err := tenantengine.NewHTTPClient(server.URL)
	if err != nil {
		t.Fatalf("NewHTTPClient: %v", err)
	}

	result, err := client.LiveRoles(context.Background(), "t-1")
	if err != nil {
		t.Fatalf("LiveRoles: %v", err)
	}
	if !result.Available {
		t.Fatal("expected Available = true")
	}
	if len(result.Roles) != 2 || result.Roles[0] != "CUS" || result.Roles[1] != "VEN" {
		t.Fatalf("unexpected roles: %v", result.Roles)
	}
}

func TestLiveRolesReturnsUnavailableOnNon200(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusServiceUnavailable)
	}))
	defer server.Close()

	client, _ := tenantengine.NewHTTPClient(server.URL)
	result, err := client.LiveRoles(context.Background(), "t-1")

	if err == nil {
		t.Fatal("expected an error")
	}
	if result.Available {
		t.Fatal("expected Available = false on a 503, not indistinguishable from zero roles")
	}
	if result.Roles != nil {
		t.Fatalf("expected nil roles on failure, got %v", result.Roles)
	}
}

func TestLiveRolesReturnsUnavailableOnMalformedBody(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("not json"))
	}))
	defer server.Close()

	client, _ := tenantengine.NewHTTPClient(server.URL)
	result, err := client.LiveRoles(context.Background(), "t-1")

	if err == nil {
		t.Fatal("expected an error")
	}
	if result.Available {
		t.Fatal("expected Available = false on malformed body")
	}
}

func TestLiveRolesReturnsUnavailableOnConnectionFailure(t *testing.T) {
	client, _ := tenantengine.NewHTTPClient("http://127.0.0.1:1")

	result, err := client.LiveRoles(context.Background(), "t-1")

	if err == nil {
		t.Fatal("expected an error")
	}
	if result.Available {
		t.Fatal("expected Available = false on connection failure")
	}
}

func TestLiveRolesRespectsContextTimeout(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(200 * time.Millisecond)
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{"tenant_id":"t-1","roles":[]}`))
	}))
	defer server.Close()

	client, _ := tenantengine.NewHTTPClient(server.URL)
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
	defer cancel()

	result, err := client.LiveRoles(ctx, "t-1")

	if err == nil {
		t.Fatal("expected a timeout error")
	}
	if result.Available {
		t.Fatal("expected Available = false on timeout")
	}
}

func TestNewHTTPClientRequiresBaseURL(t *testing.T) {
	if _, err := tenantengine.NewHTTPClient(""); err == nil {
		t.Fatal("expected an error for empty base URL")
	}
}