package export

import (
	"context"
	"fmt"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func TestBackupAndRetention(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 10, 0, 0, 0, time.Local)

	info, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Reason: "publish", Keep: 3, Now: base})
	if err != nil {
		t.Fatalf("备份: %v", err)
	}
	if info.Size == 0 || info.SHA256 == "" {
		t.Errorf("备份信息不完整: %+v", info)
	}
	if info.Reason != "publish" {
		t.Errorf("备份原因 = %q，期望 publish", info.Reason)
	}
	if _, err := os.Stat(info.Path); err != nil {
		t.Fatalf("备份文件不存在: %v", err)
	}

	// 快照必须可打开，且数据与源库一致。
	bdb := openSQLite(t, info.Path)
	if got := countRows(t, bdb, "teams"); got != 2 {
		t.Errorf("备份内 teams = %d，期望 2", got)
	}
	if got := countRows(t, bdb, "score_ledger"); got != 2 {
		t.Errorf("备份内 score_ledger = %d，期望 2", got)
	}
	_ = bdb.Close()

	// 再生成 5 份，Keep=3 应只留最近 3 份。
	for i := 1; i <= 5; i++ {
		if _, err := Backup(db, BackupOptions{
			Dir: dir, Prefix: "event", Reason: "auto", Keep: 3,
			Now: base.Add(time.Duration(i) * time.Minute),
		}); err != nil {
			t.Fatalf("第 %d 次备份: %v", i, err)
		}
	}
	list, err := ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("列出备份: %v", err)
	}
	if len(list) != 3 {
		t.Fatalf("保留份数 = %d，期望 3", len(list))
	}
	if list[0].Reason != "auto" {
		t.Errorf("最新备份原因 = %q，期望 auto", list[0].Reason)
	}

	latest, ok, err := LatestBackup(dir, "event")
	if err != nil || !ok {
		t.Fatalf("最近备份: ok=%v err=%v", ok, err)
	}
	if !latest.CreatedAt.Equal(base.Add(5 * time.Minute)) {
		t.Errorf("最近备份时间 = %s，期望 %s", latest.CreatedAt, base.Add(5*time.Minute))
	}

	if _, err := PruneBackups(dir, "event", 1); err != nil {
		t.Fatalf("手动清理: %v", err)
	}
	list, err = ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("清理后列出备份: %v", err)
	}
	if len(list) != 1 {
		t.Errorf("清理后份数 = %d，期望 1", len(list))
	}
}

func TestBackupBeforePublishAndUniqueNames(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 11, 0, 0, 0, time.Local)

	a, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Now: base, SkipPrune: true})
	if err != nil {
		t.Fatalf("备份 A: %v", err)
	}
	b, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Now: base, SkipPrune: true})
	if err != nil {
		t.Fatalf("备份 B: %v", err)
	}
	if a.Path == b.Path {
		t.Errorf("同一秒的两份备份重名: %s", a.Path)
	}

	info, err := BackupBeforePublish(db, BackupOptions{Dir: dir, Prefix: "event", Keep: 20, Now: base.Add(time.Hour)})
	if err != nil {
		t.Fatalf("发布前备份: %v", err)
	}
	if info.Reason != "publish" {
		t.Errorf("发布前备份原因 = %q，期望 publish", info.Reason)
	}
	if filepath.Dir(info.Path) != dir {
		t.Errorf("备份目录 = %q，期望 %q", filepath.Dir(info.Path), dir)
	}
}

func TestListBackupsMissingDir(t *testing.T) {
	list, err := ListBackups(filepath.Join(t.TempDir(), "不存在"), "event")
	if err != nil {
		t.Fatalf("目录不存在不应报错: %v", err)
	}
	if len(list) != 0 {
		t.Errorf("备份数 = %d，期望 0", len(list))
	}
	if _, ok, err := LatestBackup(filepath.Join(t.TempDir(), "不存在"), "event"); err != nil || ok {
		t.Errorf("空目录的最近备份: ok=%v err=%v", ok, err)
	}
}

// 间隔 <=0 关闭任务；未配置备份目录时安全跳过（不 panic、不生成文件）。
func TestStartAutoDisabled(t *testing.T) {
	dir := t.TempDir()
	svc := NewService(nil, nil, dir, 20, testLogger())
	ctx := context.Background()

	svc.StartAuto(ctx, 0)
	svc.StartAuto(ctx, -time.Minute)

	entries, err := os.ReadDir(dir)
	if err != nil {
		t.Fatalf("读取备份目录: %v", err)
	}
	if len(entries) != 0 {
		t.Fatalf("间隔 <=0 不应生成备份，实际 %d 个文件", len(entries))
	}

	// 未配置备份目录：只记日志并跳过，不能 panic。
	NewService(nil, nil, "", 20, testLogger()).StartAuto(ctx, time.Minute)
}

