package test

import (
	"RenewCMS/api/pkg/apperr"
	"RenewCMS/internal/domain/audit"
	"RenewCMS/internal/infrastructure/useCases"
	"encoding/json"
	"errors"
	"net/http"
	"testing"
	"time"
)

var settingsTestZone = time.FixedZone("server", 2*60*60)

func settingsTestClock() time.Time {
	return time.Date(2026, time.October, 6, 10, 0, 0, 0, settingsTestZone)
}

func TestSettingsNextCleanupDomain(t *testing.T) {
	cases := []struct {
		name string
		days int
		now  time.Time
		next string
	}{
		{"before 03:00 today", 90, time.Date(2026, 10, 6, 2, 59, 59, 0, settingsTestZone), "2026-10-06T03:00:00+02:00"},
		{"mid day", 90, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
		{"exactly 03:00 is strictly after", 90, time.Date(2026, 10, 6, 3, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
		{"year end", 30, time.Date(2026, 12, 31, 23, 30, 0, 0, settingsTestZone), "2027-01-01T03:00:00+02:00"},
		{"365 days", 365, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
		{"forever", 0, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), ""},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			got := audit.Settings{RetentionDays: c.days}.WithNextCleanup(c.now).NextCleanupAt
			if c.next == "" {
				if got != nil {
					t.Fatalf("expected nil, got %v", got)
				}
				return
			}
			if got == nil || got.Format(time.RFC3339) != c.next {
				t.Fatalf("expected %s, got %v", c.next, got)
			}
		})
	}
}

func TestSettingsNextCleanupUseCases(t *testing.T) {
	t.Run("Get returns the next cleanup from the clock or nil for Forever", func(t *testing.T) {
		fake := newActivitySettingsFake()
		get := useCases.NewGetActivityRetentionUseCase(fake, newSizeEvents(t), settingsTestClock)

		current, err := get.GetActivityRetention()
		if err != nil || current.NextCleanupAt == nil || current.NextCleanupAt.Format(time.RFC3339) != "2026-10-07T03:00:00+02:00" {
			t.Fatalf("unexpected %+v, %v", current, err)
		}

		fake.settings.RetentionDays = 0
		current, err = get.GetActivityRetention()
		if err != nil || current.NextCleanupAt != nil {
			t.Fatalf("expected nil next cleanup, got %+v, %v", current, err)
		}
	})

	t.Run("Update returns the next cleanup of the new period", func(t *testing.T) {
		fake := newActivitySettingsFake()
		update := useCases.NewUpdateActivityRetentionUseCase(fake, newSizeEvents(t), discardRecorder, settingsTestClock)

		forever, err := update.UpdateActivityRetention(testCtx, retentionDays(0))
		if err != nil || forever.RetentionDays != 0 || forever.NextCleanupAt != nil {
			t.Fatalf("unexpected %+v, %v", forever, err)
		}
		back, err := update.UpdateActivityRetention(testCtx, retentionDays(365))
		if err != nil || back.NextCleanupAt == nil || back.NextCleanupAt.Format(time.RFC3339) != "2026-10-07T03:00:00+02:00" {
			t.Fatalf("unexpected %+v, %v", back, err)
		}
		same, err := update.UpdateActivityRetention(testCtx, retentionDays(365))
		if err != nil || same.NextCleanupAt == nil {
			t.Fatalf("unexpected %+v, %v", same, err)
		}
	})

	t.Run("Update refuses an invalid period and saves nothing", func(t *testing.T) {
		fake := newActivitySettingsFake()
		_, err := useCases.NewUpdateActivityRetentionUseCase(fake, newSizeEvents(t), discardRecorder, settingsTestClock).UpdateActivityRetention(testCtx, retentionDays(7))
		if !errors.Is(err, audit.ErrInvalidRetention) || fake.retentionOK != 0 {
			t.Fatalf("expected a refusal, got %v", err)
		}
	})
}

func TestSettingsNextCleanupHttp(t *testing.T) {
	keys := func(t *testing.T, body string) map[string]any {
		t.Helper()
		var decoded map[string]any
		if err := json.Unmarshal([]byte(body), &decoded); err != nil {
			t.Fatalf("invalid json %q: %v", body, err)
		}
		return decoded
	}

	t.Run("GET keeps the existing fields and adds exactly one next cleanup and the size fields", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)
		e.settings.settings.LastCleanupAt = activityPtr(time.Date(2026, time.October, 6, 1, 0, 0, 0, time.UTC))
		e.settings.settings.LastCleanupRemoved = 142

		rec := e.get("/v1/settings", asUser(e, activityEditorID))

		body := keys(t, rec.Body.String())
		if rec.Code != http.StatusOK || len(body) != 7 || body["activity_next_cleanup_at"] != "2026-10-07T03:00:00Z" || body["activity_last_cleanup_removed"] != float64(142) {
			t.Errorf("unexpected %d %v", rec.Code, body)
		}
	})

	t.Run("GET is null for Forever and open to an admin", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)
		e.settings.settings.RetentionDays = 0

		rec := e.get("/v1/settings", asUser(e, activityAdminID))

		body := keys(t, rec.Body.String())
		next, present := body["activity_next_cleanup_at"]
		if rec.Code != http.StatusOK || !present || next != nil {
			t.Errorf("unexpected %d %v", rec.Code, body)
		}
	})

	t.Run("PATCH returns the next cleanup of the new period", func(t *testing.T) {
		for _, c := range []struct {
			from, to int
			null     bool
		}{{90, 30, false}, {90, 0, true}, {0, 365, false}, {90, 90, false}} {
			e := newActivityHTTPEnv(t, 1000)
			e.settings.settings.RetentionDays = c.from

			rec := e.send(http.MethodPatch, "/v1/settings", `{"activity_retention_days": `+itoaSettings(c.to)+`}`, asUser(e, activityOwnerID))

			body := keys(t, rec.Body.String())
			next, present := body["activity_next_cleanup_at"]
			if rec.Code != http.StatusOK || body["activity_retention_days"] != float64(c.to) || !present || (next == nil) != c.null {
				t.Errorf("%d to %d: unexpected %d %v", c.from, c.to, rec.Code, body)
			}
			if !c.null && next != "2026-10-07T03:00:00Z" {
				t.Errorf("%d to %d: unexpected next %v", c.from, c.to, next)
			}
		}
	})
}

