package history

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"testing"
	"time"
)

func TestAddDoesNotCapAtFiftyEntries(t *testing.T) {
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
	}

	for i := 0; i < 60; i++ {
		store.Add("history entry")
	}

	entries := store.GetAll()
	if len(entries) != 60 {
		t.Fatalf("expected 60 entries, got %d", len(entries))
	}

	fd := readHistoryFile(t, store.path)
	if len(fd.Entries) != 60 {
		t.Fatalf("expected 60 persisted entries, got %d", len(fd.Entries))
	}
}

func TestRetentionPrunesMemoryAndFile(t *testing.T) {
	now := time.Now()
	store := &Store{
		retentionDays: 7,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "new entry", Timestamp: now.UnixMilli()},
			{Text: "old entry", Timestamp: now.AddDate(0, 0, -8).UnixMilli()},
		},
	}

	entries := store.GetAll()
	if len(entries) != 1 {
		t.Fatalf("expected 1 retained entry, got %d", len(entries))
	}
	if entries[0].Text != "new entry" {
		t.Fatalf("expected new entry to be retained, got %q", entries[0].Text)
	}

	fd := readHistoryFile(t, store.path)
	if len(fd.Entries) != 1 {
		t.Fatalf("expected 1 persisted entry, got %d", len(fd.Entries))
	}
	if fd.Entries[0].Text != "new entry" {
		t.Fatalf("expected persisted new entry, got %q", fd.Entries[0].Text)
	}
}

func TestSetRetentionDaysRejectsUnsupportedValues(t *testing.T) {
	store := &Store{
		retentionDays: 30,
		path:          filepath.Join(t.TempDir(), "history.json"),
	}

	if err := store.SetRetentionDays(365); err == nil {
		t.Fatal("expected unsupported retention value to fail")
	}
	if got := store.GetRetentionDays(); got != 30 {
		t.Fatalf("expected retention to remain 30, got %d", got)
	}
}

func TestLoadNormalizesUnsupportedRetention(t *testing.T) {
	path := filepath.Join(t.TempDir(), "history.json")
	data, err := json.Marshal(fileData{
		RetentionDays: intPtr(365),
		Entries:       []Entry{{Text: "entry", Timestamp: time.Now().UnixMilli()}},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(path, data, 0644); err != nil {
		t.Fatal(err)
	}

	store := &Store{
		retentionDays: 30,
		path:          path,
	}
	store.load()

	if got := store.GetRetentionDays(); got != 30 {
		t.Fatalf("expected invalid loaded retention to normalize to 30, got %d", got)
	}
}

func TestGetUnexportedFiltersByScope(t *testing.T) {
	loc := time.FixedZone("UTC+8", 8*60*60)
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, loc)
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "today", Timestamp: now.Add(-time.Hour).UnixMilli()},
			{Text: "exported", Timestamp: now.Add(-2 * time.Hour).UnixMilli(), ExportedAt: now.UnixMilli()},
			{Text: "yesterday", Timestamp: now.AddDate(0, 0, -1).UnixMilli()},
			{Text: "old", Timestamp: now.AddDate(0, 0, -8).UnixMilli()},
		},
	}

	today := store.GetUnexported(ExportScopeToday, now, loc)
	if len(today) != 1 || today[0].Text != "today" {
		t.Fatalf("expected only today's unexported entry, got %+v", today)
	}

	last7Days := store.GetUnexported(ExportScopeLast7Days, now, loc)
	if len(last7Days) != 2 || last7Days[0].Text != "today" || last7Days[1].Text != "yesterday" {
		t.Fatalf("expected today and yesterday, got %+v", last7Days)
	}

	all := store.GetUnexported(ExportScopeAll, now, loc)
	if len(all) != 3 || all[0].Text != "today" || all[1].Text != "yesterday" || all[2].Text != "old" {
		t.Fatalf("expected all unexported entries, got %+v", all)
	}
}

