package stego

import (
	"bytes"
	"compress/zlib"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"strings"

	"github.com/andydixon/nexus/internal/leviathan/document"
)

// MetaEntry is one piece of textual/EXIF metadata recovered from an image.
type MetaEntry struct {
	Offset    int64  `json:"offset"`
	Length    int64  `json:"length"`
	Container string `json:"container"`
	Kind      string `json:"kind"`
	Keyword   string `json:"keyword"`
	Value     string `json:"value"`
	Note      string `json:"note,omitempty"`
}

// ScanMetadata walks PNG chunks or JPEG segments (APPn / COM) and decodes
// human-readable metadata. Output is best-effort — malformed containers
// return whatever has been parsed up to the failure point.
func ScanMetadata(d *document.Document) ([]MetaEntry, error) {
	size := d.Size()
	if size < 8 {
		return nil, errors.New("file too small")
	}
	head, err := d.Range(0, minInt64(16, size))
	if err != nil {
		return nil, err
	}
	switch {
	case len(head) >= 8 && string(head[:8]) == "\x89PNG\r\n\x1a\n":
		return scanPNGMeta(d)
	case len(head) >= 3 && head[0] == 0xff && head[1] == 0xd8 && head[2] == 0xff:
		return scanJPEGMeta(d)
	case len(head) >= 6 && (string(head[:6]) == "GIF87a" || string(head[:6]) == "GIF89a"):
		return scanGIFMeta(d)
	}
	return nil, errors.New("unsupported container (PNG, JPEG and GIF handled)")
}

func scanPNGMeta(d *document.Document) ([]MetaEntry, error) {
	size := d.Size()
	out := []MetaEntry{}
	off := int64(8)
	for off+12 <= size {
		hdr, err := d.Range(off, 8)
		if err != nil {
			break
		}
		ln := int64(binary.BigEndian.Uint32(hdr[0:4]))
		typ := string(hdr[4:8])
		if ln < 0 || off+12+ln > size {
			break
		}
		if typ == "tEXt" || typ == "zTXt" || typ == "iTXt" {
			data, err := d.Range(off+8, ln)
			if err == nil {
				entry := decodePNGTextChunk(typ, data)
				entry.Offset = off
				entry.Length = 12 + ln
				entry.Container = "png"
				out = append(out, entry)
			}
		}
		off += 12 + ln
		if typ == "IEND" {
			break
		}
	}
	return out, nil
}

func decodePNGTextChunk(typ string, data []byte) MetaEntry {
	e := MetaEntry{Kind: typ}
	i := bytes.IndexByte(data, 0)
	if i < 0 {
		e.Note = "no keyword separator"
		e.Value = safeText(data)
		return e
	}
	e.Keyword = string(data[:i])
	rest := data[i+1:]
	switch typ {
	case "tEXt":
		e.Value = safeText(rest)
	case "zTXt":
		if len(rest) < 1 {
			e.Note = "truncated"
			return e
		}
		// rest[0] = compression method (0 = zlib)
		method := rest[0]
		raw, err := zlibDecompress(rest[1:])
		if err != nil {
			e.Note = fmt.Sprintf("zlib fail (method=%d): %v", method, err)
			return e
		}
		e.Value = safeText(raw)
	case "iTXt":
		// compression flag, compression method, language tag\0, translated keyword\0, text
		if len(rest) < 2 {
			e.Note = "truncated"
			return e
		}
		compressed := rest[0] == 1
		rest = rest[2:]
		j := bytes.IndexByte(rest, 0)
		if j < 0 {
			e.Value = safeText(rest)
			return e
		}
		lang := string(rest[:j])
		rest = rest[j+1:]
		k := bytes.IndexByte(rest, 0)
		if k < 0 {
			e.Value = safeText(rest)
			return e
		}
		trk := string(rest[:k])
		rest = rest[k+1:]
		if compressed {
			if raw, err := zlibDecompress(rest); err == nil {
				rest = raw
			} else {
				e.Note = "zlib fail: " + err.Error()
			}
		}
		v := safeText(rest)
		if lang != "" || trk != "" {
			v = fmt.Sprintf("[%s/%s] %s", lang, trk, v)
		}
		e.Value = v
	}
	return e
}

