package imageutil

import (
	"bytes"
	"image"
	"image/color"
	"image/png"
	"testing"
)

func TestIsImageFormat(t *testing.T) {
	tests := []struct {
		name        string
		contentType string
		want        bool
	}{
		{"JPEG", "image/jpeg", true},
		{"PNG", "image/png", true},
		{"GIF", "image/gif", true},
		{"WebP", "image/webp", true},
		{"Invalid", "image/invalid", false},
		{"Empty", "", false},
		{"Text", "text/plain", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IsImageFormat(tt.contentType); got != tt.want {
				t.Errorf("IsImageFormat(%q) = %v, want %v", tt.contentType, got, tt.want)
			}
		})
	}
}

func TestDefaultOptions(t *testing.T) {
	opts := DefaultOptions()

	if !opts.Lossless {
		t.Error("DefaultOptions().Lossless = false, want true")
	}
	if opts.Quality != 90 {
		t.Errorf("DefaultOptions().Quality = %v, want 90", opts.Quality)
	}
	if opts.Compression != 4 {
		t.Errorf("DefaultOptions().Compression = %v, want 4", opts.Compression)
	}
}

func TestProcessImage(t *testing.T) {
	// Create a test image
	img := image.NewRGBA(image.Rect(0, 0, 100, 100))
	for y := 0; y < 100; y++ {
		for x := 0; x < 100; x++ {
			img.Set(x, y, color.RGBA{R: 255, G: 0, B: 0, A: 255})
		}
	}

	var buf bytes.Buffer
	if err := png.Encode(&buf, img); err != nil {
		t.Fatalf("Failed to create test PNG: %v", err)
	}

	tests := []struct {
		name    string
		opts    ProcessOptions
		wantErr bool
	}{
		{
			name: "Default options",
			opts: DefaultOptions(),
		},
		{
			name: "Custom quality",
			opts: ProcessOptions{
				Lossless: false,
				Quality:  75,
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			reader := bytes.NewReader(buf.Bytes())
			result, err := ProcessImage(reader, tt.opts)
			if (err != nil) != tt.wantErr {
				t.Errorf("ProcessImage() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr && len(result) == 0 {
				t.Error("ProcessImage() returned empty result")
			}
		})
	}

	// Test with invalid input
	_, err := ProcessImage(bytes.NewReader([]byte("invalid image data")), DefaultOptions())
	if err == nil {
		t.Error("ProcessImage() with invalid input should return error")
	}
}