add_test.go

package cmd

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

	"github.com/substantialcattle5/sietch/testutil"
)

func TestParseFileArguments(t *testing.T) {
	tests := []struct {
		name        string
		args        []string
		expected    []FilePair
		expectError bool
	}{
		{
			name: "single file pair",
			args: []string{"source.txt", "dest/"},
			expected: []FilePair{
				{Source: "source.txt", Destination: "dest/"},
			},
			expectError: false,
		},
		{
			name: "multiple paired arguments",
			args: []string{"file1.txt", "dest1/", "file2.txt", "dest2/"},
			expected: []FilePair{
				{Source: "file1.txt", Destination: "dest1/"},
				{Source: "file2.txt", Destination: "dest2/"},
			},
			expectError: false,
		},
		{
			name: "even number of args - paired pattern",
			args: []string{"file1.txt", "file2.txt", "file3.txt", "dest/"},
			expected: []FilePair{
				{Source: "file1.txt", Destination: "file2.txt"},
				{Source: "file3.txt", Destination: "dest/"},
			},
			expectError: false,
		},
		{
			name:        "insufficient arguments",
			args:        []string{"source.txt"},
			expected:    nil,
			expectError: true,
		},
		{
			name: "complex file paths",
			args: []string{"/path/to/file1.txt", "/another/path/dest1/", "~/file2.txt", "./dest2/"},
			expected: []FilePair{
				{Source: "/path/to/file1.txt", Destination: "/another/path/dest1/"},
				{Source: "~/file2.txt", Destination: "./dest2/"},
			},
			expectError: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parseFileArguments(tt.args)

			if tt.expectError {
				if err == nil {
					t.Errorf("Expected error but got none")
				}
				return
			}

			if err != nil {
				t.Errorf("Unexpected error: %v", err)
				return
			}

			if len(result) != len(tt.expected) {
				t.Errorf("Expected %d pairs, got %d", len(tt.expected), len(result))
				return
			}

			for i, expected := range tt.expected {
				if result[i].Source != expected.Source {
					t.Errorf("Pair %d: expected source %s, got %s", i, expected.Source, result[i].Source)
				}
				if result[i].Destination != expected.Destination {
					t.Errorf("Pair %d: expected destination %s, got %s", i, expected.Destination, result[i].Destination)
				}
			}
		})
	}
}

func TestAddCommandUsageText(t *testing.T) {
	// Check that usage text reflects multiple file support
	usageText := addCmd.Use

	if !strings.Contains(usageText, "[source_path2] [destination_path2]...") {
		t.Errorf("Usage text should indicate multiple file support, got: %s", usageText)
	}
}

func TestAddCommandLongDescription(t *testing.T) {
	// Check that long description contains multiple file support information
	longText := addCmd.Long

	expectedPhrases := []string{
		"multiple files",
		"Paired arguments",
		"Single destination",
		"source1 dest1 source2 dest2",
		"source1 source2 ... dest",
	}

	for _, phrase := range expectedPhrases {
		if !strings.Contains(longText, phrase) {
			t.Errorf("Long description should contain '%s'", phrase)
		}
	}
}

func TestAddCommandShortDescription(t *testing.T) {
	// Check that short description reflects multiple file support
	shortText := addCmd.Short

	if !strings.Contains(shortText, "one or more files") {
		t.Errorf("Short description should indicate multiple file support, got: %s", shortText)
	}
}

func TestAddCommandWithMockVault(t *testing.T) {
	testutil.SkipIfShort(t, "integration test")

	// Create a mock vault for testing
	mockConfig := testutil.NewMockConfig(t, "add-test")
	mockConfig.SetupTestVault(t)

	// Create test files
	testFile1 := testutil.CreateTestFile(t, mockConfig.VaultPath, "test1.txt", "test content 1")
	testFile2 := testutil.CreateTestFile(t, mockConfig.VaultPath, "test2.txt", "test content 2")

	// Change to vault directory
	originalDir, _ := os.Getwd()
	os.Chdir(mockConfig.VaultPath)
	defer os.Chdir(originalDir)

	// Test multiple file addition (this would require more setup for full integration)
	// For now, we test that the argument parsing works correctly
	args := []string{testFile1, "docs/", testFile2, "data/"}
	filePairs, err := parseFileArguments(args)

	if err != nil {
		t.Fatalf("Failed to parse arguments: %v", err)
	}

	expected := []FilePair{
		{Source: testFile1, Destination: "docs/"},
		{Source: testFile2, Destination: "data/"},
	}

	if len(filePairs) != len(expected) {
		t.Fatalf("Expected %d pairs, got %d", len(expected), len(filePairs))
	}

	for i, expected := range expected {
		if filePairs[i].Source != expected.Source {
			t.Errorf("Pair %d: expected source %s, got %s", i, expected.Source, filePairs[i].Source)
		}
		if filePairs[i].Destination != expected.Destination {
			t.Errorf("Pair %d: expected destination %s, got %s", i, expected.Destination, filePairs[i].Destination)
		}
	}
}

