package schedule

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/carlosframework/platform/internal/registry"
)

func controlFixture(t *testing.T) (*registry.Registry, *http.ServeMux) {
	t.Helper()
	reg, err := registry.Open(filepath.Join(t.TempDir(), "r.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { reg.Close() })
	mux := http.NewServeMux()
	Mount(mux, "a.bab.oncarlos.com", reg, func() (string, error) { return "tok", nil }, func() time.Time { return at("2026-08-23T13:07:00Z") })
	return reg, mux
}

func do(mux *http.ServeMux, method, path, auth, body string) *httptest.ResponseRecorder {
	req := httptest.NewRequest(method, path, strings.NewReader(body))
	if auth != "" {
		req.Header.Set("Authorization", auth)
	}
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	return rec
}

func TestControlRequiresTheHostsToken(t *testing.T) {
	_, mux := controlFixture(t)
	for _, auth := range []string{"", "Bearer wrong", "Basic tok"} {
		if rec := do(mux, "PUT", "/schedule/r", auth, `{"at":"2026-09-01T08:00:00Z","path":"/r"}`); rec.Code != http.StatusUnauthorized {
			t.Errorf("auth %q → %d, want 401", auth, rec.Code)
		}
		if rec := do(mux, "GET", "/schedule", auth, ""); rec.Code != http.StatusUnauthorized {
			t.Errorf("GET auth %q → %d", auth, rec.Code)
		}
	}
}

func TestControlPutGetDelete(t *testing.T) {
	reg, mux := controlFixture(t)
	rec := do(mux, "PUT", "/schedule/remind", "Bearer tok", `{"at":"2026-09-01T08:00:00Z","path":"/jobs/remind"}`)
	if rec.Code != http.StatusOK {
		t.Fatalf("put = %d %s", rec.Code, rec.Body)
	}
	var ts TimerStatus
	json.Unmarshal(rec.Body.Bytes(), &ts)
	if ts.Kind != KindOnce || ts.NextAt != at("2026-09-01T08:00:00Z").Unix() || ts.Path != "/jobs/remind" || ts.Spec != "at "+itoa(ts.NextAt) {
		t.Fatalf("put body = %+v", ts)
	}
	tm, _ := reg.GetTimer("a.bab.oncarlos.com", "remind")
	if tm == nil || tm.Kind != KindOnce {
		t.Fatalf("row = %+v", tm)
	}
	// Upsert by name moves the time.
	do(mux, "PUT", "/schedule/remind", "Bearer tok", `{"at":"2026-09-02T08:00:00Z","path":"/jobs/remind"}`)
	tm, _ = reg.GetTimer("a.bab.oncarlos.com", "remind")
	if tm.NextAt != at("2026-09-02T08:00:00Z").Unix() {
		t.Fatalf("upsert did not move: %+v", tm)
	}
	rec = do(mux, "GET", "/schedule", "Bearer tok", "")
	var list struct{ Timers []TimerStatus }
	json.Unmarshal(rec.Body.Bytes(), &list)
	if len(list.Timers) != 1 || list.Timers[0].Name != "remind" {
		t.Fatalf("list = %+v", list)
	}
	if rec := do(mux, "DELETE", "/schedule/remind", "Bearer tok", ""); rec.Code != http.StatusNoContent {
		t.Fatalf("delete = %d", rec.Code)
	}
	if rec := do(mux, "DELETE", "/schedule/remind", "Bearer tok", ""); rec.Code != http.StatusNoContent {
		t.Fatalf("second delete = %d, want 204 (idempotent)", rec.Code)
	}
}

func TestControlRefusals(t *testing.T) {
	reg, mux := controlFixture(t)
	reg.UpsertTimer(registry.Timer{Host: "a.bab.oncarlos.com", Name: "sync", Kind: KindSchedule, Spec: "every 6h0m0s", Path: "/s", NextAt: 1})
	cases := []struct {
		name, body string
		want       int
	}{
		{"sync", `{"at":"2026-09-01T08:00:00Z","path":"/p"}`, http.StatusConflict},
		{"Bad", `{"at":"2026-09-01T08:00:00Z","path":"/p"}`, http.StatusBadRequest},
		{"ok", `{"at":"2026-09-01T08:00:00Z","path":"p"}`, http.StatusBadRequest},
		{"ok", `{"at":"soon","path":"/p"}`, http.StatusBadRequest},
		{"ok", `{"at":"2028-09-01T08:00:00Z","path":"/p"}`, http.StatusBadRequest}, // > 400 days ahead
		{"ok", `not json`, http.StatusBadRequest},
	}
	for _, c := range cases {
		if rec := do(mux, "PUT", "/schedule/"+c.name, "Bearer tok", c.body); rec.Code != c.want {
			t.Errorf("PUT %s %s → %d, want %d (%s)", c.name, c.body, rec.Code, c.want, rec.Body)
		}
	}
	// A past `at` is accepted and fires on the next tick.
	if rec := do(mux, "PUT", "/schedule/past", "Bearer tok", `{"at":"2020-01-01T00:00:00Z","path":"/p"}`); rec.Code != http.StatusOK {
		t.Fatalf("past at → %d", rec.Code)
	}
	if tm, _ := reg.GetTimer("a.bab.oncarlos.com", "past"); tm.NextAt != at("2020-01-01T00:00:00Z").Unix() {
		t.Fatalf("past row = %+v", tm)
	}
}

// json.Decoder.Decode stops at the first value and silently drops whatever
// follows it, so a naive Decode(&body) would accept a body like
// `{"at":...}{"at":...}` or `{"at":...}garbage` and act on the first
// object alone. The PUT handler must refuse it instead.
func TestControlPutRejectsTrailingJSON(t *testing.T) {
	_, mux := controlFixture(t)
	for _, body := range []string{
		`{"at":"2026-09-01T08:00:00Z","path":"/p"}{"at":"2026-09-02T08:00:00Z","path":"/p"}`,
		`{"at":"2026-09-01T08:00:00Z","path":"/p"} garbage`,
		`{"at":"2026-09-01T08:00:00Z","path":"/p"},`,
	} {
		if rec := do(mux, "PUT", "/schedule/trailing", "Bearer tok", body); rec.Code != http.StatusBadRequest {
			t.Errorf("PUT with trailing data %q → %d, want 400 (%s)", body, rec.Code, rec.Body)
		}
	}
	// A clean single object still works.
	if rec := do(mux, "PUT", "/schedule/clean", "Bearer tok", `{"at":"2026-09-01T08:00:00Z","path":"/p"}`); rec.Code != http.StatusOK {
		t.Fatalf("clean body → %d (%s)", rec.Code, rec.Body)
	}
	// dec.More() must not trip on WHITESPACE after the object — a curl
	// heredoc (`curl -d @- <<EOF`) appends exactly this, a trailing
	// newline, and sometimes leading/trailing spaces too. Only a second
	// TOKEN counts as trailing data.
	for i, body := range []string{
		"{\"at\":\"2026-09-01T08:00:00Z\",\"path\":\"/p\"}\n",
		"{\"at\":\"2026-09-01T08:00:00Z\",\"path\":\"/p\"} \n \t",
		"  {\"at\":\"2026-09-01T08:00:00Z\",\"path\":\"/p\"}  ",
	} {
		name := "clean-ws-" + itoa(int64(i))
		if rec := do(mux, "PUT", "/schedule/"+name, "Bearer tok", body); rec.Code != http.StatusOK {
			t.Errorf("PUT with trailing/leading whitespace %q → %d, want 200 (%s)", body, rec.Code, rec.Body)
		}
	}
}

// A member's clock is not UTC; `at` must accept an offset and the row must
// store the UTC instant it names, not the offset's clock-face numbers.
func TestControlPutNormalisesTZOffsetToUTC(t *testing.T) {
	reg, mux := controlFixture(t)
	// 09:00 +01:00 is 08:00Z.
	rec := do(mux, "PUT", "/schedule/tz", "Bearer tok", `{"at":"2026-09-01T09:00:00+01:00","path":"/p"}`)
	if rec.Code != http.StatusOK {
		t.Fatalf("put = %d %s", rec.Code, rec.Body)
	}
	want := at("2026-09-01T08:00:00Z").Unix()
	var ts TimerStatus
	json.Unmarshal(rec.Body.Bytes(), &ts)
	if ts.NextAt != want || ts.Spec != "at "+itoa(want) {
		t.Fatalf("response = %+v, want next_at=%d", ts, want)
	}
	tm, err := reg.GetTimer("a.bab.oncarlos.com", "tz")
	if err != nil || tm.NextAt != want || tm.DueAt != want {
		t.Fatalf("row = %+v, err=%v, want next_at/due_at=%d", tm, err, want)
	}
}

func TestControlDeleteRefusesDeclaredSchedule(t *testing.T) {
	reg, mux := controlFixture(t)
	reg.UpsertTimer(registry.Timer{Host: "a.bab.oncarlos.com", Name: "sync", Kind: KindSchedule, Spec: "every 6h0m0s", Path: "/s", NextAt: 1})
	if rec := do(mux, "DELETE", "/schedule/sync", "Bearer tok", ""); rec.Code != http.StatusConflict {
		t.Fatalf("delete declared schedule = %d, want 409 (%s)", rec.Code, rec.Body)
	}
	tm, err := reg.GetTimer("a.bab.oncarlos.com", "sync")
	if err != nil || tm == nil || tm.Kind != KindSchedule {
		t.Fatalf("row did not survive the refused delete: %v, err=%v", tm, err)
	}
}

func TestControlCapsOncePerHost(t *testing.T) {
	reg, mux := controlFixture(t)
	for i := 0; i < MaxOncePerHost; i++ {
		reg.UpsertTimer(registry.Timer{Host: "a.bab.oncarlos.com", Name: "n" + itoa(int64(i)), Kind: KindOnce, Spec: "at 1", Path: "/p", NextAt: 1})
	}
	if rec := do(mux, "PUT", "/schedule/over", "Bearer tok", `{"at":"2026-09-01T08:00:00Z","path":"/p"}`); rec.Code != http.StatusTooManyRequests {
		t.Fatalf("over cap → %d", rec.Code)
	}
	// Replacing an existing name is not a new row and must still work.
	if rec := do(mux, "PUT", "/schedule/n1", "Bearer tok", `{"at":"2026-09-01T08:00:00Z","path":"/p"}`); rec.Code != http.StatusOK {
		t.Fatalf("replace at cap → %d", rec.Code)
	}
}

func itoa(n int64) string { return strconv.FormatInt(n, 10) }

func TestControlScheduleCapabilities(t *testing.T) {
	_, mux := controlFixture(t)
	for _, auth := range []string{"", "Bearer wrong", "Basic tok"} {
		rec := do(mux, "GET", "/schedule-capabilities", auth, "")
		if rec.Code != http.StatusUnauthorized || strings.Contains(rec.Body.String(), "registration_fence") {
			t.Fatalf("unauthorized capability response: %d %s", rec.Code, rec.Body.String())
		}
	}
	rec := do(mux, "GET", "/schedule-capabilities", "Bearer tok", "")
	if rec.Code != http.StatusOK || rec.Header().Get("Content-Type") != "application/json" {
		t.Fatalf("capability response: %d %s", rec.Code, rec.Body.String())
	}
	var got map[string]bool
	if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil {
		t.Fatal(err)
	}
	if len(got) != 1 || !got["registration_fence"] {
		t.Fatalf("capabilities: %v", got)
	}
	old := http.NewServeMux()
	old.HandleFunc("GET /schedule", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
	rec = do(old, "GET", "/schedule-capabilities", "Bearer tok", "")
	if rec.Code != http.StatusNotFound || strings.Contains(rec.Body.String(), "registration_fence") {
		t.Fatalf("old capability response: %d %s", rec.Code, rec.Body.String())
	}
}

func TestControlNonpositiveOccurrenceArmsTimer(t *testing.T) {
	for _, requested := range []int64{0, -1, -62135596800} {
		for _, current := range []int64{1787490420, 0, -1} {
			t.Run(strconv.FormatInt(requested, 10)+"/"+strconv.FormatInt(current, 10), func(t *testing.T) {
				reg, _ := controlFixture(t)
				mux := http.NewServeMux()
				Mount(mux, "a.bab.oncarlos.com", reg, func() (string, error) { return "tok", nil }, func() time.Time { return time.Unix(current, 0) })
				body := `{"at":"` + time.Unix(requested, 0).UTC().Format(time.RFC3339) + `","path":"/jobs/remind"}`
				rec := do(mux, "PUT", "/schedule/remind", "Bearer tok", body)
				if rec.Code != http.StatusOK {
					t.Fatalf("PUT: %d %s", rec.Code, rec.Body.String())
				}
				row, err := reg.GetTimer("a.bab.oncarlos.com", "remind")
				if err != nil {
					t.Fatal(err)
				}
				if row.NextAt != max(int64(1), current) || row.DueAt != requested || row.Spec != "at "+strconv.FormatInt(requested, 10) {
					t.Fatalf("normalized timer: %+v", row)
				}
				first := row.Registration
				rec = do(mux, "PUT", "/schedule/remind", "Bearer tok", body)
				if rec.Code != http.StatusOK {
					t.Fatalf("repeat PUT: %d %s", rec.Code, rec.Body.String())
				}
				row, err = reg.GetTimer("a.bab.oncarlos.com", "remind")
				if err != nil {
					t.Fatal(err)
				}
				if row.Registration == first {
					t.Fatal("repeat PUT did not rearm")
				}
			})
		}
	}
}