package util

import (
	"fmt"
	"strings"
	"testing"
)

// Real IPFS CIDs for testing
var validCIDs = []string{
	"bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi",
	"bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm",
	"bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha",
}

func TestConvertCIDBase32ToBase62(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		wantErr bool
	}{
		{
			name:    "valid IPFS CID 1",
			input:   "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi",
			wantErr: false,
		},
		{
			name:    "valid IPFS CID 2",
			input:   "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm",
			wantErr: false,
		},
		{
			name:    "valid IPFS CID 3",
			input:   "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha",
			wantErr: false,
		},
		{
			name:    "empty string",
			input:   "",
			wantErr: true,
		},
		{
			name:    "invalid characters",
			input:   "invalid123!@#",
			wantErr: true,
		},
		{
			name:    "only prefix",
			input:   "bafkrei",
			wantErr: true,
		},
	}

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

			if tt.wantErr {
				if err == nil {
					t.Errorf("ConvertCIDBase32ToBase62() expected error but got %v", result)
				}
				return
			}

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

			if result == "" {
				t.Errorf("ConvertCIDBase32ToBase62() returned empty result")
			}

			t.Logf("Converted %s to %s", tt.input, result)
		})
	}
}

func TestRoundTripConversionWithRealCIDs(t *testing.T) {
	for i, originalCID := range validCIDs {
		t.Run(fmt.Sprintf("real_cid_%d", i+1), func(t *testing.T) {
			// Convert to base62
			base62Result, err := ConvertCIDBase32ToBase62(originalCID)
			if err != nil {
				t.Fatalf("Failed to convert to base62: %v", err)
			}

			t.Logf("Original CID: %s", originalCID)
			t.Logf("Base62:       %s", base62Result)
			t.Logf("Length reduction: %d -> %d chars (%.1f%% reduction)",
				len(originalCID), len(base62Result),
				float64(len(originalCID)-len(base62Result))/float64(len(originalCID))*100)

			// Convert back to base32
			base32Result, err := ConvertCIDBase62ToBase32(base62Result)
			if err != nil {
				t.Fatalf("Failed to convert back to base32: %v", err)
			}

			t.Logf("Restored:     %s", base32Result)

			// Compare (case insensitive since base32 can be uppercase/lowercase)
			if !strings.EqualFold(originalCID, base32Result) {
				t.Errorf("Round trip failed:\nOriginal: %s\nBase62:   %s\nRestored: %s",
					originalCID, base62Result, base32Result)
			}
		})
	}
}

func TestIsBase32WithRealCIDs(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected bool
	}{
		{
			name:     "real CID 1",
			input:    "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi",
			expected: true,
		},
		{
			name:     "real CID 2",
			input:    "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm",
			expected: true,
		},
		{
			name:     "real CID 3",
			input:    "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha",
			expected: true,
		},
		{
			name:     "real CID uppercase",
			input:    strings.ToUpper("bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi"),
			expected: true,
		},
		{
			name:     "empty string",
			input:    "",
			expected: false,
		},
		{
			name:     "invalid characters",
			input:    "bafkrei123invalid!@#",
			expected: false,
		},
		{
			name:     "contains 0 and 1 (invalid in base32)",
			input:    "bafkrei01234567890",
			expected: false,
		},
		{
			name:     "contains 8 and 9 (invalid in base32)",
			input:    "bafkrei89abcdef",
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := IsBase32(tt.input)
			if result != tt.expected {
				t.Errorf("IsBase32(%q) = %v, expected %v", tt.input, result, tt.expected)
			}
		})
	}
}

func TestCompressionRatio(t *testing.T) {
	t.Log("Testing compression ratios with real CIDs:")

	var totalOriginalLength, totalBase62Length int

	for i, cid := range validCIDs {
		base62, err := ConvertCIDBase32ToBase62(cid)
		if err != nil {
			t.Fatalf("Failed to convert CID %d: %v", i+1, err)
		}

		originalLen := len(cid)
		base62Len := len(base62)
		reduction := float64(originalLen-base62Len) / float64(originalLen) * 100

		totalOriginalLength += originalLen
		totalBase62Length += base62Len

		t.Logf("CID %d: %d -> %d chars (%.1f%% reduction)",
			i+1, originalLen, base62Len, reduction)
	}

	overallReduction := float64(totalOriginalLength-totalBase62Length) / float64(totalOriginalLength) * 100
	t.Logf("Overall: %d -> %d chars (%.1f%% reduction)",
		totalOriginalLength, totalBase62Length, overallReduction)
}

func TestSpecificCIDConversions(t *testing.T) {
	// Test each CID individually with detailed logging
	testCases := []struct {
		name string
		cid  string
	}{
		{"CID with 'igns2g4c'", "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi"},
		{"CID with 'igms7evf'", "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm"},
		{"CID with 'ieedz3pv'", "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha"},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Test IsBase32
			if !IsBase32(tc.cid) {
				t.Errorf("IsBase32 failed for %s", tc.cid)
			}

			// Test conversion to base62
			base62, err := ConvertCIDBase32ToBase62(tc.cid)
			if err != nil {
				t.Fatalf("ConvertCIDBase32ToBase62 failed: %v", err)
			}

			// Test conversion back to base32
			restored, err := ConvertCIDBase62ToBase32(base62)
			if err != nil {
				t.Fatalf("ConvertCIDBase62ToBase32 failed: %v", err)
			}

			// Verify round trip
			if !strings.EqualFold(tc.cid, restored) {
				t.Errorf("Round trip failed for %s", tc.cid)
				t.Errorf("  Original: %s", tc.cid)
				t.Errorf("  Base62:   %s", base62)
				t.Errorf("  Restored: %s", restored)
			} else {
				t.Logf("✓ Round trip successful")
				t.Logf("  Original: %s", tc.cid)
				t.Logf("  Base62:   %s", base62)
				t.Logf("  Restored: %s", restored)
			}
		})
	}
}

// Benchmark with real CIDs
func BenchmarkConvertRealCIDBase32ToBase62(b *testing.B) {
	cid := validCIDs[0] // Use first real CID

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := ConvertCIDBase32ToBase62(cid)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkConvertRealCIDBase62ToBase32(b *testing.B) {
	// Convert real CID to base62 first
	base62CID, err := ConvertCIDBase32ToBase62(validCIDs[0])
	if err != nil {
		b.Fatal(err)
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := ConvertCIDBase62ToBase32(base62CID)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkIsBase32RealCID(b *testing.B) {
	cid := validCIDs[0]

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		IsBase32(cid)
	}
}