package store

import (
	"os"
	"path/filepath"
	"reflect"
	"testing"
)

func TestReadManagedSessions_missingFile(t *testing.T) {
	dir := t.TempDir()
	data, err := ReadManagedSessions(dir)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if data.Sessions == nil {
		t.Error("Sessions should be non-nil empty slice, got nil")
	}
	if len(data.Sessions) != 0 {
		t.Errorf("want 0 sessions, got %d", len(data.Sessions))
	}
}

func TestManagedSessions_roundtrip(t *testing.T) {
	dir := t.TempDir()
	original := ManagedSessionsData{
		Sessions: []ManagedSession{
			{ID: "s1", Name: "Session One", ProfilePath: "/path/to/profile.json", CreatedAt: 1000},
			{ID: "s2", Name: "Session Two", ProfilePath: "", CreatedAt: 2000},
		},
	}
	if err := WriteManagedSessions(dir, original); err != nil {
		t.Fatalf("WriteManagedSessions: %v", err)
	}
	got, err := ReadManagedSessions(dir)
	if err != nil {
		t.Fatalf("ReadManagedSessions: %v", err)
	}
	if !reflect.DeepEqual(got, original) {
		t.Errorf("roundtrip mismatch:\n got  %+v\n want %+v", got, original)
	}
}

func TestWriteManagedSessions_createsSpxDir(t *testing.T) {
	dir := t.TempDir()
	data := ManagedSessionsData{Sessions: []ManagedSession{}}
	if err := WriteManagedSessions(dir, data); err != nil {
		t.Fatalf("WriteManagedSessions: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dir, ".spx", "session-names.json")); err != nil {
		t.Errorf("session-names.json not created: %v", err)
	}
}

func TestAddSession(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{}}
	s := ManagedSession{ID: "a1", Name: "Alpha", CreatedAt: 100}
	data = AddSession(data, s)
	if len(data.Sessions) != 1 {
		t.Fatalf("want 1 session, got %d", len(data.Sessions))
	}
	if data.Sessions[0] != s {
		t.Errorf("session mismatch: got %+v, want %+v", data.Sessions[0], s)
	}
}

func TestRenameSession(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{
		{ID: "a1", Name: "Old Name", CreatedAt: 100},
		{ID: "a2", Name: "Other", CreatedAt: 200},
	}}
	data = RenameSession(data, "a1", "New Name")
	if data.Sessions[0].Name != "New Name" {
		t.Errorf("want 'New Name', got %q", data.Sessions[0].Name)
	}
	// other session unchanged
	if data.Sessions[1].Name != "Other" {
		t.Errorf("other session name changed: got %q", data.Sessions[1].Name)
	}
}

func TestRenameSession_notFound(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{
		{ID: "a1", Name: "Alpha", CreatedAt: 100},
	}}
	result := RenameSession(data, "nonexistent", "X")
	if result.Sessions[0].Name != "Alpha" {
		t.Error("renaming nonexistent id should not change data")
	}
}

func TestDeleteSession(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{
		{ID: "a1", Name: "Alpha", CreatedAt: 100},
		{ID: "a2", Name: "Beta", CreatedAt: 200},
		{ID: "a3", Name: "Gamma", CreatedAt: 300},
	}}
	data = DeleteSession(data, "a2")
	if len(data.Sessions) != 2 {
		t.Fatalf("want 2 sessions after delete, got %d", len(data.Sessions))
	}
	for _, s := range data.Sessions {
		if s.ID == "a2" {
			t.Error("deleted session still present")
		}
	}
}

func TestDeleteSession_notFound(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{
		{ID: "a1", Name: "Alpha", CreatedAt: 100},
	}}
	result := DeleteSession(data, "nonexistent")
	if len(result.Sessions) != 1 {
		t.Error("deleting nonexistent id should not change session count")
	}
}

func TestFindSession(t *testing.T) {
	s := ManagedSession{ID: "a1", Name: "Alpha", CreatedAt: 100}
	data := ManagedSessionsData{Sessions: []ManagedSession{s}}

	found, ok := FindSession(data, "a1")
	if !ok {
		t.Fatal("expected to find session a1")
	}
	if found != s {
		t.Errorf("found session mismatch: got %+v, want %+v", found, s)
	}
}

func TestFindSession_notFound(t *testing.T) {
	data := ManagedSessionsData{Sessions: []ManagedSession{
		{ID: "a1", Name: "Alpha", CreatedAt: 100},
	}}
	_, ok := FindSession(data, "nope")
	if ok {
		t.Error("expected not found")
	}
}