package vaultview

import (
	"slices"
	"testing"

	"git.julianfamily.org/keepassgo/internal/vault"
)

func TestVaultRootProjectsKeepassStorageRoot(t *testing.T) {
	t.Parallel()

	model := vault.Model{
		Entries: []vault.Entry{
			{ID: "bellagio-ledger", Title: "Bellagio Ledger", Path: []string{"keepass", "Crew", "Internet"}},
			{ID: "fountain-cameras", Title: "Fountain Cameras", Path: []string{"keepass", "Crew", "Security"}},
		},
		Groups: [][]string{
			{"keepass"},
			{"keepass", "Crew"},
			{"keepass", "Crew", "Internet"},
			{"keepass", "Crew", "Security"},
			{"Recycle Bin"},
		},
	}

	view := VaultRoot(model)

	if got := view.ChildGroups(nil); !slices.Equal(got, []string{"Crew"}) {
		t.Fatalf("VaultRoot(model).ChildGroups(nil) = %v, want [Crew]", got)
	}
	if got := view.ChildGroups([]string{"Crew"}); !slices.Equal(got, []string{"Internet", "Security"}) {
		t.Fatalf("VaultRoot(model).ChildGroups([Crew]) = %v, want [Internet Security]", got)
	}

	gotEntries := view.EntriesInPath([]string{"Crew", "Internet"})
	if len(gotEntries) != 1 || !slices.Equal(gotEntries[0].Path, []string{"Crew", "Internet"}) {
		t.Fatalf("VaultRoot(model).EntriesInPath([Crew Internet]) = %#v, want logical path [Crew Internet]", gotEntries)
	}

	if got := view.ToPhysicalPath(nil); !slices.Equal(got, []string{"keepass"}) {
		t.Fatalf("VaultRoot(model).ToPhysicalPath(nil) = %v, want [keepass]", got)
	}
	if got := view.ToPhysicalPath([]string{"Crew", "Internet"}); !slices.Equal(got, []string{"keepass", "Crew", "Internet"}) {
		t.Fatalf("VaultRoot(model).ToPhysicalPath([Crew Internet]) = %v, want [keepass Crew Internet]", got)
	}
	if got := view.FromPhysicalPath([]string{"keepass", "Crew", "Internet"}); !slices.Equal(got, []string{"Crew", "Internet"}) {
		t.Fatalf("VaultRoot(model).FromPhysicalPath([keepass Crew Internet]) = %v, want [Crew Internet]", got)
	}
}

func TestVaultRecycleBinProjectsRecycleTree(t *testing.T) {
	t.Parallel()

	model := vault.Model{
		RecycleBin: []vault.Entry{
			{ID: "bellagio-ledger", Title: "Bellagio Ledger", Path: []string{"Crew", "Internet"}},
			{ID: "fountain-cameras", Title: "Fountain Cameras", Path: []string{"Crew", "Security"}},
		},
	}

	view := VaultRecycleBin(model)

	if got := view.ChildGroups(nil); !slices.Equal(got, []string{"Crew"}) {
		t.Fatalf("VaultRecycleBin(model).ChildGroups(nil) = %v, want [Crew]", got)
	}
	if got := view.ChildGroups([]string{"Crew"}); !slices.Equal(got, []string{"Internet", "Security"}) {
		t.Fatalf("VaultRecycleBin(model).ChildGroups([Crew]) = %v, want [Internet Security]", got)
	}

	gotEntries := view.EntriesInPath([]string{"Crew", "Internet"})
	if len(gotEntries) != 1 || !slices.Equal(gotEntries[0].Path, []string{"Crew", "Internet"}) {
		t.Fatalf("VaultRecycleBin(model).EntriesInPath([Crew Internet]) = %#v, want logical recycle-bin path [Crew Internet]", gotEntries)
	}

	if got := view.ToPhysicalPath([]string{"Crew", "Internet"}); !slices.Equal(got, []string{"Crew", "Internet"}) {
		t.Fatalf("VaultRecycleBin(model).ToPhysicalPath([Crew Internet]) = %v, want [Crew Internet]", got)
	}
}

func TestVaultTemplatesProjectsTemplatesStorageRoot(t *testing.T) {
	t.Parallel()

	model := vault.Model{
		Templates: []vault.Entry{
			{ID: "website-login", Title: "Website Login", Path: []string{"Templates", "Web"}},
			{ID: "ssh-login", Title: "SSH Login", Path: []string{"Templates", "Infra"}},
		},
		Groups: [][]string{
			{"Templates"},
			{"Templates", "Infra"},
			{"Templates", "Web"},
			{"keepass"},
		},
	}

	view := VaultTemplates(model)

	if got := view.ChildGroups(nil); !slices.Equal(got, []string{"Infra", "Web"}) {
		t.Fatalf("VaultTemplates(model).ChildGroups(nil) = %v, want [Infra Web]", got)
	}

	gotEntries := view.EntriesInPath([]string{"Web"})
	if len(gotEntries) != 1 || !slices.Equal(gotEntries[0].Path, []string{"Web"}) {
		t.Fatalf("VaultTemplates(model).EntriesInPath([Web]) = %#v, want logical path [Web]", gotEntries)
	}

	if got := view.ToPhysicalPath(nil); !slices.Equal(got, []string{"Templates"}) {
		t.Fatalf("VaultTemplates(model).ToPhysicalPath(nil) = %v, want [Templates]", got)
	}
	if got := view.ToPhysicalPath([]string{"Web"}); !slices.Equal(got, []string{"Templates", "Web"}) {
		t.Fatalf("VaultTemplates(model).ToPhysicalPath([Web]) = %v, want [Templates Web]", got)
	}
	if got := view.FromPhysicalPath([]string{"Templates", "Web"}); !slices.Equal(got, []string{"Web"}) {
		t.Fatalf("VaultTemplates(model).FromPhysicalPath([Templates Web]) = %v, want [Web]", got)
	}
}

func TestVaultReturnsPhysicalPathsUnchanged(t *testing.T) {
	t.Parallel()

	model := vault.Model{
		Entries: []vault.Entry{
			{ID: "bellagio-ledger", Title: "Bellagio Ledger", Path: []string{"keepass", "Crew", "Internet"}},
		},
	}

	view := Vault(model)

	if got := view.ChildGroups(nil); !slices.Equal(got, []string{"keepass"}) {
		t.Fatalf("Vault(model).ChildGroups(nil) = %v, want [keepass]", got)
	}
	if got := view.ToPhysicalPath([]string{"keepass", "Crew"}); !slices.Equal(got, []string{"keepass", "Crew"}) {
		t.Fatalf("Vault(model).ToPhysicalPath([keepass Crew]) = %v, want [keepass Crew]", got)
	}
	if got := view.FromPhysicalEntry(model.Entries[0]); !slices.Equal(got.Path, []string{"keepass", "Crew", "Internet"}) {
		t.Fatalf("Vault(model).FromPhysicalEntry(entry).Path = %v, want [keepass Crew Internet]", got.Path)
	}
}