func scanJPEGMeta(d *document.Document) ([]MetaEntry, error) {
	size := d.Size()
	out := []MetaEntry{}
	off := int64(2) // skip SOI
	for off+4 <= size {
		hdr, err := d.Range(off, 2)
		if err != nil || hdr[0] != 0xff {
			break
		}
		marker := hdr[1]
		// Standalone markers (no payload): SOI/EOI/RSTn
		if marker == 0xd9 || marker == 0xd8 || (marker >= 0xd0 && marker <= 0xd7) {
			off += 2
			continue
		}
		// Read segment length (big-endian, includes the length bytes themselves)
		lnBytes, err := d.Range(off+2, 2)
		if err != nil {
			break
		}
		segLen := int64(binary.BigEndian.Uint16(lnBytes))
		if segLen < 2 || off+2+segLen > size {
			break
		}
		payload, err := d.Range(off+4, segLen-2)
		if err != nil {
			break
		}
		switch {
		case marker == 0xfe: // COM
			out = append(out, MetaEntry{
				Offset: off, Length: 2 + segLen,
				Container: "jpeg", Kind: "COM",
				Value: safeText(payload),
			})
		case marker == 0xe1: // APP1 — EXIF / XMP
			entries := decodeJPEGApp1(payload)
			for _, e := range entries {
				e.Offset = off
				e.Length = 2 + segLen
				e.Container = "jpeg"
				out = append(out, e)
			}
		case marker == 0xe0: // APP0 — JFIF
			out = append(out, MetaEntry{
				Offset: off, Length: 2 + segLen,
				Container: "jpeg", Kind: "APP0",
				Keyword: sniffMarker(payload),
				Value:   fmt.Sprintf("%d bytes", len(payload)),
			})
		case marker >= 0xe2 && marker <= 0xef: // APP2..APP15
			out = append(out, MetaEntry{
				Offset: off, Length: 2 + segLen,
				Container: "jpeg", Kind: fmt.Sprintf("APP%d", marker-0xe0),
				Keyword: sniffMarker(payload),
				Value:   fmt.Sprintf("%d bytes", len(payload)),
			})
		}
		off += 2 + segLen
		// SOS (Start of Scan) — entropy-coded data follows, stop walking.
		if marker == 0xda {
			break
		}
	}
	return out, nil
}

func sniffMarker(p []byte) string {
	i := bytes.IndexByte(p, 0)
	if i < 0 || i > 16 {
		if len(p) > 16 {
			return string(p[:16])
		}
		return ""
	}
	return string(p[:i])
}

func decodeJPEGApp1(p []byte) []MetaEntry {
	out := []MetaEntry{}
	if len(p) >= 6 && string(p[:6]) == "Exif\x00\x00" {
		tiff := p[6:]
		entries, err := decodeEXIF(tiff)
		if err == nil {
			out = append(out, entries...)
		} else {
			out = append(out, MetaEntry{Kind: "APP1/EXIF", Note: err.Error()})
		}
		return out
	}
	if len(p) >= 28 && string(p[:28]) == "http://ns.adobe.com/xap/1.0/" {
		xmp := p[29:]
		out = append(out, MetaEntry{
			Kind: "APP1/XMP", Keyword: "xmp", Value: safeText(xmp),
		})
		return out
	}
	out = append(out, MetaEntry{
		Kind: "APP1", Keyword: sniffMarker(p), Value: fmt.Sprintf("%d bytes", len(p)),
	})
	return out
}

// EXIF reader: TIFF header + IFD0 + IFD1 + Exif SubIFD + GPS SubIFD +
// Interoperability IFD. Handles ASCII/BYTE/SHORT/LONG/RATIONAL/SRATIONAL
// values, plus UNDEFINED as hex preview. Detects MakerNote presence.
func decodeEXIF(tiff []byte) ([]MetaEntry, error) {
	if len(tiff) < 8 {
		return nil, errors.New("short TIFF header")
	}
	var bo binary.ByteOrder
	switch string(tiff[:2]) {
	case "II":
		bo = binary.LittleEndian
	case "MM":
		bo = binary.BigEndian
	default:
		return nil, errors.New("bad TIFF byte-order mark")
	}
	if bo.Uint16(tiff[2:4]) != 0x002a {
		return nil, errors.New("bad TIFF magic")
	}
	ifd0 := int(bo.Uint32(tiff[4:8]))
	out := []MetaEntry{}
	ptrs := ifdPointers{}
	nextIFD := 0
	out = append(out, readIFD(tiff, ifd0, bo, "IFD0", &ptrs, &nextIFD)...)
	// IFD1 (thumbnail) if present.
	if nextIFD > 0 {
		out = append(out, readIFD(tiff, nextIFD, bo, "IFD1", nil, nil)...)
	}
	if ptrs.exif > 0 {
		out = append(out, readIFD(tiff, ptrs.exif, bo, "ExifIFD", &ptrs, nil)...)
	}
	if ptrs.gps > 0 {
		out = append(out, readIFD(tiff, ptrs.gps, bo, "GPSIFD", nil, nil)...)
	}
	if ptrs.interop > 0 {
		out = append(out, readIFD(tiff, ptrs.interop, bo, "InteropIFD", nil, nil)...)
	}
	return out, nil
}

