package appbackup

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

// slash normalizes OS path separators so the assertions hold on both Linux (production) and Windows
// (dev). The double-nest invariant is about path segments, not the separator byte.
func slash(p string) string { return filepath.ToSlash(p) }

// TestNoDoubleFelhomDataForInGuestDrive asserts that for an enrolled in-guest user-data drive
// (Model A, slice 10 — the in-guest mount IS the felhom-data namespace root), none of the backup
// path helpers re-inject a felhom-data segment, so the on-host path is single-nested rather than
// the .../felhom-data/felhom-data/... double-nest that this fix removes.
func TestNoDoubleFelhomDataForInGuestDrive(t *testing.T) {
	// An enrolled drive's in-guest mount — note the basename is NOT "felhom-data".
	drive := filepath.FromSlash("/mnt/felhom-usb")
	ns := NamespaceRoot(drive, true)
	if ns != drive {
		t.Fatalf("in-guest namespace root should be the drive mount as-is: got %q want %q", ns, drive)
	}

	paths := map[string]string{
		"PrimaryBackupPath": PrimaryBackupPath(ns),
		"AppDBDumpPath":     AppDBDumpPath(ns, "nextcloud"),
		"AppVolumeDumpPath": AppVolumeDumpPath(ns, "nextcloud"),
		"AppDataDir":        AppDataDir(ns, "nextcloud"),
	}
	for name, p := range paths {
		sp := slash(p)
		if strings.Contains(sp, FelhomDataDir+"/"+FelhomDataDir) {
			t.Errorf("%s double-nests felhom-data: %q", name, sp)
		}
		if n := strings.Count(sp, FelhomDataDir); n > 1 {
			t.Errorf("%s has %d felhom-data segments (want <=1): %q", name, n, sp)
		}
		if !strings.HasPrefix(sp, "/mnt/felhom-usb/") {
			t.Errorf("%s not rooted at the drive mount: %q", name, sp)
		}
	}

	// Concrete expected single-nested DB-dump path for a drive-resident app.
	if got, want := slash(AppDBDumpPath(ns, "nextcloud")), "/mnt/felhom-usb/backups/primary/nextcloud/db-dumps"; got != want {
		t.Errorf("drive-resident DB-dump path: got %q want %q", got, want)
	}
}

// TestSystemFallbackNestsOnceUnderFelhomData asserts the SSD-only system-data fallback still nests
// under exactly one felhom-data segment (the bare drive root does NOT already contain the namespace).
func TestSystemFallbackNestsOnceUnderFelhomData(t *testing.T) {
	ns := NamespaceRoot(filepath.FromSlash("/mnt/sys_drive"), false)
	if want := filepath.Join(filepath.FromSlash("/mnt/sys_drive"), FelhomDataDir); ns != want {
		t.Fatalf("system fallback namespace root: got %q want %q", ns, want)
	}
	got := slash(AppDBDumpPath(ns, "nextcloud"))
	if want := "/mnt/sys_drive/felhom-data/backups/primary/nextcloud/db-dumps"; got != want {
		t.Errorf("system fallback DB-dump path: got %q want %q", got, want)
	}
	if n := strings.Count(got, FelhomDataDir); n != 1 {
		t.Errorf("system fallback should have exactly one felhom-data segment, got %d: %q", n, got)
	}
}