func TestGetPageClampsAndReturnsCurrentSlice(t *testing.T) {
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
	}
	for i := 0; i < 12; i++ {
		store.entries = append(store.entries, Entry{
			Text:      fmt.Sprintf("entry %02d", i),
			Timestamp: int64(1000 - i),
		})
	}

	page := store.GetPage(2, 5)
	if page.Total != 12 || page.TotalPages != 3 || page.Page != 2 || page.PageSize != 5 {
		t.Fatalf("unexpected page metadata: %+v", page)
	}
	if len(page.Entries) != 5 || page.Entries[0].Text != "entry 05" || page.Entries[4].Text != "entry 09" {
		t.Fatalf("unexpected page entries: %+v", page.Entries)
	}

	last := store.GetPage(99, 5)
	if last.Page != 3 || len(last.Entries) != 2 || last.Entries[0].Text != "entry 10" {
		t.Fatalf("expected clamped last page, got %+v", last)
	}

	defaultSize := store.GetPage(1, 0)
	if defaultSize.PageSize != defaultPageSize {
		t.Fatalf("expected default page size %d, got %d", defaultPageSize, defaultSize.PageSize)
	}
}

func TestGetPageHandlesEmptyHistory(t *testing.T) {
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
	}

	page := store.GetPage(4, 100)
	if page.Total != 0 || page.TotalPages != 0 || page.Page != 1 || len(page.Entries) != 0 {
		t.Fatalf("unexpected empty page: %+v", page)
	}
}

func TestCountsSummarizesFullHistory(t *testing.T) {
	loc := time.FixedZone("UTC+8", 8*60*60)
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, loc)
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "today", Timestamp: now.Add(-time.Hour).UnixMilli()},
			{Text: "exported", Timestamp: now.Add(-2 * time.Hour).UnixMilli(), ExportedAt: now.UnixMilli()},
			{Text: "yesterday", Timestamp: now.AddDate(0, 0, -1).UnixMilli()},
			{Text: "old", Timestamp: now.AddDate(0, 0, -8).UnixMilli()},
			{Text: "corrupt exportedAt", Timestamp: now.Add(-3 * time.Hour).UnixMilli(), ExportedAt: -1},
		},
	}

	counts := store.Counts(now, loc)
	if counts.TotalCount != 5 {
		t.Fatalf("expected total 5, got %+v", counts)
	}
	if counts.ExportedCount != 1 {
		t.Fatalf("expected exported 1, got %+v", counts)
	}
	if counts.UnexportedAllCount != 4 || counts.UnexportedLast7DaysCount != 3 || counts.UnexportedTodayCount != 2 {
		t.Fatalf("unexpected unexported counts: %+v", counts)
	}
}

func TestMarkExportedPersistsExportedAt(t *testing.T) {
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, time.UTC)
	exportedAt := now.Add(time.Minute).UnixMilli()
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "one", Timestamp: now.UnixMilli()},
			{Text: "two", Timestamp: now.Add(-time.Minute).UnixMilli()},
		},
	}

	updated, err := store.MarkExported([]int64{store.entries[0].Timestamp}, exportedAt)
	if err != nil {
		t.Fatal(err)
	}
	if updated != 1 {
		t.Fatalf("expected 1 updated entry, got %d", updated)
	}
	if store.entries[0].ExportedAt != exportedAt {
		t.Fatalf("expected exportedAt %d, got %d", exportedAt, store.entries[0].ExportedAt)
	}
	if store.entries[1].ExportedAt != 0 {
		t.Fatalf("expected unmatched entry to remain unexported, got %d", store.entries[1].ExportedAt)
	}

	fd := readHistoryFile(t, store.path)
	if len(fd.Entries) != 2 || fd.Entries[0].ExportedAt != exportedAt {
		t.Fatalf("expected exportedAt to persist, got %+v", fd.Entries)
	}
}

func TestMarkExportedRollsBackOnSaveFailure(t *testing.T) {
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, time.UTC)
	path := filepath.Join(t.TempDir(), "history.json")
	if err := os.Mkdir(path, 0755); err != nil {
		t.Fatal(err)
	}
	store := &Store{
		retentionDays: 0,
		path:          path,
		entries: []Entry{
			{Text: "one", Timestamp: now.UnixMilli()},
		},
	}

	updated, err := store.MarkExported([]int64{store.entries[0].Timestamp}, now.UnixMilli())
	if err == nil {
		t.Fatal("expected save failure")
	}
	if updated != 0 {
		t.Fatalf("expected 0 updated entries after rollback, got %d", updated)
	}
	if store.entries[0].ExportedAt != 0 {
		t.Fatalf("expected exportedAt rollback, got %d", store.entries[0].ExportedAt)
	}
}