// 定时任务按间隔生成 auto 备份。
func TestStartAutoBacksUp(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()

	const interval = 10 * time.Millisecond
	ctx, cancel := context.WithCancel(context.Background())
	// 备份跑在后台协程里，而 t.TempDir 的清理是把目录整个删掉：测试一返回它就删，
	// 协程此刻可能刚提交下一轮备份、正往目录里写新文件，RemoveAll 于是报
	// 「unlinkat .../002: directory not empty」（本用例历史上就是这样偶发红的）。
	// 清理按后进先出执行，这条比 t.TempDir 的清理注册得晚、所以先跑：
	// 先取消 ctx 等协程真正停稳，t.TempDir 再去删就不会撞上还没落完的写。
	t.Cleanup(func() {
		cancel()
		waitAutoBackupIdle(t, dir, interval)
	})

	NewService(nil, db, dir, 20, testLogger()).StartAuto(ctx, interval)

	deadline := time.Now().Add(10 * time.Second)
	for {
		list, err := ListBackups(dir, "event")
		if err != nil {
			t.Fatalf("列出备份: %v", err)
		}
		if len(list) > 0 {
			if list[0].Reason != "auto" {
				t.Fatalf("定时备份原因 = %q，期望 auto", list[0].Reason)
			}
			return
		}
		if time.Now().After(deadline) {
			t.Fatal("10 秒内未生成定时备份")
		}
		time.Sleep(interval)
	}
}

// waitAutoBackupIdle 等自动备份的后台协程停稳后再返回（供测试在删目录前调用）。
//
// Service.Wait 才是正式入口（StartAuto 起的协程都会被它 join，含已经在飞的那一轮备份）；
// 这里仍然从目录上观察「还在不在写」，因为这一条不依赖 Service 内部实现，
// 能把「Wait 返回了但目录还在变」这种回归直接照出来。协程的退出本身是确定的——
// 每轮 select 都先看 ctx.Done，ctx 一取消就返回，最多再走完一轮已经在飞的备份——
// 所以「连续若干个 tick 目录都没有新文件落盘」就足以判定它已经停了。
func waitAutoBackupIdle(t *testing.T, dir string, interval time.Duration) {
	t.Helper()

	// 20 个 tick 的安静窗口：远大于单轮备份（这份小库几毫秒）与调度抖动，
	// 又短到不至于让用例等出可感知的慢。
	const quietTicks = 20
	quiet := quietTicks * interval
	const patience = 5 * time.Second

	deadline := time.Now().Add(patience)
	last := backupDirState(t, dir)
	quietSince := time.Now()
	for {
		time.Sleep(interval)
		if cur := backupDirState(t, dir); cur != last {
			last, quietSince = cur, time.Now()
		}
		if time.Since(quietSince) >= quiet {
			return
		}
		if time.Now().After(deadline) {
			// 非 Fatal：这里用 t.Errorf 是为了不打断后面的清理（Fatal 会跳过 t.TempDir 的清理，
			// 反而把残留目录留在 TMPDIR 里），用例仍然会红。
			t.Errorf("自动备份协程在 %s 内都没停稳，目录 %s 仍在变化", patience, dir)
			return
		}
	}
}

// backupDirState 给备份目录拍一张快照，用来判断「还有没有新备份在落盘」。
// 快照带上文件名、大小与修改时间：同一秒内的第 2、3 份备份只是文件名多了序号，
// 靠修改时间也能把它们与前一份区分开。
func backupDirState(t *testing.T, dir string) string {
	t.Helper()

	entries, err := os.ReadDir(dir)
	if err != nil {
		if os.IsNotExist(err) {
			return ""
		}
		t.Fatalf("读取备份目录 %s: %v", dir, err)
	}
	var b strings.Builder
	for _, e := range entries {
		info, err := e.Info()
		if err != nil {
			continue
		}
		fmt.Fprintf(&b, "%s|%d|%d;", e.Name(), info.Size(), info.ModTime().UnixNano())
	}
	return b.String()
}

// 超过保留份数时删除最旧的备份。
func TestServiceRunPrunesOldBackups(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()
	base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.Local)
	for i := 0; i < 3; i++ {
		if _, err := Backup(db, BackupOptions{
			Dir: dir, Prefix: "event", Reason: "auto", SkipPrune: true,
			Now: base.Add(time.Duration(i) * time.Minute),
		}); err != nil {
			t.Fatalf("预置第 %d 份备份: %v", i, err)
		}
	}

	svc := NewService(nil, db, dir, 2, testLogger())
	if _, err := svc.RunEvent("auto"); err != nil {
		t.Fatalf("RunEvent: %v", err)
	}

	list, err := ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("列出备份: %v", err)
	}
	if len(list) != 2 {
		t.Fatalf("保留份数 = %d，期望 2", len(list))
	}
	if _, err := os.Stat(filepath.Join(dir, "event-auto-20260101-000000.db")); !os.IsNotExist(err) {
		t.Errorf("最旧的备份应被删除，err=%v", err)
	}
}

