image_test.go

package headlessterm

import (
	"testing"
)

func TestImageManager_Store(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	id := m.Store(10, 10, data)

	if id != 1 {
		t.Errorf("expected id 1, got %d", id)
	}
	if m.ImageCount() != 1 {
		t.Errorf("expected 1 image, got %d", m.ImageCount())
	}
	if m.UsedMemory() != 100 {
		t.Errorf("expected 100 bytes, got %d", m.UsedMemory())
	}
}

func TestImageManager_Deduplication(t *testing.T) {
	m := NewImageManager()

	data := []byte("test image data")
	id1 := m.Store(10, 10, data)
	id2 := m.Store(10, 10, data) // Same data

	if id1 != id2 {
		t.Errorf("expected same id for duplicate, got %d and %d", id1, id2)
	}
	if m.ImageCount() != 1 {
		t.Errorf("expected 1 image (deduplicated), got %d", m.ImageCount())
	}
}

func TestImageManager_StoreWithID(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 50)
	m.StoreWithID(42, 5, 5, data)

	img := m.Image(42)
	if img == nil {
		t.Fatal("expected image with id 42")
	}
	if img.Width != 5 || img.Height != 5 {
		t.Errorf("expected 5x5, got %dx%d", img.Width, img.Height)
	}
}

func TestImageManager_Place(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	placement := &ImagePlacement{
		ImageID: imageID,
		Row:     0,
		Col:     0,
		Cols:    5,
		Rows:    5,
	}

	placementID := m.Place(placement)
	if placementID != 1 {
		t.Errorf("expected placement id 1, got %d", placementID)
	}
	if m.PlacementCount() != 1 {
		t.Errorf("expected 1 placement, got %d", m.PlacementCount())
	}
}

func TestImageManager_DeleteImage(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	id := m.Store(10, 10, data)

	m.DeleteImage(id)

	if m.ImageCount() != 0 {
		t.Errorf("expected 0 images after delete, got %d", m.ImageCount())
	}
	if m.UsedMemory() != 0 {
		t.Errorf("expected 0 bytes after delete, got %d", m.UsedMemory())
	}
}

func TestImageManager_Clear(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)
	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 1, Rows: 1})

	m.Clear()

	if m.ImageCount() != 0 {
		t.Errorf("expected 0 images after clear, got %d", m.ImageCount())
	}
	if m.PlacementCount() != 0 {
		t.Errorf("expected 0 placements after clear, got %d", m.PlacementCount())
	}
}

func TestImageManager_Prune(t *testing.T) {
	m := NewImageManager()
	m.SetMaxMemory(150) // Low limit

	// Store 3 images of 100 bytes each - should trigger pruning
	data := make([]byte, 100)
	m.Store(10, 10, data)

	data2 := make([]byte, 100)
	data2[0] = 1 // Different data
	m.Store(10, 10, data2)

	// At this point, we're at 200 bytes with 150 limit
	// Pruning should have removed unreferenced images
	if m.UsedMemory() > 150 {
		// This might not prune if images are still referenced
		// Just verify it doesn't crash
	}
}

func TestImageManager_Placements(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 1, Rows: 1})
	m.Place(&ImagePlacement{ImageID: imageID, Row: 1, Col: 1, Cols: 2, Rows: 2})

	placements := m.Placements()
	if len(placements) != 2 {
		t.Errorf("expected 2 placements, got %d", len(placements))
	}
}

func TestImageManager_DeletePlacementsByPosition(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 2, Rows: 2})
	m.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 5, Cols: 2, Rows: 2})

	m.DeletePlacementsByPosition(0, 0) // Should delete first placement

	if m.PlacementCount() != 1 {
		t.Errorf("expected 1 placement after delete, got %d", m.PlacementCount())
	}
}

func TestImageManager_DeletePlacementsInRow(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 2, Rows: 2})
	m.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 5, Cols: 2, Rows: 2})

	m.DeletePlacementsInRow(1) // Row 1 intersects first placement (rows 0-1)

	if m.PlacementCount() != 1 {
		t.Errorf("expected 1 placement after delete, got %d", m.PlacementCount())
	}
}

func TestCellImage(t *testing.T) {
	cell := NewCell()

	if cell.HasImage() {
		t.Error("new cell should not have image")
	}

	cell.Image = &CellImage{
		PlacementID: 1,
		ImageID:     1,
		U0:          0.0,
		V0:          0.0,
		U1:          1.0,
		V1:          1.0,
		ZIndex:      -1,
	}

	if !cell.HasImage() {
		t.Error("cell should have image after setting")
	}

	cell.Reset()

	if cell.HasImage() {
		t.Error("cell should not have image after reset")
	}
}

func TestImageManager_DeletePlacementsInRowRange(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	// Placement at rows 0-2
	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 5-7
	m.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 10-12
	m.Place(&ImagePlacement{ImageID: imageID, Row: 10, Col: 0, Cols: 2, Rows: 3})

	// Delete placements in row range 4-8 (should only affect the second placement)
	m.DeletePlacementsInRowRange(4, 8)

	if m.PlacementCount() != 2 {
		t.Errorf("expected 2 placements after delete, got %d", m.PlacementCount())
	}
}

