// clear.go 实现 MS-RDPEGFX 2.2.4 ClearCodec（TS_CLEARCODEC_BITMAP_STREAM）
// 的完整解码，算法对齐 FreeRDP libfreerdp/codec/clear.c。
//
// 流结构：glyphFlags(1) + seqNumber(1) + [glyph 段] + residualByteCount(4) +
// bandsByteCount(4) + subcodecByteCount(4) + 三段载荷。
package rdpgfx

import (
	"encoding/binary"
	"log/slog"
)

const (
	clearFlagGlyphIndex = 0x01
	clearFlagGlyphHit   = 0x02
	clearFlagCacheReset = 0x04

	clearVBarSize      = 32768
	clearShortVBarSize = 16384
	clearGlyphSize     = 4000
)

// nsCodecDisabled 诊断开关：置 true 时丢弃 NSCodec 矩形
var nsCodecDisabled = false

type clearCodecCtx struct {
	vBarStorage      [clearVBarSize]vBarEntry
	shortVBarStorage [clearShortVBarSize]vBarEntry
	vBarCursor       int
	shortVBarCursor  int
	glyphCache       [clearGlyphSize][]byte
	seqNumber        uint32
	logged           [24]bool
}

// logOnce 每类失败只打第一条日志，避免刷屏；位序号定位失败类别
func (ctx *clearCodecCtx) logOnce(slot int, msg string, args ...any) {
	if ctx.logged[slot] {
		return
	}
	ctx.logged[slot] = true
	slog.Warn("clear:"+msg, args...)
}

func newClearCodecCtx() *clearCodecCtx {
	return &clearCodecCtx{}
}

// decode 解出一张 w×h 的 BGRA 位图；流非法时返回 nil——调用方必须保留
// surface 原内容（对齐 FreeRDP 的整帧拒绝语义）。服务器会发送子编码矩形
// 完全越界的"空更新"流，若不拒绝会把清零缓冲 blit 到屏幕形成花屏块。
func (ctx *clearCodecCtx) decode(data []byte, w, h int) []byte {
	out := make([]byte, w*h*4)
	if len(data) < 2 {
		return nil
	}
	off := 0
	glyphFlags := data[off]
	seqNumber := data[off+1]
	off += 2

	// 序列号失步（丢包/上下文重置）时重新同步而不是丢弃整帧
	if ctx.seqNumber != uint32(seqNumber) {
		ctx.seqNumber = uint32(seqNumber)
	}
	ctx.seqNumber = (ctx.seqNumber + 1) % 256

	if glyphFlags&clearFlagCacheReset != 0 {
		// FreeRDP 语义：重置游标并重新分配存储 → 所有缓存条目失效
		for i := range ctx.vBarStorage {
			ctx.vBarStorage[i] = vBarEntry{}
		}
		for i := range ctx.shortVBarStorage {
			ctx.shortVBarStorage[i] = vBarEntry{}
		}
		ctx.vBarCursor = 0
		ctx.shortVBarCursor = 0
	}

	// MS-RDPEGFX/FreeRDP 语义：GLYPH_HIT 必须与 GLYPH_INDEX 同置（0x03=命中），
	// 单独的 HIT 是非法组合
	glyphIdx := -1
	if glyphFlags&clearFlagGlyphHit != 0 {
		if glyphFlags&clearFlagGlyphIndex == 0 {
			return nil
		}
		if off+2 > len(data) {
			return nil
		}
		idx := int(binary.LittleEndian.Uint16(data[off:]))
		off += 2
		if idx >= clearGlyphSize {
			return nil
		}
		if cached := ctx.glyphCache[idx]; len(cached) == len(out) {
			copy(out, cached)
		}
		return out
	}
	if glyphFlags&clearFlagGlyphIndex != 0 {
		if off+2 > len(data) {
			return nil
		}
		glyphIdx = int(binary.LittleEndian.Uint16(data[off:]))
		off += 2
		if glyphIdx >= clearGlyphSize {
			return nil
		}
	}

	if off+12 > len(data) {
		// FreeRDP：GLYPH_HIT|INDEX 的纯命中流允许没有 12 字节长度头
		return nil
	}
	residualLen := int(binary.LittleEndian.Uint32(data[off:]))
	bandsLen := int(binary.LittleEndian.Uint32(data[off+4:]))
	subcodecLen := int(binary.LittleEndian.Uint32(data[off+8:]))
	off += 12

	if residualLen > 0 {
		if off+residualLen > len(data) {
			return nil
		}
		if !ctx.clearDecodeResidual(data[off:off+residualLen], w, h, out) {
			return nil
		}
	}
	off += residualLen
	if bandsLen > 0 {
		if off+bandsLen > len(data) {
			return nil
		}
		if !ctx.clearDecodeBands(data[off:off+bandsLen], w, h, out) {
			return nil
		}
	}
	off += bandsLen
	if subcodecLen > 0 {
		if off+subcodecLen > len(data) {
			return nil
		}
		if !ctx.clearDecodeSubcodecs(data[off:off+subcodecLen], w, h, out) {
			return nil
		}
	}

	if glyphIdx >= 0 {
		cached := make([]byte, len(out))
		copy(cached, out)
		ctx.glyphCache[glyphIdx] = cached
	}
	return out
}