func TestAddCommandErrorHandling(t *testing.T) {
	// Test error handling for various scenarios
	tests := []struct {
		name        string
		args        []string
		setupFunc   func(t *testing.T, dir string) // Function to set up test scenario
		expectError bool
	}{
		{
			name: "nonexistent source file",
			args: []string{"/nonexistent/file.txt", "dest/"},
			setupFunc: func(t *testing.T, dir string) {
				// No setup needed - file should not exist
			},
			expectError: true,
		},
		{
			name: "directory as source",
			args: []string{"."}, // Current directory
			setupFunc: func(t *testing.T, dir string) {
				// Current directory exists but is a directory
			},
			expectError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tempDir := testutil.TempDir(t, "error-test")
			defer os.RemoveAll(tempDir)

			// Run setup if provided
			if tt.setupFunc != nil {
				tt.setupFunc(t, tempDir)
			}

			// Change to temp directory
			originalDir, _ := os.Getwd()
			os.Chdir(tempDir)
			defer os.Chdir(originalDir)

			// Test that argument parsing works (even if file operations fail later)
			_, err := parseFileArguments(tt.args)
			if err != nil && !tt.expectError {
				t.Errorf("Unexpected error in argument parsing: %v", err)
			}
		})
	}
}

func TestAddCommandBatchProcessingOutput(t *testing.T) {
	// Test that batch processing shows appropriate progress messages
	// This is a unit test that focuses on the output formatting logic

	tempDir := testutil.TempDir(t, "output-test")
	defer os.RemoveAll(tempDir)

	// Create test files
	testFiles := make([]string, 3)
	for i := 0; i < 3; i++ {
		testFiles[i] = testutil.CreateTestFile(t, tempDir, "test"+string(rune('1'+i))+".txt", "content "+string(rune('1'+i)))
	}

	// Test paired arguments
	pairedArgs := []string{testFiles[0], "dest1/", testFiles[1], "dest2/"}
	filePairs, err := parseFileArguments(pairedArgs)
	if err != nil {
		t.Fatalf("Failed to parse paired arguments: %v", err)
	}

	if len(filePairs) != 2 {
		t.Errorf("Expected 2 pairs, got %d", len(filePairs))
	}

	// Test single destination arguments
	singleDestArgs := []string{testFiles[0], testFiles[1], "common-dest/"}
	filePairs2, err := parseFileArguments(singleDestArgs)
	if err != nil {
		t.Fatalf("Failed to parse single destination arguments: %v", err)
	}

	if len(filePairs2) != 2 {
		t.Errorf("Expected 2 pairs, got %d", len(filePairs2))
	}

	// Verify all files go to same destination
	for _, pair := range filePairs2 {
		if pair.Destination != "common-dest/" {
			t.Errorf("Expected destination 'common-dest/', got '%s'", pair.Destination)
		}
	}
}

func TestAddCommandFilenameBugFix(t *testing.T) {
	// Test for the bug fix: files with same basename from different directories
	// should be stored with correct destination filenames, not source basenames
	testutil.SkipIfShort(t, "integration test")

	// Create a mock vault for testing
	mockConfig := testutil.NewMockConfig(t, "filename-bug-test")
	mockConfig.SetupTestVault(t)

	// Create test files with same basename in different directories
	sourceDir1 := testutil.TempDir(t, "source1")
	sourceDir2 := testutil.TempDir(t, "source2")

	testFile1 := testutil.CreateTestFile(t, sourceDir1, "test.txt", "content from dir 1")
	testFile2 := testutil.CreateTestFile(t, sourceDir2, "test.txt", "content from dir 2")

	// Change to vault directory
	originalDir, _ := os.Getwd()
	os.Chdir(mockConfig.VaultPath)
	defer os.Chdir(originalDir)

	// Test adding files with same basename to different destinations
	// This tests the fix for the bug where filepath.Base(pair.Source) was used
	// instead of destFileName for manifest storage
	args := []string{testFile1, "docs/file1.txt", testFile2, "data/file2.txt"}

	// Parse arguments to verify they are correct
	filePairs, err := parseFileArguments(args)
	if err != nil {
		t.Fatalf("Failed to parse arguments: %v", err)
	}

	expected := []FilePair{
		{Source: testFile1, Destination: "docs/file1.txt"},
		{Source: testFile2, Destination: "data/file2.txt"},
	}

	if len(filePairs) != len(expected) {
		t.Fatalf("Expected %d pairs, got %d", len(expected), len(filePairs))
	}

	// Verify the destinations are different (this is what the bug fix ensures)
	if filePairs[0].Destination == filePairs[1].Destination {
		t.Errorf("Bug not fixed: both files have same destination %s", filePairs[0].Destination)
	}

	// Verify that the destination filenames are different
	destFileName1 := filepath.Base(filePairs[0].Destination)
	destFileName2 := filepath.Base(filePairs[1].Destination)

	if destFileName1 == destFileName2 {
		t.Errorf("Bug not fixed: both files have same destination filename %s", destFileName1)
	}

	// Verify that source basenames are the same (this was causing the bug)
	sourceBaseName1 := filepath.Base(filePairs[0].Source)
	sourceBaseName2 := filepath.Base(filePairs[1].Source)

	if sourceBaseName1 != sourceBaseName2 {
		t.Errorf("Test setup error: source basenames should be same, got %s vs %s", sourceBaseName1, sourceBaseName2)
	}

	if sourceBaseName1 != "test.txt" {
		t.Errorf("Test setup error: expected source basename 'test.txt', got %s", sourceBaseName1)
	}

	// The key test: destination filenames should be different
	if destFileName1 != "file1.txt" || destFileName2 != "file2.txt" {
		t.Errorf("Bug not fixed: expected destination filenames 'file1.txt' and 'file2.txt', got '%s' and '%s'",
			destFileName1, destFileName2)
	}
}