func TestSettingsNextCleanupQAFlow(t *testing.T) {
	t.Run("GET next cleanup follows the server clock in a +02:00 zone", func(t *testing.T) {
		cases := []struct {
			days int
			now  time.Time
			next any
		}{
			{90, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
			{90, time.Date(2026, 10, 6, 2, 59, 59, 0, settingsTestZone), "2026-10-06T03:00:00+02:00"},
			{90, time.Date(2026, 10, 6, 3, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
			{30, time.Date(2026, 12, 31, 23, 30, 0, 0, settingsTestZone), "2027-01-01T03:00:00+02:00"},
			{365, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), "2026-10-07T03:00:00+02:00"},
			{0, time.Date(2026, 10, 6, 10, 0, 0, 0, settingsTestZone), nil},
		}
		for _, c := range cases {
			e := newActivityHTTPEnv(t, 1000)
			e.now = c.now
			e.settings.settings.RetentionDays = c.days

			rec := e.get("/v1/settings", asUser(e, activityOwnerID))

			var body map[string]any
			_ = json.Unmarshal(rec.Body.Bytes(), &body)
			next, present := body["activity_next_cleanup_at"]
			if rec.Code != http.StatusOK || !present || next != c.next {
				t.Errorf("%d at %s: unexpected %d %v", c.days, c.now, rec.Code, body)
			}
		}
	})

	t.Run("GET is open to owner, admin and editor and refused without a cookie", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)
		for _, id := range []uint32{activityOwnerID, activityAdminID, activityEditorID} {
			if rec := e.get("/v1/settings", asUser(e, id)); rec.Code != http.StatusOK {
				t.Errorf("user %d: expected 200, got %d", id, rec.Code)
			}
		}
		if rec := e.get("/v1/settings"); rec.Code != http.StatusUnauthorized {
			t.Errorf("expected 401, got %d", rec.Code)
		}
	})

	t.Run("PATCH by an editor is refused and changes nothing", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)

		rec := e.send(http.MethodPatch, "/v1/settings", `{"activity_retention_days": 30}`, asUser(e, activityEditorID))

		assertPlain(t, rec, http.StatusForbidden, apperr.OwnerRequiredErrorMessage)
		if e.settings.retentionOK != 0 || len(e.all(t)) != 0 {
			t.Error("the editor changed something")
		}
	})

	t.Run("PATCH with the saved value saves nothing and records nothing", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)

		rec := e.send(http.MethodPatch, "/v1/settings", `{"activity_retention_days": 90}`, asUser(e, activityOwnerID))

		if rec.Code != http.StatusOK || e.settings.retentionOK != 0 || len(e.all(t)) != 0 {
			t.Errorf("unexpected %d, saves %d, events %d", rec.Code, e.settings.retentionOK, len(e.all(t)))
		}
	})

	t.Run("A failing settings repository answers 500", func(t *testing.T) {
		e := newActivityHTTPEnv(t, 1000)
		e.settings.getErr = errors.New("database is down")

		assertPlain(t, e.get("/v1/settings", asUser(e, activityOwnerID)), http.StatusInternalServerError, "Internal server error")
		assertPlain(t, e.send(http.MethodPatch, "/v1/settings", `{"activity_retention_days": 30}`, asUser(e, activityOwnerID)), http.StatusInternalServerError, "Internal server error")
	})

	t.Run("The next cleanup stays at 03:00 local on a DST change day", func(t *testing.T) {
		paris, err := time.LoadLocation("Europe/Paris")
		if err != nil {
			t.Skip("tzdata unavailable")
		}
		for _, c := range []struct {
			now  time.Time
			next string
		}{
			{time.Date(2026, 10, 24, 10, 0, 0, 0, paris), "2026-10-25T03:00:00+01:00"},
			{time.Date(2026, 10, 25, 1, 0, 0, 0, paris), "2026-10-25T03:00:00+01:00"},
			{time.Date(2026, 10, 25, 10, 0, 0, 0, paris), "2026-10-26T03:00:00+01:00"},
			{time.Date(2026, 3, 28, 10, 0, 0, 0, paris), "2026-03-29T03:00:00+02:00"},
		} {
			got := audit.Settings{RetentionDays: 90}.WithNextCleanup(c.now).NextCleanupAt
			if got == nil || got.Format(time.RFC3339) != c.next || got.Hour() != audit.CleanupHour {
				t.Errorf("from %s expected %s, got %v", c.now, c.next, got)
			}
		}
	})
}

func itoaSettings(n int) string {
	switch n {
	case 0:
		return "0"
	case 30:
		return "30"
	case 90:
		return "90"
	}
	return "365"
}