package slurm

import (
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestNewClient(t *testing.T) {
	client, err := NewClient("http://localhost:6820/", nil)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if client == nil {
		t.Fatal("expected non-nil client")
	}
	if client.UserAgent != DefaultUserAgent {
		t.Errorf("expected UserAgent %q, got %q", DefaultUserAgent, client.UserAgent)
	}
	if client.client == nil {
		t.Error("expected http.Client to be initialized (nil httpClient should default to http.DefaultClient)")
	}

	_, err = NewClient("://invalid", nil)
	if err == nil {
		t.Fatal("expected error for invalid URL, got nil")
	}

	client2, err := NewClient("http://localhost:6820/", nil)
	if err != nil {
		t.Fatalf("unexpected error with nil httpClient: %v", err)
	}
	if client2.client == nil {
		t.Error("expected client.httpclient to be non-nil when passing nil")
	}
}

func TestNewClient_ServicesInitialized(t *testing.T) {
	client, err := NewClient("http://localhost:6820/", nil)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	services := []struct {
		name string
		svc  interface{}
	}{
		{"Jobs", client.Jobs},
		{"Nodes", client.Nodes},
		{"Partitions", client.Partitions},
		{"Reservations", client.Reservations},
		{"Diag", client.Diag},
		{"Ping", client.Ping},
		{"Licenses", client.Licenses},
		{"Reconfigure", client.Reconfigure},
		{"Shares", client.Shares},
	}

	for _, s := range services {
		if s.svc == nil {
			t.Errorf("%s service is nil", s.name)
		}
	}
}

func TestClient_AuthHeaders(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if got := r.Header.Get("X-SLURM-USER-NAME"); got != "testuser" {
			t.Errorf("expected X-SLURM-USER-NAME %q, got %q", "testuser", got)
		}
		if got := r.Header.Get("X-SLURM-USER-TOKEN"); got != "testtoken" {
			t.Errorf("expected X-SLURM-USER-TOKEN %q, got %q", "testtoken", got)
		}
		w.WriteHeader(200)
		fmt.Fprint(w, `{}`)
	})

	server := httptest.NewServer(mux)
	defer server.Close()

	transport := &TokenAuthTransport{
		UserName: "testuser",
		Token:    "testtoken",
	}
	httpClient := transport.Client()
	client, err := NewClient(server.URL, httpClient)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	req, err := client.NewRequest("GET", "slurm/v0.0.40/ping", nil)
	if err != nil {
		t.Fatalf("unexpected error creating request: %v", err)
	}
	_, err = client.Do(context.Background(), req, nil)
	if err != nil {
		t.Fatalf("unexpected error doing request: %v", err)
	}
}

func TestClient_ErrorHandling(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(500)
		fmt.Fprint(w, "internal server error")
	})

	server := httptest.NewServer(mux)
	defer server.Close()

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

	req, err := client.NewRequest("GET", "slurm/v0.0.40/diag", nil)
	if err != nil {
		t.Fatalf("unexpected error creating request: %v", err)
	}
	_, err = client.Do(context.Background(), req, nil)

	if err == nil {
		t.Fatal("expected error for 500 response")
	}

	errorResp, ok := err.(*ErrorResponse)
	if !ok {
		t.Fatalf("expected *ErrorResponse, got %T", err)
	}
	if errorResp.Response.StatusCode != 500 {
		t.Errorf("expected status 500, got %d", errorResp.Response.StatusCode)
	}
}