package slurm

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

func TestSlurmdbJobsService_GetJobs(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/jobs", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"jobs": []}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	resp, _, err := client.SlurmdbJobs.GetJobs(context.Background(), nil)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resp == nil {
		t.Fatal("expected non-nil response")
	}
	if len(resp.Jobs) != 0 {
		t.Errorf("expected empty jobs, got %d", len(resp.Jobs))
	}
}

func TestSlurmdbJobsService_GetJobsWithOptions(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/jobs", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		q := r.URL.Query()
		if q.Get("users") != "alice,bob" {
			t.Errorf("expected users=alice,bob, got %s", q.Get("users"))
		}
		if q.Get("account") != "science" {
			t.Errorf("expected account=science, got %s", q.Get("account"))
		}
		if q.Get("cluster") != "cluster1" {
			t.Errorf("expected cluster=cluster1, got %s", q.Get("cluster"))
		}
		if q.Get("state") != "RUNNING" {
			t.Errorf("expected state=RUNNING, got %s", q.Get("state"))
		}
		if q.Get("start_time") != "1700000000" {
			t.Errorf("expected start_time=1700000000, got %s", q.Get("start_time"))
		}
		if q.Get("partition") != "gpu" {
			t.Errorf("expected partition=gpu, got %s", q.Get("partition"))
		}
		fmt.Fprint(w, `{"jobs": []}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	opts := &GetSlurmdbJobsOptions{
		Users:     Ptr("alice,bob"),
		Account:   Ptr("science"),
		Cluster:   Ptr("cluster1"),
		State:     Ptr("RUNNING"),
		StartTime: Ptr("1700000000"),
		Partition: Ptr("gpu"),
	}
	resp, _, err := client.SlurmdbJobs.GetJobs(context.Background(), opts)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resp == nil {
		t.Fatal("expected non-nil response")
	}
}

func TestSlurmdbJobsService_GetJob(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/job/12345", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		fmt.Fprint(w, `{"jobs": [{"job_id": 12345, "name": "my-job"}]}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	resp, _, err := client.SlurmdbJobs.GetJob(context.Background(), "12345")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resp == nil {
		t.Fatal("expected non-nil response")
	}
	if len(resp.Jobs) != 1 {
		t.Fatalf("expected 1 job, got %d", len(resp.Jobs))
	}
	if resp.Jobs[0].JobID == nil || *resp.Jobs[0].JobID != 12345 {
		t.Errorf("expected job_id=12345, got %v", resp.Jobs[0].JobID)
	}
}

func TestSlurmdbJobsService_GetJobs_ServerError(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/jobs", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprint(w, `{"errors": [{"error": "internal error"}]}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	_, _, err := client.SlurmdbJobs.GetJobs(context.Background(), nil)
	if err == nil {
		t.Fatal("expected error, got nil")
	}
}

func TestSlurmdbJobsService_GetJob_ServerError(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/job/99999", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNotFound)
		fmt.Fprint(w, `{"errors": [{"error": "job not found"}]}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	_, _, err := client.SlurmdbJobs.GetJob(context.Background(), "99999")
	if err == nil {
		t.Fatal("expected error, got nil")
	}
}

func TestSlurmdbJobsService_GetJobs_AllQueryParams(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc("/slurmdb/v0.0.40/jobs", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		q := r.URL.Query()
		expectedParams := map[string]string{
			"account":                     "acct1",
			"association":                 "assoc1",
			"cluster":                     "cl1",
			"constraints":                 "c1",
			"cpus_max":                    "64",
			"cpus_min":                    "1",
			"scheduler_unset":             "1",
			"scheduled_on_submit":         "1",
			"scheduled_by_main":           "1",
			"scheduled_by_backfill":       "1",
			"job_started":                 "1",
			"exit_code":                   "0",
			"show_duplicates":             "1",
			"skip_steps":                  "1",
			"disable_truncate_usage_time": "1",
			"whole_hetjob":                "1",
			"disable_whole_hetjob":        "0",
			"disable_wait_for_result":     "1",
			"usage_time_as_submit_time":   "1",
			"show_batch_script":           "1",
			"show_job_environment":        "1",
			"format":                      "json",
			"groups":                      "grp1",
			"job_name":                    "jn1",
			"nodes_max":                   "10",
			"nodes_min":                   "1",
			"partition":                   "part1",
			"qos":                         "normal",
			"reason":                      "r1",
			"reservation":                 "res1",
			"reservation_id":              "100",
			"state":                       "RUNNING",
			"step":                        "0",
			"timelimit_max":               "3600",
			"timelimit_min":               "60",
			"end_time":                    "1700001000",
			"start_time":                  "1700000000",
			"submit_time":                 "1699999000",
			"node":                        "n1",
			"users":                       "u1",
			"wckey":                       "w1",
		}
		for k, v := range expectedParams {
			got := q.Get(k)
			if got != v {
				t.Errorf("expected %s=%s, got %s", k, v, got)
			}
		}
		fmt.Fprint(w, `{"jobs": []}`)
	})
	server := httptest.NewServer(mux)
	defer server.Close()

	client, _ := NewClient(server.URL, nil)
	opts := &GetSlurmdbJobsOptions{
		Account:                  Ptr("acct1"),
		Association:              Ptr("assoc1"),
		Cluster:                  Ptr("cl1"),
		Constraints:              Ptr("c1"),
		CpusMax:                  Ptr("64"),
		CpusMin:                  Ptr("1"),
		SchedulerUnset:           Ptr("1"),
		ScheduledOnSubmit:        Ptr("1"),
		ScheduledByMain:          Ptr("1"),
		ScheduledByBackfill:      Ptr("1"),
		JobStarted:               Ptr("1"),
		ExitCode:                 Ptr("0"),
		ShowDuplicates:           Ptr("1"),
		SkipSteps:                Ptr("1"),
		DisableTruncateUsageTime: Ptr("1"),
		WholeHetjob:              Ptr("1"),
		DisableWholeHetjob:       Ptr("0"),
		DisableWaitForResult:     Ptr("1"),
		UsageTimeAsSubmitTime:    Ptr("1"),
		ShowBatchScript:          Ptr("1"),
		ShowJobEnvironment:       Ptr("1"),
		Format:                   Ptr("json"),
		Groups:                   Ptr("grp1"),
		JobName:                  Ptr("jn1"),
		NodesMax:                 Ptr("10"),
		NodesMin:                 Ptr("1"),
		Partition:                Ptr("part1"),
		Qos:                      Ptr("normal"),
		Reason:                   Ptr("r1"),
		Reservation:              Ptr("res1"),
		ReservationID:            Ptr("100"),
		State:                    Ptr("RUNNING"),
		Step:                     Ptr("0"),
		TimelimitMax:             Ptr("3600"),
		TimelimitMin:             Ptr("60"),
		EndTime:                  Ptr("1700001000"),
		StartTime:                Ptr("1700000000"),
		SubmitTime:               Ptr("1699999000"),
		Node:                     Ptr("n1"),
		Users:                    Ptr("u1"),
		Wckey:                    Ptr("w1"),
	}
	resp, _, err := client.SlurmdbJobs.GetJobs(context.Background(), opts)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resp == nil {
		t.Fatal("expected non-nil response")
	}
}