type ifdPointers struct {
	exif    int
	gps     int
	interop int
}

func readIFD(tiff []byte, off int, bo binary.ByteOrder, name string, ptrs *ifdPointers, nextPtr *int) []MetaEntry {
	out := []MetaEntry{}
	if off < 0 || off+2 > len(tiff) {
		return out
	}
	n := int(bo.Uint16(tiff[off : off+2]))
	base := off + 2
	// Cap directory count to head off hostile input.
	if n > 512 {
		n = 512
	}
	for i := 0; i < n; i++ {
		p := base + i*12
		if p+12 > len(tiff) {
			break
		}
		tag := bo.Uint16(tiff[p : p+2])
		typ := bo.Uint16(tiff[p+2 : p+4])
		count := int(bo.Uint32(tiff[p+4 : p+8]))
		valRaw := tiff[p+8 : p+12]
		// Sub-IFD pointers never appear as regular entries in the output.
		if ptrs != nil {
			switch tag {
			case 0x8769: // Exif SubIFD pointer
				ptrs.exif = int(bo.Uint32(valRaw))
				continue
			case 0x8825: // GPS IFD pointer
				ptrs.gps = int(bo.Uint32(valRaw))
				continue
			case 0xa005: // Interoperability IFD pointer
				ptrs.interop = int(bo.Uint32(valRaw))
				continue
			}
		}
		e := MetaEntry{Kind: name, Keyword: exifTagName(tag, name)}
		if tag == 0x927c { // MakerNote
			e.Value = fmt.Sprintf("%d bytes (vendor-specific, not decoded)", count)
			out = append(out, e)
			continue
		}
		e.Value = readEXIFValue(tiff, bo, typ, count, valRaw)
		out = append(out, e)
	}
	// "Next IFD" pointer follows the directory entries (4 bytes).
	if nextPtr != nil {
		tail := base + n*12
		if tail+4 <= len(tiff) {
			*nextPtr = int(bo.Uint32(tiff[tail : tail+4]))
		}
	}
	return out
}

func readEXIFValue(tiff []byte, bo binary.ByteOrder, typ uint16, count int, valRaw []byte) string {
	typeSize := map[uint16]int{1: 1, 2: 1, 3: 2, 4: 4, 5: 8, 7: 1, 9: 4, 10: 8}
	sz, ok := typeSize[typ]
	if !ok {
		return fmt.Sprintf("type=%d count=%d", typ, count)
	}
	total := sz * count
	var data []byte
	if total <= 4 {
		data = valRaw[:total]
	} else {
		off := int(bo.Uint32(valRaw))
		if off < 0 || off+total > len(tiff) {
			return fmt.Sprintf("type=%d count=%d (oob)", typ, count)
		}
		data = tiff[off : off+total]
	}
	switch typ {
	case 2: // ASCII (null-terminated)
		return safeText(bytes.TrimRight(data, "\x00"))
	case 1, 7: // BYTE, UNDEFINED — show as hex preview
		if len(data) > 32 {
			return fmt.Sprintf("%x… (%d bytes)", data[:32], len(data))
		}
		return fmt.Sprintf("%x", data)
	case 3: // SHORT
		parts := []string{}
		for i := 0; i < count && i < 8; i++ {
			parts = append(parts, fmt.Sprintf("%d", bo.Uint16(data[i*2:i*2+2])))
		}
		if count > 8 {
			parts = append(parts, "…")
		}
		return strings.Join(parts, ", ")
	case 4: // LONG
		parts := []string{}
		for i := 0; i < count && i < 6; i++ {
			parts = append(parts, fmt.Sprintf("%d", bo.Uint32(data[i*4:i*4+4])))
		}
		if count > 6 {
			parts = append(parts, "…")
		}
		return strings.Join(parts, ", ")
	case 5, 10: // RATIONAL / SRATIONAL
		parts := []string{}
		for i := 0; i < count && i < 4; i++ {
			n := bo.Uint32(data[i*8 : i*8+4])
			dn := bo.Uint32(data[i*8+4 : i*8+8])
			if dn == 0 {
				parts = append(parts, fmt.Sprintf("%d/0", n))
			} else {
				parts = append(parts, fmt.Sprintf("%d/%d", n, dn))
			}
		}
		return strings.Join(parts, ", ")
	case 9: // SLONG
		parts := []string{}
		for i := 0; i < count && i < 6; i++ {
			parts = append(parts, fmt.Sprintf("%d", int32(bo.Uint32(data[i*4:i*4+4]))))
		}
		return strings.Join(parts, ", ")
	}
	return fmt.Sprintf("type=%d count=%d", typ, count)
}