// 并发触发时必须等待同一把锁，保证同一时刻只有一个 VACUUM INTO 在跑。
func TestServiceRunMutualExclusion(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	svc := NewService(nil, db, t.TempDir(), 20, testLogger())

	svc.mu.Lock()
	done := make(chan error, 1)
	go func() {
		_, err := svc.RunEvent("auto")
		done <- err
	}()
	select {
	case err := <-done:
		t.Fatalf("RunEvent 未等待互斥锁就返回: %v", err)
	case <-time.After(100 * time.Millisecond):
	}
	svc.mu.Unlock()

	select {
	case err := <-done:
		if err != nil {
			t.Fatalf("RunEvent: %v", err)
		}
	case <-time.After(10 * time.Second):
		t.Fatal("RunEvent 超时未完成")
	}
}

// prefix 为空（列出全部备份）时要剥掉已识别的前缀，不能把 event-/system- 拼进原因。
func TestReasonFromNameWithoutPrefix(t *testing.T) {
	cases := []struct{ name, want string }{
		{"event-auto-20260909-213614.db", "auto"},
		{"event-publish-20260909-213614-2.db", "publish"},
		{"system-manual-20260909-213614.db", "manual"},
		{"db-manual-20260909-213614.db", "manual"},
	}
	for _, c := range cases {
		if got := reasonFromName(c.name, ""); got != c.want {
			t.Errorf("reasonFromName(%q, \"\") = %q，期望 %q", c.name, got, c.want)
		}
	}
}

// ListBackups 不传 prefix 时也要解析出可读原因（管理端「备份」面板按原因分列）。
func TestListBackupsParsesReasonWithoutPrefix(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 12, 0, 0, 0, time.Local)

	if _, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Reason: "auto", Now: base, SkipPrune: true}); err != nil {
		t.Fatalf("赛事库备份: %v", err)
	}
	if _, err := Backup(db, BackupOptions{Dir: dir, Prefix: "system", Reason: "manual", Now: base.Add(time.Minute), SkipPrune: true}); err != nil {
		t.Fatalf("系统库备份: %v", err)
	}

	list, err := ListBackups(dir, "")
	if err != nil {
		t.Fatalf("列出全部备份: %v", err)
	}
	if len(list) != 2 {
		t.Fatalf("备份数 = %d，期望 2", len(list))
	}
	want := map[string]string{"event": "auto", "system": "manual"}
	for _, b := range list {
		var prefix string
		for p := range want {
			if strings.HasPrefix(b.Name, p+"-") {
				prefix = p
			}
		}
		if prefix == "" {
			t.Fatalf("无法识别备份前缀: %s", b.Name)
		}
		if b.Reason != want[prefix] {
			t.Errorf("%s 的原因 = %q，期望 %q", b.Name, b.Reason, want[prefix])
		}
	}
}

// 非 NotExist 错误不能让选名函数死循环（它持锁会阻塞全部备份）。
func TestUniqueBackupPathStopsOnError(t *testing.T) {
	if os.Geteuid() == 0 {
		t.Skip("root 不受目录权限限制")
	}
	dir := filepath.Join(t.TempDir(), "locked")
	if err := os.Mkdir(dir, 0o755); err != nil {
		t.Fatalf("创建目录: %v", err)
	}
	if err := os.Chmod(dir, 0o000); err != nil {
		t.Fatalf("改权限: %v", err)
	}
	t.Cleanup(func() { _ = os.Chmod(dir, 0o755) })

	done := make(chan error, 1)
	go func() {
		_, err := uniqueBackupPath(dir, "event", "auto", time.Now())
		done <- err
	}()
	select {
	case err := <-done:
		if err == nil {
			t.Fatal("目录不可读应返回错误")
		}
	case <-time.After(5 * time.Second):
		t.Fatal("uniqueBackupPath 在非 NotExist 错误上死循环")
	}
}

// 同一秒重复备份会带 -2 之类的序号，原因解析不能把它当成时间的一部分。
func TestReasonFromNameWithSequence(t *testing.T) {
	cases := []struct{ name, prefix, want string }{
		{"event-auto-20260909-213614.db", "event", "auto"},
		{"event-auto-20260909-213614-2.db", "event", "auto"},
		{"event-publish-20260909-213614-10.db", "event", "publish"},
		{"system-manual-20260909-213614.db", "system", "manual"},
	}
	for _, c := range cases {
		if got := reasonFromName(c.name, c.prefix); got != c.want {
			t.Errorf("reasonFromName(%q) = %q，期望 %q", c.name, got, c.want)
		}
	}
}

func testLogger() *slog.Logger {
	return slog.New(slog.NewTextHandler(io.Discard, nil))
}