// clearDecodeResidual：(b,g,r,runLen) 游程填充，runLen 用 1/2/4 字节变长编码。
// 返回 false 表示流非法（对齐 FreeRDP 的整帧拒绝语义）。
func (ctx *clearCodecCtx) clearDecodeResidual(data []byte, w, h int, out []byte) bool {
	off, pixelIndex, pixelCount := 0, 0, w*h
	for off < len(data) {
		if off+4 > len(data) {
			ctx.logOnce(2, "residual truncated (entry hdr)")
			return false
		}
		b, g, r := data[off], data[off+1], data[off+2]
		run := int(data[off+3])
		off += 4
		if run >= 0xFF {
			if off+2 > len(data) {
				ctx.logOnce(2, "residual truncated (run16 hdr)")
				return false
			}
			run = int(binary.LittleEndian.Uint16(data[off:]))
			off += 2
			if run >= 0xFFFF {
				if off+4 > len(data) {
					ctx.logOnce(2, "residual truncated (run32 hdr)")
					return false
				}
				run = int(binary.LittleEndian.Uint32(data[off:]))
				off += 4
			}
		}
		if run > pixelCount-pixelIndex {
			ctx.logOnce(3, "residual run overflow", "run", run, "left", pixelCount-pixelIndex)
			return false
		}
		i := pixelIndex * 4
		for n := 0; n < run; n++ {
			out[i], out[i+1], out[i+2], out[i+3] = b, g, r, 0xFF
			i += 4
		}
		pixelIndex += run
	}
	if pixelIndex != pixelCount {
		// FreeRDP：residual 必须恰好铺满整幅，否则整帧失败
		ctx.logOnce(16, "residual incomplete", "covered", pixelIndex, "want", pixelCount)
		return false
	}
	return true
}