func exifTagName(tag uint16, ifd string) string {
	if ifd == "GPSIFD" {
		if n, ok := gpsTags[tag]; ok {
			return n
		}
		return fmt.Sprintf("GPS tag 0x%04x", tag)
	}
	if n, ok := exifTags[tag]; ok {
		return n
	}
	return fmt.Sprintf("tag 0x%04x", tag)
}

// exifTags covers the standard TIFF/Exif tags routinely seen in
// JPEG/TIFF images produced by consumer cameras and phones.
var exifTags = map[uint16]string{
	// TIFF / IFD0
	0x0100: "ImageWidth", 0x0101: "ImageLength",
	0x0102: "BitsPerSample", 0x0103: "Compression",
	0x0106: "PhotometricInterpretation", 0x010a: "FillOrder",
	0x010d: "DocumentName", 0x010e: "ImageDescription",
	0x010f: "Make", 0x0110: "Model", 0x0111: "StripOffsets",
	0x0112: "Orientation", 0x0115: "SamplesPerPixel",
	0x0116: "RowsPerStrip", 0x0117: "StripByteCounts",
	0x011a: "XResolution", 0x011b: "YResolution",
	0x011c: "PlanarConfiguration", 0x0128: "ResolutionUnit",
	0x012d: "TransferFunction", 0x0131: "Software", 0x0132: "DateTime",
	0x013b: "Artist", 0x013c: "HostComputer",
	0x013e: "WhitePoint", 0x013f: "PrimaryChromaticities",
	0x0211: "YCbCrCoefficients", 0x0212: "YCbCrSubSampling",
	0x0213: "YCbCrPositioning", 0x0214: "ReferenceBlackWhite",
	0x02bc: "XMP",
	0x8298: "Copyright", 0x83bb: "IPTCNAA",
	0x8769: "ExifIFDPointer", 0x8773: "InterColorProfile",
	0x8825: "GPSIFDPointer",
	// Exif SubIFD
	0x829a: "ExposureTime", 0x829d: "FNumber",
	0x8822: "ExposureProgram", 0x8824: "SpectralSensitivity",
	0x8827: "ISOSpeedRatings", 0x8828: "OECF",
	0x9000: "ExifVersion",
	0x9003: "DateTimeOriginal", 0x9004: "DateTimeDigitized",
	0x9010: "OffsetTime", 0x9011: "OffsetTimeOriginal", 0x9012: "OffsetTimeDigitized",
	0x9101: "ComponentsConfiguration", 0x9102: "CompressedBitsPerPixel",
	0x9201: "ShutterSpeedValue", 0x9202: "ApertureValue",
	0x9203: "BrightnessValue", 0x9204: "ExposureBiasValue",
	0x9205: "MaxApertureValue", 0x9206: "SubjectDistance",
	0x9207: "MeteringMode", 0x9208: "LightSource", 0x9209: "Flash",
	0x920a: "FocalLength",
	0x9214: "SubjectArea", 0x927c: "MakerNote", 0x9286: "UserComment",
	0x9290: "SubSecTime", 0x9291: "SubSecTimeOriginal", 0x9292: "SubSecTimeDigitized",
	0xa000: "FlashpixVersion", 0xa001: "ColorSpace",
	0xa002: "PixelXDimension", 0xa003: "PixelYDimension",
	0xa004: "RelatedSoundFile", 0xa005: "InteropIFDPointer",
	0xa20b: "FlashEnergy", 0xa20c: "SpatialFrequencyResponse",
	0xa20e: "FocalPlaneXResolution", 0xa20f: "FocalPlaneYResolution",
	0xa210: "FocalPlaneResolutionUnit",
	0xa214: "SubjectLocation", 0xa215: "ExposureIndex",
	0xa217: "SensingMethod", 0xa300: "FileSource", 0xa301: "SceneType",
	0xa302: "CFAPattern", 0xa401: "CustomRendered",
	0xa402: "ExposureMode", 0xa403: "WhiteBalance",
	0xa404: "DigitalZoomRatio", 0xa405: "FocalLengthIn35mmFilm",
	0xa406: "SceneCaptureType", 0xa407: "GainControl",
	0xa408: "Contrast", 0xa409: "Saturation", 0xa40a: "Sharpness",
	0xa40b: "DeviceSettingDescription", 0xa40c: "SubjectDistanceRange",
	0xa420: "ImageUniqueID", 0xa430: "OwnerName", 0xa431: "SerialNumber",
	0xa432: "LensSpecification", 0xa433: "LensMake", 0xa434: "LensModel",
	0xa435: "LensSerialNumber",
	// Thumbnail IFD1 re-uses IFD0 tags; additional ones:
	0x0201: "JPEGInterchangeFormat", 0x0202: "JPEGInterchangeFormatLength",
}

