package imagecache

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

func TestCache_StoreAndLoad(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	// 存储图片
	data := []byte("fake image data")
	filename, err := cache.Store(data, ".jpg")
	if err != nil {
		t.Fatalf("Store() error = %v", err)
	}

	// 验证文件存在
	path := filepath.Join(dir, filename)
	if _, err := os.Stat(path); os.IsNotExist(err) {
		t.Errorf("Store() file not created: %s", path)
	}

	// 加载图片
	loaded, err := cache.Load(filename)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}

	if string(loaded) != string(data) {
		t.Errorf("Load() = %s, want %s", loaded, data)
	}
}

func TestCache_LoadBase64(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	data := []byte("test data")
	filename, err := cache.Store(data, ".png")
	if err != nil {
		t.Fatalf("Store() error = %v", err)
	}

	b64, err := cache.LoadBase64(filename)
	if err != nil {
		t.Fatalf("LoadBase64() error = %v", err)
	}

	if b64 == "" {
		t.Error("LoadBase64() returned empty string")
	}
}

func TestCache_Exists(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	filename, _ := cache.Store([]byte("data"), ".jpg")

	if !cache.Exists(filename) {
		t.Error("Exists() = false, want true")
	}

	if cache.Exists("nonexistent.jpg") {
		t.Error("Exists() = true for nonexistent file")
	}
}

func TestCache_Delete(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	filename, _ := cache.Store([]byte("data"), ".jpg")

	if err := cache.Delete(filename); err != nil {
		t.Fatalf("Delete() error = %v", err)
	}

	if cache.Exists(filename) {
		t.Error("Delete() file still exists")
	}
}

func TestCache_List(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	cache.Store([]byte("data1"), ".jpg")
	cache.Store([]byte("data2"), ".png")

	files, err := cache.List()
	if err != nil {
		t.Fatalf("List() error = %v", err)
	}

	if len(files) != 2 {
		t.Errorf("List() returned %d files, want 2", len(files))
	}
}

func TestCache_Stats(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	cache.Store([]byte("data1"), ".jpg")
	cache.Store([]byte("data2"), ".png")

	count, totalSize, err := cache.Stats()
	if err != nil {
		t.Fatalf("Stats() error = %v", err)
	}

	if count != 2 {
		t.Errorf("Stats() count = %d, want 2", count)
	}

	if totalSize <= 0 {
		t.Errorf("Stats() totalSize = %d, want > 0", totalSize)
	}
}

func TestCache_SafePath(t *testing.T) {
	dir := t.TempDir()
	cache, err := New(dir, 0, 0)
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	// 测试路径遍历防护
	tests := []struct {
		input    string
		expected string
	}{
		{"test.jpg", filepath.Join(dir, "test.jpg")},
		{"../etc/passwd", filepath.Join(dir, "passwd")},
		{"/etc/passwd", filepath.Join(dir, "passwd")},
		{"subdir/test.jpg", filepath.Join(dir, "test.jpg")},
	}

	for _, tt := range tests {
		got := cache.safePath(tt.input)
		if got != tt.expected {
			t.Errorf("safePath(%q) = %q, want %q", tt.input, got, tt.expected)
		}
	}
}

func TestDetectMIME(t *testing.T) {
	tests := []struct {
		filename string
		expected string
	}{
		{"test.jpg", "image/jpeg"},
		{"test.jpeg", "image/jpeg"},
		{"test.png", "image/png"},
		{"test.gif", "image/gif"},
		{"test.webp", "image/webp"},
		{"test.unknown", "image/jpeg"},
	}

	for _, tt := range tests {
		got := detectMIME(tt.filename)
		if got != tt.expected {
			t.Errorf("detectMIME(%q) = %q, want %q", tt.filename, got, tt.expected)
		}
	}
}