package workspace

import (
	"context"
	"testing"

	"munin/internal/store"
)

func TestManagerGetCachesAndOpens(t *testing.T) {
	m := NewManager(t.TempDir())
	t.Cleanup(func() { m.Close() })

	id := store.NewID()

	w1, err := m.Get(id)
	if err != nil {
		t.Fatal(err)
	}
	if w1.ID != id {
		t.Errorf("ID = %q, erwartet %q", w1.ID, id)
	}

	// Ein zweiter Zugriff auf dieselbe ID muss dieselbe, bereits offene
	// Instanz liefern — sonst würde jede Anfrage die Datei neu öffnen und
	// den Suchindex neu aufbauen.
	w2, err := m.Get(id)
	if err != nil {
		t.Fatal(err)
	}
	if w1 != w2 {
		t.Error("zweiter Get(id) hat eine neue Instanz geöffnet statt die gecachte zu liefern")
	}

	// Grundfunktion: Der gelieferte Store lässt sich tatsächlich benutzen.
	if _, err := w1.Store.CreateProject(context.Background(), id, "test", "Test", ""); err != nil {
		t.Fatal(err)
	}
}

func TestManagerGetOpensSeparateFilesPerWorkspace(t *testing.T) {
	m := NewManager(t.TempDir())
	t.Cleanup(func() { m.Close() })

	a, err := m.Get(store.NewID())
	if err != nil {
		t.Fatal(err)
	}
	b, err := m.Get(store.NewID())
	if err != nil {
		t.Fatal(err)
	}

	ctx := context.Background()
	if _, err := a.Store.CreateProject(ctx, a.ID, "in-a", "In A", ""); err != nil {
		t.Fatal(err)
	}

	// Strukturelle Trennung: Ein Projekt aus Workspace A darf in Workspace B
	// nicht auffindbar sein — sie sind unterschiedliche Dateien.
	if _, err := b.Store.ProjectBySlug(ctx, b.ID, "in-a"); err == nil {
		t.Error("Projekt aus Workspace A war über Workspace B erreichbar")
	}
}

func TestManagerCloseClosesAllOpened(t *testing.T) {
	m := NewManager(t.TempDir())

	w, err := m.Get(store.NewID())
	if err != nil {
		t.Fatal(err)
	}

	if err := m.Close(); err != nil {
		t.Fatal(err)
	}

	// Nach dem Schließen darf die Datenbank nicht mehr benutzbar sein.
	if _, err := w.Store.CreateProject(context.Background(), w.ID, "zu-spaet", "Zu spät", ""); err == nil {
		t.Error("Store nahm nach Manager.Close() noch Schreibvorgänge an")
	}
}