// clearDecodeBands：vBar 列带解码（含短 vBar 缓存/整 vBar 缓存/背景合成）。
// 返回 false 表示流非法（整帧拒绝）。
func (ctx *clearCodecCtx) clearDecodeBands(data []byte, w, h int, out []byte) bool {
	off := 0
	for off+11 <= len(data) {
		xStart := int(binary.LittleEndian.Uint16(data[off:]))
		xEnd := int(binary.LittleEndian.Uint16(data[off+2:]))
		yStart := int(binary.LittleEndian.Uint16(data[off+4:]))
		yEnd := int(binary.LittleEndian.Uint16(data[off+6:]))
		cb, cg, cr := data[off+8], data[off+9], data[off+10]
		off += 11
		if xEnd < xStart || yEnd < yStart {
			ctx.logOnce(4, "bands bad rect", "xStart", xStart, "xEnd", xEnd, "yStart", yStart, "yEnd", yEnd)
			return false
		}
		colorBkg := [4]byte{cb, cg, cr, 0xFF}
		vBarCount := xEnd - xStart + 1
		vBarHeight := yEnd - yStart + 1
		if vBarHeight > 52 {
			ctx.logOnce(5, "bands vBarHeight>52", "h", vBarHeight)
			return false
		}

		for i := 0; i < vBarCount; i++ {
			if off+2 > len(data) {
				return false
			}
			vBarHeader := binary.LittleEndian.Uint16(data[off:])
			off += 2

			var entry *vBarEntry
			var shortEntry *vBarEntry
			vBarUpdate := false
			vBarYOn := 0
			vBarShortPixelCount := 0

			switch {
			case vBarHeader&0xC000 == 0x4000: // SHORT_VBAR_CACHE_HIT
				idx := int(vBarHeader & 0x3FFF)
				if idx >= clearShortVBarSize {
					ctx.logOnce(6, "bands short idx range", "idx", idx)
					return false
				}
				shortEntry = &ctx.shortVBarStorage[idx]
				if off >= len(data) {
					return false
				}
				vBarYOn = int(data[off])
				off++
				vBarShortPixelCount = shortEntry.count
				vBarUpdate = true
			case vBarHeader&0xC000 == 0x0000: // SHORT_VBAR_CACHE_MISS
				vBarYOn = int(vBarHeader & 0xFF)
				vBarYOff := int((vBarHeader >> 8) & 0x3F)
				if vBarYOff < vBarYOn {
					ctx.logOnce(7, "bands yOff<yOn", "yOff", vBarYOff, "yOn", vBarYOn)
					return false
				}
				vBarShortPixelCount = vBarYOff - vBarYOn
				if vBarShortPixelCount > 52 {
					ctx.logOnce(8, "bands short count>52", "n", vBarShortPixelCount)
					return false
				}
				if off+vBarShortPixelCount*3 > len(data) {
					return false
				}
				shortEntry = &ctx.shortVBarStorage[ctx.shortVBarCursor]
				shortEntry.count = vBarShortPixelCount
				shortEntry.pixels = make([]byte, vBarShortPixelCount*4)
				for p := 0; p < vBarShortPixelCount; p++ {
					shortEntry.pixels[p*4] = data[off+p*3]
					shortEntry.pixels[p*4+1] = data[off+p*3+1]
					shortEntry.pixels[p*4+2] = data[off+p*3+2]
					shortEntry.pixels[p*4+3] = 0xFF
				}
				off += vBarShortPixelCount * 3
				ctx.shortVBarCursor = (ctx.shortVBarCursor + 1) % clearShortVBarSize
				vBarUpdate = true
			case vBarHeader&0x8000 == 0x8000: // VBAR_CACHE_HIT
				idx := int(vBarHeader & 0x7FFF)
				if idx >= clearVBarSize {
					ctx.logOnce(9, "bands vbar idx range", "idx", idx)
					return false
				}
				entry = &ctx.vBarStorage[idx]
				if entry.pixels == nil {
					// 缓存被重置后的命中：填充哑数据
					entry.count = vBarHeight
					entry.pixels = make([]byte, vBarHeight*4)
				}
			default:
				ctx.logOnce(10, "bands invalid vBarHeader", "hdr", vBarHeader)
				return false
			}

			if vBarUpdate {
				ve := &ctx.vBarStorage[ctx.vBarCursor]
				ve.count = vBarHeight
				ve.pixels = make([]byte, vBarHeight*4)
				// 前段背景 [0, vBarYOn)
				bgFront := vBarYOn
				if bgFront > vBarHeight {
					bgFront = vBarHeight
				}
				for y2 := 0; y2 < bgFront; y2++ {
					copy(ve.pixels[y2*4:(y2+1)*4], colorBkg[:])
				}
				// 中段：短 vBar 像素 [vBarYOn, vBarYOn+vBarShortPixelCount)
				count := vBarShortPixelCount
				if vBarYOn+count > vBarHeight {
					count = vBarHeight - vBarYOn
				}
				if count < 0 {
					count = 0
				}
				if count > 0 && shortEntry != nil {
					copy(ve.pixels[vBarYOn*4:(vBarYOn+count)*4], shortEntry.pixels[0:count*4])
				}
				// 后段背景 [vBarYOn+vBarShortPixelCount, vBarHeight)
				start := vBarYOn + vBarShortPixelCount
				if start < 0 {
					start = 0
				}
				if start > vBarHeight {
					start = vBarHeight
				}
				for y2 := start; y2 < vBarHeight; y2++ {
					copy(ve.pixels[y2*4:(y2+1)*4], colorBkg[:])
				}
				ctx.vBarCursor = (ctx.vBarCursor + 1) % clearVBarSize
				entry = ve
			}

			if entry == nil || entry.count != vBarHeight {
				continue
			}

			// 落到输出：第 i 列，从 yStart 起取 min(count, h-yStart) 像素
			x := xStart + i
			if x >= w {
				continue
			}
			count := entry.count
			if count > h-yStart {
				count = h - yStart
			}
			if count <= 0 {
				continue
			}
			for y := 0; y < count; y++ {
				dst := (yStart+y)*w*4 + x*4
				copy(out[dst:dst+4], entry.pixels[y*4:y*4+4])
			}
		}
	}
	return true
}