func TestMarkExportedReplacesNonPositiveExportedAt(t *testing.T) {
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, time.UTC)
	exportedAt := now.Add(time.Minute).UnixMilli()
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "negative", Timestamp: now.UnixMilli(), ExportedAt: -1},
		},
	}

	updated, err := store.MarkExported([]int64{store.entries[0].Timestamp}, exportedAt)
	if err != nil {
		t.Fatal(err)
	}
	if updated != 1 {
		t.Fatalf("expected 1 updated entry, got %d", updated)
	}
	if store.entries[0].ExportedAt != exportedAt {
		t.Fatalf("expected exportedAt to be replaced, got %d", store.entries[0].ExportedAt)
	}
}

func TestClearExportedRemovesOnlyPositiveExportedAt(t *testing.T) {
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, time.UTC)
	store := &Store{
		retentionDays: 0,
		path:          filepath.Join(t.TempDir(), "history.json"),
		entries: []Entry{
			{Text: "exported", Timestamp: now.UnixMilli(), ExportedAt: now.UnixMilli()},
			{Text: "unexported", Timestamp: now.Add(-time.Minute).UnixMilli()},
			{Text: "zero", Timestamp: now.Add(-2 * time.Minute).UnixMilli(), ExportedAt: 0},
			{Text: "negative", Timestamp: now.Add(-3 * time.Minute).UnixMilli(), ExportedAt: -1},
		},
	}

	result, err := store.ClearExported()
	if err != nil {
		t.Fatal(err)
	}
	if result.DeletedCount != 1 || result.RemainingCount != 3 {
		t.Fatalf("unexpected result: %+v", result)
	}
	if len(store.entries) != 3 {
		t.Fatalf("expected 3 remaining entries, got %d", len(store.entries))
	}
	for _, entry := range store.entries {
		if entry.Text == "exported" {
			t.Fatalf("exported entry was not removed: %+v", store.entries)
		}
	}

	fd := readHistoryFile(t, store.path)
	if len(fd.Entries) != 3 {
		t.Fatalf("expected persisted 3 entries, got %+v", fd.Entries)
	}
}

func TestClearExportedRollsBackOnSaveFailure(t *testing.T) {
	now := time.Date(2026, 5, 30, 15, 0, 0, 0, time.UTC)
	path := filepath.Join(t.TempDir(), "history.json")
	if err := os.Mkdir(path, 0755); err != nil {
		t.Fatal(err)
	}
	store := &Store{
		retentionDays: 0,
		path:          path,
		entries: []Entry{
			{Text: "exported", Timestamp: now.UnixMilli(), ExportedAt: now.UnixMilli()},
			{Text: "unexported", Timestamp: now.Add(-time.Minute).UnixMilli()},
		},
	}

	result, err := store.ClearExported()
	if err == nil {
		t.Fatal("expected save failure")
	}
	if result.DeletedCount != 0 || result.RemainingCount != 0 {
		t.Fatalf("expected empty result after rollback, got %+v", result)
	}
	if len(store.entries) != 2 || store.entries[0].Text != "exported" {
		t.Fatalf("expected entries rollback, got %+v", store.entries)
	}
}

func TestLoadOldHistoryWithoutExportedAtDefaultsToUnexported(t *testing.T) {
	path := filepath.Join(t.TempDir(), "history.json")
	data := []byte(`{"retentionDays":0,"entries":[{"text":"old format","timestamp":1780134620883}]}`)
	if err := os.WriteFile(path, data, 0644); err != nil {
		t.Fatal(err)
	}

	store := &Store{
		retentionDays: 30,
		path:          path,
	}
	store.load()

	entries := store.GetAll()
	if len(entries) != 1 {
		t.Fatalf("expected 1 entry, got %d", len(entries))
	}
	if entries[0].ExportedAt != 0 {
		t.Fatalf("expected old entry to load as unexported, got exportedAt=%d", entries[0].ExportedAt)
	}
}

func readHistoryFile(t *testing.T, path string) fileData {
	t.Helper()
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	var fd fileData
	if err := json.Unmarshal(data, &fd); err != nil {
		t.Fatal(err)
	}
	return fd
}

func intPtr(v int) *int {
	return &v
}