var gpsTags = map[uint16]string{
	0x0000: "GPSVersionID", 0x0001: "GPSLatitudeRef", 0x0002: "GPSLatitude",
	0x0003: "GPSLongitudeRef", 0x0004: "GPSLongitude",
	0x0005: "GPSAltitudeRef", 0x0006: "GPSAltitude",
	0x0007: "GPSTimeStamp", 0x0008: "GPSSatellites", 0x0009: "GPSStatus",
	0x000a: "GPSMeasureMode", 0x000b: "GPSDOP", 0x000c: "GPSSpeedRef",
	0x000d: "GPSSpeed", 0x000e: "GPSTrackRef", 0x000f: "GPSTrack",
	0x0010: "GPSImgDirectionRef", 0x0011: "GPSImgDirection",
	0x0012: "GPSMapDatum", 0x0013: "GPSDestLatitudeRef", 0x0014: "GPSDestLatitude",
	0x0015: "GPSDestLongitudeRef", 0x0016: "GPSDestLongitude",
	0x0017: "GPSDestBearingRef", 0x0018: "GPSDestBearing",
	0x0019: "GPSDestDistanceRef", 0x001a: "GPSDestDistance",
	0x001b: "GPSProcessingMethod", 0x001c: "GPSAreaInformation",
	0x001d: "GPSDateStamp", 0x001e: "GPSDifferential", 0x001f: "GPSHPositioningError",
}

func zlibDecompress(b []byte) ([]byte, error) {
	r, err := zlib.NewReader(bytes.NewReader(b))
	if err != nil {
		return nil, err
	}
	defer r.Close()
	// 2 MiB cap — textual metadata should never be near this.
	lim := &io.LimitedReader{R: r, N: 2 * 1024 * 1024}
	return io.ReadAll(lim)
}

func safeText(b []byte) string {
	// Preserve text but trim extreme size and strip control chars other than tab/newline.
	if len(b) > 4096 {
		b = b[:4096]
	}
	sb := strings.Builder{}
	sb.Grow(len(b))
	for _, c := range b {
		if c == '\t' || c == '\n' || c == '\r' || (c >= 0x20 && c <= 0x7e) {
			sb.WriteByte(c)
			continue
		}
		if c >= 0x80 {
			// Pass through; browser will render as UTF-8 if valid.
			sb.WriteByte(c)
			continue
		}
		// Drop other controls.
	}
	return sb.String()
}