// clearDecodeSubcodecs：矩形级子编码（0=BGR24 原始，1=NSCodec，2=RLEX）。
// 返回 false 表示流非法（整帧拒绝）。
func (ctx *clearCodecCtx) clearDecodeSubcodecs(data []byte, w, h int, out []byte) bool {
	off := 0
	for off+13 <= len(data) {
		xStart := int(binary.LittleEndian.Uint16(data[off:]))
		yStart := int(binary.LittleEndian.Uint16(data[off+2:]))
		width := int(binary.LittleEndian.Uint16(data[off+4:]))
		height := int(binary.LittleEndian.Uint16(data[off+6:]))
		bmpLen := int(binary.LittleEndian.Uint32(data[off+8:]))
		subcodecId := data[off+12]
		off += 13
		if off+bmpLen > len(data) {
			ctx.logOnce(11, "subcodec payload truncated", "id", subcodecId, "want", bmpLen, "have", len(data)-off)
			return false
		}
		payload := data[off : off+bmpLen]
		off += bmpLen

		// FreeRDP 语义：子编码矩形越界是非法流，整帧拒绝（否则服务器发来的
		// 完全越界"空更新"矩形会把清零缓冲 blit 到屏幕形成花屏块）
		if xStart >= w || yStart >= h || xStart+width > w || yStart+height > h {
			ctx.logOnce(17, "subcodec rect out of bounds",
				"id", subcodecId, "x", xStart, "y", yStart, "rw", width, "rh", height, "w", w, "h", h)
			return false
		}

		switch subcodecId {
		case 0: // 未压缩 BGR24
			if len(payload) != width*height*3 {
				ctx.logOnce(18, "subcodec BGR24 size mismatch", "want", width*height*3, "have", len(payload))
				return false
			}
			clearWriteBGR24(payload, width, height, out, xStart, yStart, w, h)
		case 1: // NSCodec（YCoCg 色域压缩编码）
			if !clearDecodeNSCodec(payload, width, height, out, xStart, yStart, w, h) {
				return false
			}
		case 2: // RLEX
			if !ctx.clearDecodeRLEX(payload, width, height, out, xStart, yStart, w, h) {
				return false
			}
		default:
			ctx.logOnce(15, "unknown subcodec id", "id", subcodecId)
			return false
		}
	}
	return true
}

func clearWriteBGR24(data []byte, w, h int, out []byte, xDst, yDst, surfW, surfH int) {
	stride := w * 3
	if stride*h > len(data) {
		return
	}
	for y := 0; y < h; y++ {
		if yDst+y >= surfH {
			return
		}
		row := data[y*stride : (y+1)*stride]
		for x := 0; x < w; x++ {
			if xDst+x >= surfW {
				break
			}
			dst := (yDst+y)*surfW*4 + (xDst+x)*4
			out[dst], out[dst+1], out[dst+2], out[dst+3] = row[x*3], row[x*3+1], row[x*3+2], 0xFF
		}
	}
}

// clearDecodeNSCodec 解码 NSCodec 子编码矩形，算法对齐 FreeRDP libfreerdp/codec/nsc.c：
// 20 字节头（4×PlaneByteCount + ColorLossLevel + ChromaSubsamplingLevel + 保留 2 字节），
// 4 个色度平面（Y/Co/Cg/A）RLE 解压后做色损恢复与 YCoCg→RGB 转换。

