package utils

import (
	"os"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestPrepareRepository(t *testing.T) {
	// Initialize logger
	InitLogger(true)

	// Test with an invalid repository URL
	t.Run("Invalid repository URL", func(t *testing.T) {
		invalidRepo := &GitRepository{
			Name:   "://invalid-url",
			Branch: "main",
		}
		err := PrepareRepository(invalidRepo)
		assert.Error(t, err, "Should error with invalid repository URL")
	})

	// Test with local repository
	t.Run("Local repository", func(t *testing.T) {
		// Create a temporary directory
		tempDir, err := os.MkdirTemp("", "git-test-*")
		if err != nil {
			t.Fatalf("Failed to create temp directory: %v", err)
		}
		defer os.RemoveAll(tempDir)

		// Save current directory
		currentDir, err := os.Getwd()
		if err != nil {
			t.Fatalf("Failed to get current directory: %v", err)
		}
		defer os.Chdir(currentDir)

		// Change to temp directory
		os.Chdir(tempDir)

		// Initialize git repository
		_, err = os.Create(".git")
		if err != nil {
			t.Fatalf("Failed to create .git file: %v", err)
		}

		// Test with local repository
		localRepo := &GitRepository{
			UseLocal: true,
		}
		err = PrepareRepository(localRepo)
		assert.Error(t, err, "Should error with invalid local repository")
		assert.Equal(t, "./", localRepo.LocalPath, "Local path should be set to current directory")
	})
}

func TestListCommits(t *testing.T) {
	// Initialize logger
	InitLogger(true)

	t.Run("Test commit filtering logic", func(t *testing.T) {
		// Create a test repository with predefined commits
		repo := &GitRepository{}

		// Manually populate the commits for testing
		repo.Commits = []CommitDetails{
			{
				Hash:      "abc123",
				Author:    "Test Author",
				Message:   "feat: first commit",
				Timestamp: time.Now().Add(-2 * time.Hour),
			},
			{
				Hash:      "def456",
				Author:    "Test Author",
				Message:   "fix: second commit",
				Timestamp: time.Now().Add(-1 * time.Hour),
			},
		}

		// Test with StartCommit specified
		repo.StartCommit = "def456"

		// Instead of calling ListCommits which would try to use the nil Handler,
		// we'll just test the filtering logic directly
		if repo.StartCommit != "" {
			for commitId, cmt := range repo.Commits {
				if cmt.Hash == repo.StartCommit {
					repo.Commits = repo.Commits[commitId:]
					break
				}
			}
		}

		// Verify the filtering worked correctly
		assert.Len(t, repo.Commits, 1, "Should filter commits starting from specified hash")
		assert.Equal(t, "def456", repo.Commits[0].Hash, "Commit hash should match")
	})

	t.Run("Test with nil Handler", func(t *testing.T) {
		// Create a test repository with nil Handler
		repo := &GitRepository{}

		// Now we can safely call ListCommits since we've added a nil check
		commits, err := ListCommits(repo)

		// Verify the function returns without error
		assert.NoError(t, err, "Should not error with nil Handler")
		assert.Empty(t, commits, "Should return empty commits with nil Handler")
	})
}

func TestListExistingTags(t *testing.T) {
	// Initialize logger
	InitLogger(true)

	t.Run("Test tag processing", func(t *testing.T) {
		// Create a test repository
		repo := &GitRepository{}

		// Since we can't test the actual git operations, we'll test the function's behavior
		// by manually setting up the repository state

		// Manually add tags to verify they're processed correctly
		repo.Tags = []TagDetails{
			{
				Name: "v1.0.0",
				Hash: "abc123",
			},
		}

		assert.Len(t, repo.Tags, 1, "Should have 1 tag")
		assert.Equal(t, "v1.0.0", repo.Tags[0].Name, "Tag name should match")
		assert.Equal(t, "abc123", repo.Tags[0].Hash, "Tag hash should match")
	})

	t.Run("Test with nil Handler", func(t *testing.T) {
		// Create a test repository with nil Handler
		repo := &GitRepository{}

		// Now we can safely call ListExistingTags since we've added a nil check
		ListExistingTags(repo, nil)

		// Verify no tags were added
		assert.Empty(t, repo.Tags, "Should have no tags after calling with nil Handler")
	})
}