func minInt64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// scanGIFMeta walks a GIF file and surfaces every extension block that
// can carry human-readable data: Comment (0x21 0xFE), Plain Text
// (0x21 0x01), and Application (0x21 0xFF — XMP, Netscape loop, etc.).
func scanGIFMeta(d *document.Document) ([]MetaEntry, error) {
	size := d.Size()
	out := []MetaEntry{}
	// Skip header (6) + logical screen descriptor (7 fixed) and the
	// optional global colour table.
	hdr, err := d.Range(0, 13)
	if err != nil {
		return nil, err
	}
	off := int64(13)
	packed := hdr[10]
	if packed&0x80 != 0 {
		gctSize := int64(3) * (int64(1) << uint((packed&0x07)+1))
		off += gctSize
	}
	for off < size {
		b, err := d.Range(off, 1)
		if err != nil {
			break
		}
		switch b[0] {
		case 0x3b: // trailer
			return out, nil
		case 0x2c: // Image Descriptor: skip descriptor + optional LCT + LZW data
			next, ok := skipGIFImage(d, off)
			if !ok {
				return out, nil
			}
			off = next
		case 0x21: // Extension Introducer
			if off+2 > size {
				return out, nil
			}
			lbl, _ := d.Range(off+1, 1)
			start := off
			payload, next, ok := readGIFSubBlocks(d, off+2)
			if !ok {
				return out, nil
			}
			switch lbl[0] {
			case 0xfe:
				out = append(out, MetaEntry{
					Offset: start, Length: next - start,
					Container: "gif", Kind: "Comment",
					Value: safeText(payload),
				})
			case 0x01:
				// Plain Text: first 12 bytes are text-grid parameters.
				text := payload
				if len(text) > 12 {
					text = text[12:]
				} else {
					text = nil
				}
				out = append(out, MetaEntry{
					Offset: start, Length: next - start,
					Container: "gif", Kind: "PlainText",
					Value: safeText(text),
				})
			case 0xff:
				// Application Extension: first sub-block is an 11-byte
				// identifier like "NETSCAPE2.0" or "XMP DataXMP".
				if len(payload) >= 11 {
					appID := string(bytes.TrimRight(payload[:11], "\x00 "))
					rest := payload[11:]
					out = append(out, MetaEntry{
						Offset: start, Length: next - start,
						Container: "gif", Kind: "Application",
						Keyword: appID,
						Value:   safeText(rest),
					})
				} else {
					out = append(out, MetaEntry{
						Offset: start, Length: next - start,
						Container: "gif", Kind: "Application",
						Value: safeText(payload),
					})
				}
			default:
				// Graphic control (0xf9) and others — skip.
			}
			off = next
		default:
			// Unknown byte; bail.
			return out, nil
		}
	}
	return out, nil
}

// readGIFSubBlocks reads a chain of GIF sub-blocks: each starts with a
// length byte (0 terminates). Returns (concatenated payload, offset of
// next byte after terminator, ok).
func readGIFSubBlocks(d *document.Document, off int64) ([]byte, int64, bool) {
	size := d.Size()
	out := []byte{}
	for off < size {
		ln, err := d.Range(off, 1)
		if err != nil {
			return nil, off, false
		}
		n := int64(ln[0])
		off++
		if n == 0 {
			return out, off, true
		}
		if off+n > size {
			return nil, off, false
		}
		block, err := d.Range(off, n)
		if err != nil {
			return nil, off, false
		}
		out = append(out, block...)
		off += n
		// Hard cap to prevent OOM on malformed input.
		if len(out) > 16*1024*1024 {
			return out, off, true
		}
	}
	return nil, off, false
}

// skipGIFImage walks an Image Descriptor block starting at off (the 0x2c
// byte), skipping the descriptor, any local colour table, the LZW
// minimum-code-size byte and the image data sub-blocks. Returns the
// offset of the next block, or (0, false) on truncation.
func skipGIFImage(d *document.Document, off int64) (int64, bool) {
	size := d.Size()
	if off+10 > size {
		return 0, false
	}
	desc, err := d.Range(off, 10)
	if err != nil {
		return 0, false
	}
	packed := desc[9]
	off += 10
	if packed&0x80 != 0 {
		lctSize := int64(3) * (int64(1) << uint((packed&0x07)+1))
		off += lctSize
	}
	// LZW minimum code size byte, then sub-blocks.
	if off+1 > size {
		return 0, false
	}
	off++
	_, next, ok := readGIFSubBlocks(d, off)
	if !ok {
		return 0, false
	}
	return next, true
}