package utils

import (
	"net/http"
	"net/http/httptest"
	"os"
	"testing"

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

func TestNormalizeVersion(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		{"v1.0.0", "1.0.0"},
		{"1.0.0", "1.0.0"},
		{"  v2.1.3  ", "2.1.3"},
		{"V1.0.0", "1.0.0"},
		{"v", ""},
		{"", ""},
	}

	for _, tt := range tests {
		t.Run(tt.input, func(t *testing.T) {
			result := normalizeVersion(tt.input)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestFindBinaryAsset(t *testing.T) {
	assets := []ReleaseAsset{
		{Name: "semver-gen-1.0.0-linux-amd64.tar.gz", BrowserDownloadURL: "https://example.com/linux-amd64.tar.gz"},
		{Name: "semver-gen-1.0.0-darwin-arm64.tar.gz", BrowserDownloadURL: "https://example.com/darwin-arm64.tar.gz"},
		{Name: "semver-gen-1.0.0-darwin-amd64.tar.gz", BrowserDownloadURL: "https://example.com/darwin-amd64.tar.gz"},
		{Name: "semver-gen-1.0.0-windows-amd64.zip", BrowserDownloadURL: "https://example.com/windows-amd64.zip"},
		{Name: "semver-gen-1.0.0-checksums.txt", BrowserDownloadURL: "https://example.com/checksums.txt"},
	}

	// Test finding the correct asset for the current platform
	url := findBinaryAsset(assets)
	assert.NotEmpty(t, url, "Should find a binary for the current platform")
	assert.NotContains(t, url, "checksum", "Should not return checksum file")
}

func TestFindBinaryAssetEmpty(t *testing.T) {
	assets := []ReleaseAsset{}
	url := findBinaryAsset(assets)
	assert.Empty(t, url, "Should return empty string when no assets")
}

func TestCheckLatestRelease(t *testing.T) {
	// Initialize logger
	InitLogger(false)

	// Create a mock server
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{
			"tag_name": "v1.2.3",
			"html_url": "https://github.com/lukaszraczylo/semver-generator/releases/tag/v1.2.3",
			"name": "Release 1.2.3",
			"assets": []
		}`))
	}))
	defer server.Close()

	// Note: In a real test, we'd need to mock the HTTP client or the URL
	// For now, we just test the network error case
	release, ok := CheckLatestRelease()
	// This will either succeed (if network is available) or fail gracefully
	if ok {
		assert.NotEmpty(t, release)
	}
}

func TestFetchLatestReleaseError(t *testing.T) {
	InitLogger(false)

	// Save original client
	originalClient := httpClient
	defer func() { httpClient = originalClient }()

	// Create a mock server that returns an error
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer server.Close()

	// We can't easily test this without modifying the URL constant
	// but we can test the error handling by checking that it fails gracefully
	release, ok := CheckLatestRelease()
	// The result depends on whether the real GitHub API is accessible
	_ = release
	_ = ok
}

func TestCopyFile(t *testing.T) {
	// Create a temp source file
	srcContent := []byte("test content")
	srcFile, err := os.CreateTemp("", "test-*")
	assert.NoError(t, err)
	defer os.Remove(srcFile.Name())

	_, err = srcFile.Write(srcContent)
	assert.NoError(t, err)
	srcFile.Close()

	// Create destination path
	dstPath := srcFile.Name() + ".copy"
	defer os.Remove(dstPath)

	// Copy the file
	err = copyFile(srcFile.Name(), dstPath)
	assert.NoError(t, err)

	// Verify the content
	content, err := os.ReadFile(dstPath)
	assert.NoError(t, err)
	assert.Equal(t, srcContent, content)
}

func TestReplaceBinary(t *testing.T) {
	// Create a temp "new" binary
	newContent := []byte("new binary content")
	newFile, err := os.CreateTemp("", "new-binary-*")
	assert.NoError(t, err)
	defer os.Remove(newFile.Name())

	_, err = newFile.Write(newContent)
	assert.NoError(t, err)
	newFile.Close()

	// Create a temp "current" binary
	currentFile, err := os.CreateTemp("", "current-binary-*")
	assert.NoError(t, err)
	currentPath := currentFile.Name()
	defer os.Remove(currentPath)
	currentFile.Close()

	// Replace the binary
	err = replaceBinary(newFile.Name(), currentPath)
	assert.NoError(t, err)

	// Verify the content was replaced
	content, err := os.ReadFile(currentPath)
	assert.NoError(t, err)
	assert.Equal(t, newContent, content)
}

func TestUpdatePackageNoBinary(t *testing.T) {
	InitLogger(false)

	// This test verifies UpdatePackage handles the case where no binary is found
	// by testing with a mock that returns empty assets
	// Note: This would need proper mocking of httpClient to test fully
}