"math/rand"

	// 448x448 grayscale image produces >4096 bytes of base64
	img := image.NewGray(image.Rect(0, 0, 448, 448))
	for y := range 448 {
		for x := range 448 {
			img.SetGray(x, y, color.Gray{Y: uint8((x + y) % 256)})

	// 128x128 random noise image is incompressible — produces >4096 bytes of base64 even with proper LZ77
	rng := rand.New(rand.NewSource(42))
	img := image.NewGray(image.Rect(0, 0, 128, 128))
	for y := range 128 {
		for x := range 128 {
			img.SetGray(x, y, color.Gray{Y: uint8(rng.Intn(256))})

	"bytes"
	"encoding/base64"
	"fmt"

	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/ansi/kitty"

	// ESC _ G a=d ; ESC \  = delete all images
	fmt.Fprintf(w, "\x1b_Ga=d\x1b\\")
	return nil

	_, err := io.WriteString(w, ansi.KittyGraphics(nil, "a=d"))
	return err

// Chunks are 4096 bytes per the Kitty protocol recommendation.

	// Encode to PNG
	var pngBuf bytes.Buffer
	if err := encodePNG(img, &pngBuf); err != nil {
		return fmt.Errorf("failed to encode PNG: %w", err)
	}
	// Base64 encode
	base64Data := base64.StdEncoding.EncodeToString(pngBuf.Bytes())
	// Small payload: send in a single escape sequence (no m= key needed)
	const chunkSize = 4096
	if len(base64Data) <= chunkSize {
		fmt.Fprintf(w, "\x1b_Gf=100,a=T;%s\x1b\\", base64Data)
		return nil
	}
	// Chunked transmission for large payloads
	for offset := 0; offset < len(base64Data); offset += chunkSize {
		end := min(offset+chunkSize, len(base64Data))
		chunk := base64Data[offset:end]
		if offset == 0 {
			// First chunk: include format and action, m=1 means more chunks follow
			fmt.Fprintf(w, "\x1b_Gf=100,a=T,m=1;%s\x1b\\", chunk)
		} else if end < len(base64Data) {
			// Middle chunk: m=1 means more chunks follow
			fmt.Fprintf(w, "\x1b_Gm=1;%s\x1b\\", chunk)
		} else {
			// Last chunk: m=0 means no more chunks
			fmt.Fprintf(w, "\x1b_Gm=0;%s\x1b\\", chunk)
		}
	}
	return nil

	return kitty.EncodeGraphics(w, img, &kitty.Options{
		Format:       kitty.PNG,
		Action:       kitty.TransmitAndPut,
		Transmission: kitty.Direct,
		Chunk:        true,
	})

		}
	}
	return result
}
// encodePNG encodes an image to PNG format.
// Detects whether image is grayscale or RGB and uses appropriate encoder.
func encodePNG(img image.Image, w io.Writer) error {
	if _, ok := img.(*image.Gray); ok {
		return encodeGrayscalePNG(img, w)
	}
	return encodeRGBPNG(img, w)
}
// encodeGrayscalePNG encodes a grayscale image to PNG format.
// This is a minimal implementation that works for 8-bit grayscale images.
func encodeGrayscalePNG(img image.Image, w io.Writer) error {
	bounds := img.Bounds()
	width := bounds.Dx()
	height := bounds.Dy()
	// PNG signature
	signature := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
	if _, err := w.Write(signature); err != nil {
		return err
	}
	// IHDR chunk
	ihdr := make([]byte, 13)
	ihdr[0] = byte(width >> 24)
	ihdr[1] = byte(width >> 16)
	ihdr[2] = byte(width >> 8)
	ihdr[3] = byte(width)
	ihdr[4] = byte(height >> 24)
	ihdr[5] = byte(height >> 16)
	ihdr[6] = byte(height >> 8)
	ihdr[7] = byte(height)
	ihdr[8] = 8  // bit depth
	ihdr[9] = 0  // color type: grayscale
	ihdr[10] = 0 // compression: deflate
	ihdr[11] = 0 // filter: adaptive
	ihdr[12] = 0 // interlace: none
	if err := writePNGChunk(w, "IHDR", ihdr); err != nil {
		return err
	}
	// IDAT chunk (image data)
	rawData := make([]byte, 0, height*(width+1))
	for y := range height {
		rawData = append(rawData, 0) // filter byte (none)
		for x := range width {
			c := color.GrayModel.Convert(img.At(x+bounds.Min.X, y+bounds.Min.Y)).(color.Gray)
			rawData = append(rawData, c.Y)
		}
	}
	compressed := deflateCompress(rawData)
	if err := writePNGChunk(w, "IDAT", compressed); err != nil {
		return err
	}
	// IEND chunk
	if err := writePNGChunk(w, "IEND", nil); err != nil {
		return err
	}
	return nil
}
// encodeRGBPNG encodes an RGB image to PNG format.
// This is a minimal implementation that works for 8-bit RGB images.
func encodeRGBPNG(img image.Image, w io.Writer) error {
	bounds := img.Bounds()
	width := bounds.Dx()
	height := bounds.Dy()
	// PNG signature
	signature := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
	if _, err := w.Write(signature); err != nil {
		return err
	}
	// IHDR chunk
	ihdr := make([]byte, 13)
	ihdr[0] = byte(width >> 24)
	ihdr[1] = byte(width >> 16)
	ihdr[2] = byte(width >> 8)
	ihdr[3] = byte(width)
	ihdr[4] = byte(height >> 24)
	ihdr[5] = byte(height >> 16)
	ihdr[6] = byte(height >> 8)
	ihdr[7] = byte(height)
	ihdr[8] = 8  // bit depth
	ihdr[9] = 2  // color type: RGB
	ihdr[10] = 0 // compression: deflate
	ihdr[11] = 0 // filter: adaptive
	ihdr[12] = 0 // interlace: none
	if err := writePNGChunk(w, "IHDR", ihdr); err != nil {
		return err
	}
	// IDAT chunk (image data)
	// RGB: 3 bytes per pixel + 1 filter byte per row
	rawData := make([]byte, 0, height*(width*3+1))
	for y := range height {
		rawData = append(rawData, 0) // filter byte (none)
		for x := range width {
			r, g, b, _ := img.At(x+bounds.Min.X, y+bounds.Min.Y).RGBA()
			rawData = append(rawData, byte(r>>8), byte(g>>8), byte(b>>8))
		}
	}
	compressed := deflateCompress(rawData)
	if err := writePNGChunk(w, "IDAT", compressed); err != nil {
		return err
	}
	// IEND chunk
	if err := writePNGChunk(w, "IEND", nil); err != nil {
		return err
	}
	return nil
}
// writePNGChunk writes a PNG chunk with CRC
func writePNGChunk(w io.Writer, chunkType string, data []byte) error {
	// Length (4 bytes, big-endian)
	length := uint32(len(data))
	if _, err := w.Write([]byte{
		byte(length >> 24),
		byte(length >> 16),
		byte(length >> 8),
		byte(length),
	}); err != nil {
		return err
	}
	// Chunk type (4 bytes)
	if _, err := w.Write([]byte(chunkType)); err != nil {
		return err
	}
	// Chunk data
	if len(data) > 0 {
		if _, err := w.Write(data); err != nil {
			return err

	// CRC32 of chunk type + data
	crc := crc32PNG([]byte(chunkType), data)
	if _, err := w.Write([]byte{
		byte(crc >> 24),
		byte(crc >> 16),
		byte(crc >> 8),
		byte(crc),
	}); err != nil {
		return err
	}
	return nil
}
// crc32PNG computes CRC32 for PNG
func crc32PNG(chunkType, data []byte) uint32 {
	crc := uint32(0xFFFFFFFF)
	// Process chunk type
	for _, b := range chunkType {
		crc = updateCRC32(crc, b)
	}
	// Process data
	for _, b := range data {
		crc = updateCRC32(crc, b)
	}
	return crc ^ 0xFFFFFFFF
}
// updateCRC32 updates CRC with one byte
func updateCRC32(crc uint32, b byte) uint32 {
	// CRC32 polynomial table (standard)
	const poly = 0xEDB88320
	crc ^= uint32(b)
	for range 8 {
		if crc&1 != 0 {
			crc = (crc >> 1) ^ poly
		} else {
			crc >>= 1
		}
	}
	return crc
}
// deflateCompress performs simple deflate compression
// For simplicity, we use uncompressed deflate blocks (not optimal but works)
func deflateCompress(data []byte) []byte {
	result := make([]byte, 0)
	// Write zlib header
	result = append(result, 0x78, 0x01) // deflate, level 1
	// Split into uncompressed blocks (max 65535 bytes each)
	offset := 0
	for offset < len(data) {
		blockSize := min(len(data)-offset, 65535)
		// Block header: final=1 if last block, type=00 (uncompressed)
		isFinal := byte(0)
		if offset+blockSize >= len(data) {
			isFinal = 1
		}
		// Store uncompressed block
		result = append(result, isFinal) // BFINAL + BTYPE=00
		len := uint16(blockSize)
		nlen := ^len
		result = append(result, byte(len), byte(len>>8))
		result = append(result, byte(nlen), byte(nlen>>8))
		result = append(result, data[offset:offset+blockSize]...)
		offset += blockSize
	}
	// Add Adler-32 checksum
	adler := adler32(data)
	result = append(result, byte(adler>>24), byte(adler>>16), byte(adler>>8), byte(adler))

}
// adler32 computes Adler-32 checksum
func adler32(data []byte) uint32 {
	const mod = 65521
	a, b := uint32(1), uint32(0)
	for _, c := range data {
		a = (a + uint32(c)) % mod
		b = (b + a) % mod
	}
	return (b << 16) | a

	github.com/charmbracelet/x/ansi v0.11.6

	github.com/charmbracelet/x/ansi v0.11.6 // indirect