package main

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

func TestMemoryManager(t *testing.T) {
	// Create a temporary directory for testing
	tmpDir, err := os.MkdirTemp("", "memory-test")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	// Set XDG_STATE_HOME to our temp directory
	oldStateHome := os.Getenv("XDG_STATE_HOME")
	os.Setenv("XDG_STATE_HOME", tmpDir)
	defer os.Setenv("XDG_STATE_HOME", oldStateHome)

	// Create memory manager
	memoryManager, err := NewMemoryManager()
	if err != nil {
		t.Fatalf("Failed to create memory manager: %v", err)
	}

	// Test adding memories
	testData := []struct {
		fact     string
		keywords []string
	}{
		{"The sky is blue", []string{"sky", "blue", "nature"}},
		{"Cats are mammals", []string{"cats", "mammals", "animals"}},
		{"Water freezes at 0°C", []string{"water", "ice", "temperature", "science"}},
	}

	for _, data := range testData {
		err := memoryManager.AddMemory(data.fact, data.keywords)
		if err != nil {
			t.Errorf("Failed to add memory '%s': %v", data.fact, err)
		}
	}

	// Test retrieving all memories
	memories, err := memoryManager.GetAllMemories()
	if err != nil {
		t.Fatalf("Failed to retrieve memories: %v", err)
	}

	if len(memories) != len(testData) {
		t.Errorf("Expected %d memories, got %d", len(testData), len(memories))
	}

	// Test retrieving unique keywords
	keywords, err := memoryManager.GetUniqueKeywords()
	if err != nil {
		t.Fatalf("Failed to retrieve keywords: %v", err)
	}

	// Expected number of unique keywords
	expectedKeywords := map[string]bool{
		"sky": true, "blue": true, "nature": true,
		"cats": true, "mammals": true, "animals": true,
		"water": true, "ice": true, "temperature": true, "science": true,
	}

	if len(keywords) != len(expectedKeywords) {
		t.Errorf("Expected %d unique keywords, got %d", len(expectedKeywords), len(keywords))
	}

	// Test retrieving memories by keyword
	testKeyword := "science"
	byKeyword, err := memoryManager.GetMemoriesByKeyword(testKeyword)
	if err != nil {
		t.Fatalf("Failed to retrieve memories by keyword: %v", err)
	}

	if len(byKeyword) != 1 {
		t.Errorf("Expected 1 memory with keyword '%s', got %d", testKeyword, len(byKeyword))
	}

	if len(byKeyword) > 0 && byKeyword[0].Fact != "Water freezes at 0°C" {
		t.Errorf("Expected to find 'Water freezes at 0°C' with keyword '%s', got '%s'", 
			testKeyword, byKeyword[0].Fact)
	}

	// Verify the file is created and contains the correct data
	filePath := filepath.Join(tmpDir, "memories.txt")
	if _, err := os.Stat(filePath); os.IsNotExist(err) {
		t.Errorf("Memory file was not created")
	}

	content, err := os.ReadFile(filePath)
	if err != nil {
		t.Fatalf("Failed to read memory file: %v", err)
	}

	if len(content) == 0 {
		t.Errorf("Memory file is empty")
	}
}