func TestImageManager_DeletePlacementsBelow(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	// Placement at rows 0-2
	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 5-7
	m.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 10-12
	m.Place(&ImagePlacement{ImageID: imageID, Row: 10, Col: 0, Cols: 2, Rows: 3})

	// Delete placements below row 4 (should delete second and third)
	m.DeletePlacementsBelow(4)

	if m.PlacementCount() != 1 {
		t.Errorf("expected 1 placement after delete, got %d", m.PlacementCount())
	}
}

func TestImageManager_DeletePlacementsAbove(t *testing.T) {
	m := NewImageManager()

	data := make([]byte, 100)
	imageID := m.Store(10, 10, data)

	// Placement at rows 0-2
	m.Place(&ImagePlacement{ImageID: imageID, Row: 0, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 5-7
	m.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 0, Cols: 2, Rows: 3})
	// Placement at rows 10-12
	m.Place(&ImagePlacement{ImageID: imageID, Row: 10, Col: 0, Cols: 2, Rows: 3})

	// Delete placements above row 7 (should delete first and second)
	m.DeletePlacementsAbove(7)

	if m.PlacementCount() != 1 {
		t.Errorf("expected 1 placement after delete, got %d", m.PlacementCount())
	}
}

// TestClearScreenClearsImages verifies that CSI 2J clears all image placements
func TestClearScreenClearsImages(t *testing.T) {
	term := New(WithSize(24, 80))

	// Add an image
	data := make([]byte, 100)
	imageID := term.images.Store(10, 10, data)
	term.images.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 5, Cols: 2, Rows: 2})

	if term.ImagePlacementCount() != 1 {
		t.Fatalf("expected 1 placement, got %d", term.ImagePlacementCount())
	}

	// Clear screen with CSI 2J
	term.WriteString("\x1b[2J")

	// All placements should be cleared
	if term.ImagePlacementCount() != 0 {
		t.Errorf("expected 0 placements after CSI 2J, got %d", term.ImagePlacementCount())
	}

	// Image data should still exist
	if term.ImageCount() != 1 {
		t.Errorf("expected 1 image (data preserved), got %d", term.ImageCount())
	}
}

// TestClearScreenBelowClearsImages verifies that CSI 0J clears images below cursor
func TestClearScreenBelowClearsImages(t *testing.T) {
	term := New(WithSize(24, 80))

	// Add images above and below cursor position
	data := make([]byte, 100)
	imageID := term.images.Store(10, 10, data)
	term.images.Place(&ImagePlacement{ImageID: imageID, Row: 2, Col: 0, Cols: 2, Rows: 2})  // Above
	term.images.Place(&ImagePlacement{ImageID: imageID, Row: 10, Col: 0, Cols: 2, Rows: 2}) // Below

	// Position cursor at row 5
	term.WriteString("\x1b[6;1H")

	// Clear screen below (CSI 0J)
	term.WriteString("\x1b[0J")

	// Only placement below should be cleared
	if term.ImagePlacementCount() != 1 {
		t.Errorf("expected 1 placement after CSI 0J, got %d", term.ImagePlacementCount())
	}
}

// TestResetStateClearsImagesAndCache verifies that terminal reset clears all images
func TestResetStateClearsImagesAndCache(t *testing.T) {
	term := New(WithSize(24, 80))

	// Add an image
	data := make([]byte, 100)
	imageID := term.images.Store(10, 10, data)
	term.images.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 5, Cols: 2, Rows: 2})

	if term.ImageCount() != 1 || term.ImagePlacementCount() != 1 {
		t.Fatalf("expected 1 image and 1 placement, got %d and %d", term.ImageCount(), term.ImagePlacementCount())
	}

	// Reset terminal (RIS - ESC c)
	term.WriteString("\x1bc")

	// Both images and placements should be cleared
	if term.ImageCount() != 0 {
		t.Errorf("expected 0 images after reset, got %d", term.ImageCount())
	}
	if term.ImagePlacementCount() != 0 {
		t.Errorf("expected 0 placements after reset, got %d", term.ImagePlacementCount())
	}
}

// TestAlternateScreenClearsImages verifies that switching screens clears placements
func TestAlternateScreenClearsImages(t *testing.T) {
	term := New(WithSize(24, 80))

	// Add an image
	data := make([]byte, 100)
	imageID := term.images.Store(10, 10, data)
	term.images.Place(&ImagePlacement{ImageID: imageID, Row: 5, Col: 5, Cols: 2, Rows: 2})

	if term.ImagePlacementCount() != 1 {
		t.Fatalf("expected 1 placement, got %d", term.ImagePlacementCount())
	}

	// Switch to alternate screen (CSI ? 1049 h)
	term.WriteString("\x1b[?1049h")

	// Placements should be cleared
	if term.ImagePlacementCount() != 0 {
		t.Errorf("expected 0 placements after switching to alternate screen, got %d", term.ImagePlacementCount())
	}

	// Image data should still exist
	if term.ImageCount() != 1 {
		t.Errorf("expected 1 image (data preserved), got %d", term.ImageCount())
	}

	// Add another image on alternate screen
	imageID2 := term.images.Store(20, 20, data)
	term.images.Place(&ImagePlacement{ImageID: imageID2, Row: 0, Col: 0, Cols: 3, Rows: 3})

	// Switch back to primary screen (CSI ? 1049 l)
	term.WriteString("\x1b[?1049l")

	// Placements should be cleared again
	if term.ImagePlacementCount() != 0 {
		t.Errorf("expected 0 placements after switching back to primary screen, got %d", term.ImagePlacementCount())
	}
}