func clearDecodeNSCodec(data []byte, w, h int, out []byte, xDst, yDst, surfW, surfH int) bool {
	if len(data) < 20 {
		return false
	}
	var planeCount [4]int
	total := 0
	for i := 0; i < 4; i++ {
		planeCount[i] = int(binary.LittleEndian.Uint32(data[i*4:]))
		total += planeCount[i]
	}
	colorLossLevel := int(data[16])
	chroma := int(data[17])
	if colorLossLevel < 1 || colorLossLevel > 7 {
		return false
	}
	planes := data[20:]
	if len(planes) < total {
		return false
	}

	rw := (w + 7) &^ 7
	rh := (h + 1) &^ 1
	// 原始平面字节数（OrgByteCount）
	org := [4]int{w * h, w * h, w * h, w * h}
	if chroma != 0 {
		org[0] = rw * h
		org[1] = (rw / 2) * (rh / 2)
		org[2] = org[1]
	}
	var pbuf [4][]byte
	for i := 0; i < 4; i++ {
		pbuf[i] = make([]byte, org[i])
	}

	off := 0
	for i := 0; i < 4; i++ {
		psize := planeCount[i]
		plane := planes[off : off+psize]
		off += psize
		switch {
		case psize == 0:
			for j := range pbuf[i] {
				pbuf[i][j] = 0xFF
			}
		case psize < org[i]:
			if !nscRLEDecode(plane, pbuf[i]) {
				return false
			}
		default:
			copy(pbuf[i], plane[:org[i]])
		}
	}

	// 色损恢复 + YCoCg→RGB：shift = ColorLossLevel-1
	shift := uint(colorLossLevel - 1)
	bmp := make([]byte, w*h*4)
	pos := 0
	for y := 0; y < h; y++ {
		var yplane, coplane, cgplane []byte
		if chroma != 0 {
			yplane = pbuf[0][y*rw:]
			coplane = pbuf[1][(y>>1)*(rw>>1):]
			cgplane = pbuf[2][(y>>1)*(rw>>1):]
		} else {
			yplane = pbuf[0][y*w:]
			coplane = pbuf[1][y*w:]
			cgplane = pbuf[2][y*w:]
		}
		// A 平面（pbuf[3]）不参与显示：canvas putImageData 会保留 alpha，
		// 非 255 的 alpha 会呈现半透明色块，故强制输出不透明
		coIdx, cgIdx := 0, 0
		for x := 0; x < w; x++ {
			yv := int16(yplane[x])
			// C: (INT16)(INT8)(((INT16)u8) << shift) —— 16 位环绕后截断低 8 位再符号扩展
			cov := int16(int8(byte(int16(coplane[coIdx]) << shift)))
			cgv := int16(int8(byte(int16(cgplane[cgIdx]) << shift)))
			rv := yv + cov - cgv
			gv := yv + cgv
			bv := yv - cov - cgv
			bmp[pos] = nscClamp(bv)
			bmp[pos+1] = nscClamp(gv)
			bmp[pos+2] = nscClamp(rv)
			// A 平面值不作为透明度使用：RDP 桌面内容恒不透明，而 canvas
			// putImageData 会保留 alpha，若 A 平面含非 255 值会呈现半透明色块
			bmp[pos+3] = 0xFF
			pos += 4
			if chroma != 0 {
				if x%2 == 1 {
					coIdx++
					cgIdx++
				}
			} else {
				coIdx++
				cgIdx++
			}
		}
	}
	blitBGRA(bmp, w, h, out, xDst, yDst, surfW, surfH)
	return true
}

// nscRLEDecode 单平面 NSC 游程解码，对齐 FreeRDP nsc_rle_decode
func nscRLEDecode(in, out []byte) bool {
	inOff, outOff := 0, 0
	left := len(out)
	for left > 4 {
		if inOff >= len(in) {
			return false
		}
		value := in[inOff]
		inOff++
		if left == 5 {
			out[outOff] = value
			outOff++
			left--
		} else if inOff >= len(in) {
			return false
		} else if value == in[inOff] {
			inOff++
			if inOff >= len(in) {
				return false
			}
			var run int
			if in[inOff] < 0xFF {
				run = int(in[inOff]) + 2
				inOff++
			} else {
				if inOff+5 > len(in) {
					return false
				}
				inOff++
				run = int(in[inOff]) | int(in[inOff+1])<<8 | int(in[inOff+2])<<16 | int(in[inOff+3])<<24
				inOff += 4
			}
			if run > len(out)-outOff || run > left {
				return false
			}
			for j := 0; j < run; j++ {
				out[outOff+j] = value
			}
			outOff += run
			left -= run
		} else {
			out[outOff] = value
			outOff++
			left--
		}
	}
	if len(out)-outOff < 4 || left < 4 || len(in)-inOff < 4 {
		return false
	}
	copy(out[outOff:outOff+4], in[inOff:inOff+4])
	return true
}

