package notes

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	"verstak/internal/core/files"
	"verstak/internal/core/nodes"
	"verstak/internal/core/storage"
)

func setupService(t *testing.T) (*Service, *nodes.Repository, string) {
	t.Helper()
	dir := t.TempDir()
	db, err := storage.Open(filepath.Join(dir, "test.db"))
	if err != nil {
		t.Fatalf("open db: %v", err)
	}
	t.Cleanup(func() { db.Close() })

	nodeRepo := nodes.NewRepository(db)
	fileSvc := files.NewService(db, dir)
	svc := NewService(db, dir, nodeRepo, fileSvc)
	return svc, nodeRepo, dir
}

func TestCreateAndRead(t *testing.T) {
	svc, _, vaultRoot := setupService(t)

	node, fileRec, err := svc.Create("", "My Note")
	if err != nil {
		t.Fatalf("Create: %v", err)
	}
	if node.Title != "My Note" {
		t.Errorf("title = %q", node.Title)
	}
	if fileRec == nil || fileRec.ID == "" {
		t.Fatal("file record missing")
	}

	// Read initial content.
	content, err := svc.Read(node.ID)
	if err != nil {
		t.Fatalf("Read: %v", err)
	}
	if !strings.Contains(content, "My Note") {
		t.Errorf("content = %q", content)
	}

	// Verify file on disk.
	spacesDir := filepath.Join(vaultRoot, "spaces")
	entries, _ := os.ReadDir(spacesDir)
	if len(entries) == 0 {
		t.Error("expected file in spaces/")
	}
}

func TestSaveAndBackup(t *testing.T) {
	svc, _, vaultRoot := setupService(t)

	node, _, _ := svc.Create("", "Backup Test")

	// Save new content.
	newContent := "# Updated\n\nThis is the new content."
	if err := svc.Save(node.ID, newContent); err != nil {
		t.Fatalf("Save: %v", err)
	}

	// Read back.
	got, err := svc.Read(node.ID)
	if err != nil {
		t.Fatal(err)
	}
	if got != newContent {
		t.Errorf("content = %q, want %q", got, newContent)
	}

	// Check backup exists.
	histDir := filepath.Join(vaultRoot, ".verstak", "history")
	entries, _ := os.ReadDir(histDir)
	if len(entries) != 1 {
		t.Errorf("backup count = %d, want 1", len(entries))
	}
}

func TestDeleteNote(t *testing.T) {
	svc, nodeRepo, _ := setupService(t)

	node, _, _ := svc.Create("", "To Delete")
	if err := svc.Delete(node.ID); err != nil {
		t.Fatal(err)
	}

	if _, err := nodeRepo.GetActive(node.ID); err == nil {
		t.Error("expected deleted node to be inactive")
	}
}