package modules

import (
	"os"
	"testing"

	"github.com/go-git/go-git/v5"
)

func createTestRepo(t *testing.T) (*git.Repository, string) {
	t.Helper()

	// Create a temporary directory for the test repo
	tmpDir, err := os.MkdirTemp("", "test-repo-*")
	if err != nil {
		t.Fatal(err)
	}

	// Initialize repository
	repo, err := git.PlainInit(tmpDir, true) // bare repository
	if err != nil {
		t.Fatal(err)
	}

	return repo, tmpDir
}

func TestGetVersions(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		versions, err := handler.getVersions("/nonexistent/path")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if versions != nil {
			t.Error("expected nil versions for nonexistent repository")
		}
	})

	t.Run("empty_repository", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		versions, err := handler.getVersions(tmpDir)
		if err != nil {
			t.Errorf("expected no error for empty repository, got: %v", err)
		}
		if len(versions) != 0 {
			t.Errorf("expected 0 versions for empty repository, got %d", len(versions))
		}

		_ = repo // Use repo to avoid unused variable
	})
}

func TestGetLatestVersion(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		version, err := handler.getLatestVersion("/nonexistent/path")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if version != "" {
			t.Error("expected empty version for nonexistent repository")
		}
	})

	t.Run("empty_repository", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		// This should fail because there are no commits in the repository
		version, err := handler.getLatestVersion(tmpDir)
		if err == nil {
			t.Error("expected error for empty repository")
		}
		if version != "" {
			t.Error("expected empty version for empty repository")
		}

		_ = repo
	})
}

func TestGeneratePseudoVersion(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		version, err := handler.generatePseudoVersion("/nonexistent/path")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if version != "" {
			t.Error("expected empty version for nonexistent repository")
		}
	})
}

func TestGetVersionTimestamp(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		timestamp, err := handler.getVersionTimestamp("/nonexistent/path", "v1.0.0")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if timestamp != "" {
			t.Error("expected empty timestamp for nonexistent repository")
		}
	})

	t.Run("version_not_found", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		timestamp, err := handler.getVersionTimestamp(tmpDir, "v9.9.9")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}
		if timestamp != "" {
			t.Error("expected empty timestamp for nonexistent version")
		}

		_ = repo
	})

	t.Run("empty_version_string", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		_, err := handler.getVersionTimestamp(tmpDir, "")
		if err == nil {
			t.Error("expected error for empty version string")
		}

		_ = repo
	})

	t.Run("version_with_v_prefix", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		// Test that version starting with 'v' is handled (should try both with and without)
		_, err := handler.getVersionTimestamp(tmpDir, "v1.0.0")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}

		_ = repo
	})
}

func TestGetModFile(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		content, err := handler.getModFile("/nonexistent/path", "v1.0.0")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if content != nil {
			t.Error("expected nil content for nonexistent repository")
		}
	})

	t.Run("version_not_found", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		content, err := handler.getModFile(tmpDir, "v9.9.9")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}
		if content != nil {
			t.Error("expected nil content for nonexistent version")
		}

		_ = repo
	})
}

func TestGetModuleZip(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("repository_not_found", func(t *testing.T) {
		zipData, err := handler.getModuleZip("/nonexistent/path", "v1.0.0")
		if err == nil {
			t.Error("expected error for nonexistent repository")
		}
		if zipData != nil {
			t.Error("expected nil zip data for nonexistent repository")
		}
	})

	t.Run("version_not_found", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		zipData, err := handler.getModuleZip(tmpDir, "v9.9.9")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}
		if zipData != nil {
			t.Error("expected nil zip data for nonexistent version")
		}

		_ = repo
	})
}

func TestResolveVersion(t *testing.T) {
	handler := &ModuleHandler{}

	t.Run("nonexistent_tag", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		hash, err := handler.resolveVersion(repo, "v1.0.0")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}
		if !hash.IsZero() {
			t.Error("expected zero hash for nonexistent version")
		}
	})

	t.Run("short_version_string", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		// Test with a version string that's too short to be a hash
		hash, err := handler.resolveVersion(repo, "abc")
		if err == nil {
			t.Error("expected error for short version string")
		}
		if !hash.IsZero() {
			t.Error("expected zero hash for short version string")
		}
	})

	t.Run("version_with_v_prefix", func(t *testing.T) {
		repo, tmpDir := createTestRepo(t)
		defer os.RemoveAll(tmpDir)

		// Test version with 'v' prefix
		hash, err := handler.resolveVersion(repo, "v1.2.3")
		if err == nil {
			t.Error("expected error for nonexistent version")
		}
		if !hash.IsZero() {
			t.Error("expected zero hash for nonexistent version")
		}
	})
}

func TestIsInNestedModule(t *testing.T) {
	handler := &ModuleHandler{}

	// We'll test this with a nil tree since setting up a real tree is complex
	// This tests the edge cases and basic logic

	t.Run("root_directory", func(t *testing.T) {
		isNested := handler.isInNestedModule(nil, "")
		if isNested {
			t.Error("root directory should not be considered nested module")
		}
	})

	t.Run("current_directory", func(t *testing.T) {
		isNested := handler.isInNestedModule(nil, ".")
		if isNested {
			t.Error("current directory should not be considered nested module")
		}
	})
}