func nscClamp(v int16) byte {
	if v < 0 {
		return 0
	}
	if v > 255 {
		return 255
	}
	return byte(v)
}

func blitBGRA(src []byte, w, h int, out []byte, xDst, yDst, surfW, surfH int) {
	for y := 0; y < h; y++ {
		dy := yDst + y
		if dy >= surfH {
			return
		}
		for x := 0; x < w; x++ {
			dx := xDst + x
			if dx >= surfW {
				break
			}
			copy(out[(dy*surfW+dx)*4:(dy*surfW+dx)*4+4], src[(y*w+x)*4:(y*w+x)*4+4])
		}
	}
}

// clearDecodeRLEX：调色板游程编码（套位打包索引）
func (ctx *clearCodecCtx) clearDecodeRLEX(data []byte, w, h int, out []byte, xDst, yDst, surfW, surfH int) bool {
	if len(data) < 1 {
		return false
	}
	paletteCount := int(data[0])
	if paletteCount < 1 || paletteCount > 127 {
		return false
	}
	if 1+paletteCount*3 > len(data) {
		return false
	}
	palette := make([][4]byte, paletteCount)
	off := 1
	for i := 0; i < paletteCount; i++ {
		palette[i] = [4]byte{data[off], data[off+1], data[off+2], 0xFF} // b,g,r
		off += 3
	}

	numBits := clearLog2Floor(paletteCount-1) + 1
	pixelCount := w * h
	pixelIndex := 0
	x, y := 0, 0
	putPixel := func(c [4]byte) {
		if xDst+x < surfW && yDst+y < surfH {
			dst := (yDst+y)*surfW*4 + (xDst+x)*4
			copy(out[dst:dst+4], c[:])
		}
		if x++; x >= w {
			y++
			x = 0
		}
	}
	for off+2 <= len(data) && pixelIndex < pixelCount {
		tmp := data[off]
		run := int(data[off+1])
		off += 2
		suiteDepth := int(tmp >> uint(numBits) & clear8BitMask(8-numBits))
		stopIndex := int(tmp & clear8BitMask(numBits))
		startIndex := stopIndex - suiteDepth
		if run >= 0xFF {
			if off+2 > len(data) {
				ctx.logOnce(13, "rlex truncated (run16 hdr)")
				return false
			}
			run = int(binary.LittleEndian.Uint16(data[off:]))
			off += 2
			if run >= 0xFFFF {
				if off+4 > len(data) {
					ctx.logOnce(13, "rlex truncated (run32 hdr)")
					return false
				}
				run = int(binary.LittleEndian.Uint32(data[off:]))
				off += 4
			}
		}
		if startIndex < 0 || startIndex >= paletteCount || stopIndex >= paletteCount {
			ctx.logOnce(12, "rlex bad palette index", "start", startIndex, "stop", stopIndex, "count", paletteCount)
			return false
		}
		if run > pixelCount-pixelIndex {
			ctx.logOnce(14, "rlex run overflow", "run", run, "left", pixelCount-pixelIndex)
			return false
		}
		for i := 0; i < run; i++ {
			putPixel(palette[startIndex])
		}
		pixelIndex += run
		for i := 0; i <= suiteDepth && pixelIndex < pixelCount; i++ {
			putPixel(palette[startIndex+i])
			pixelIndex++
		}
	}
	if pixelIndex != pixelCount {
		// FreeRDP：RLEX 必须恰好覆盖矩形，否则整帧失败
		ctx.logOnce(19, "rlex incomplete", "covered", pixelIndex, "want", pixelCount)
		return false
	}
	return true
}

func clear8BitMask(bits int) byte {
	if bits <= 0 || bits > 8 {
		return 0
	}
	return byte((1 << uint(bits)) - 1)
}

func clearLog2Floor(v int) int {
	log := 0
	for v > 1 {
		v >>= 1
		log++
	}
	return log
}