package core

import (
	"fmt"
	"log/slog"
	"sync"
	"unsafe"
)

func CVAL(p *[]uint8) int {
	a := int((*p)[0])
	*p = (*p)[1:]
	return a
}

func CVAL2(p *[]uint8, v *uint16) {
	*v = *((*uint16)(unsafe.Pointer(&(*p)[0])))
	*p = (*p)[2:]
}

func CVAL3(p *[]uint8, v *[3]uint8) {
	(*v)[0] = (*p)[0]
	(*v)[1] = (*p)[1]
	(*v)[2] = (*p)[2]
	*p = (*p)[3:]
}

func REPEAT(f func(), count *int, x *int, width int) {
	for *count > 0 && *x < width {
		f()
		*count--
		*x++
	}
}

// rleFailLog 记录 RLE 解码失败（限次），此前失败被静默吞掉：
// 半解码的池化缓冲被直接画上画布形成噪块，且无任何日志可查。
func rleFailLog(reason string, width, height, inputLen int, consumed int) {
	slog.Warn("bitmap RLE decode failed", "reason", reason,
		"w", width, "h", height, "inputLen", inputLen, "consumed", consumed)
}

/* 1 byte bitmap decompress */
func decompress1(output *[]uint8, width, height int, input []uint8, size int) bool {
	var (
		prevline, line, count            int
		offset, code                     int
		x                                int = width
		opcode                           int
		lastopcode                       int8 = -1
		insertmix, bicolour, isfillormix bool
		mixmask, mask                    uint8
		colour1, colour2                 uint8
		mix                              uint8 = 0xff
		fom_mask                         uint8
	)
	out := *output
	for len(input) != 0 {
		fom_mask = 0
		code = CVAL(&input)
		opcode = code >> 4
		/* Handle different opcode forms */
		switch opcode {
		case 0xc, 0xd, 0xe:
			opcode -= 6
			count = int(code & 0xf)
			offset = 16
			break
		case 0xf:
			opcode = code & 0xf
			if opcode < 9 {
				count = int(CVAL(&input))
				count |= int(CVAL(&input) << 8)
			} else {
				count = 1
				if opcode < 0xb {
					count = 8
				}
			}
			offset = 0
			break
		default:
			opcode >>= 1
			count = int(code & 0x1f)
			offset = 32
			break
		}
		/* Handle strange cases for counts */
		if offset != 0 {
			isfillormix = ((opcode == 2) || (opcode == 7))
			if count == 0 {
				if isfillormix {
					count = int(CVAL(&input)) + 1
				} else {
					count = int(CVAL(&input) + offset)
				}
			} else if isfillormix {
				count <<= 3
			}
		}
		/* Read preliminary data */
		switch opcode {
		case 0: /* Fill */
			if (lastopcode == int8(opcode)) && !((x == width) && (prevline == 0)) {
				insertmix = true
			}
			break
		case 8: /* Bicolour */
			colour1 = uint8(CVAL(&input))
			colour2 = uint8(CVAL(&input))
			break
		case 3: /* Colour */
			colour2 = uint8(CVAL(&input))
			break
		case 6: /* SetMix/Mix */
			fallthrough
		case 7: /* SetMix/FillOrMix */
			mix = uint8(CVAL(&input))
			opcode -= 5
			break
		case 9: /* FillOrMix_1 */
			mask = 0x03
			opcode = 0x02
			fom_mask = 3
			break
		case 0x0a: /* FillOrMix_2 */
			mask = 0x05
			opcode = 0x02
			fom_mask = 5
			break
		}
		lastopcode = int8(opcode)
		mixmask = 0
		/* Output body */
		for count > 0 {
			if x >= width {
				if height <= 0 {
					return false
				}

				x = 0
				height--
				prevline = line
				line = height * width
			}
			switch opcode {
			case 0: /* Fill */
				if insertmix {
					if prevline == 0 {
						out[x+line] = mix
					} else {
						out[x+line] = out[prevline+x] ^ mix
					}
					insertmix = false
					count--
					x++
				}
				n := min(count, width-x)
				if prevline == 0 {
					clear(out[x+line : x+line+n])
				} else {
					copy(out[x+line:x+line+n], out[prevline+x:prevline+x+n])
				}
				count -= n
				x += n
				break
			case 1: /* Mix */
				n := min(count, width-x)
				if prevline == 0 {
					seg := out[x+line : x+line+n]
					for i := range seg {
						seg[i] = mix
					}
				} else {
					src := out[prevline+x : prevline+x+n]
					dst := out[x+line : x+line+n]
					for i := range dst {
						dst[i] = src[i] ^ mix
					}
				}
				count -= n
				x += n
				break
			case 2: /* Fill or Mix */
				if prevline == 0 {
					for count > 0 && x < width {
						mixmask <<= 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[x+line] = mix
						} else {
							out[x+line] = 0
						}

						count--
						x++
					}
				} else {
					for count > 0 && x < width {
						mixmask = mixmask << 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[x+line] = out[prevline+x] ^ mix
						} else {
							out[x+line] = out[prevline+x]
						}

						count--
						x++
					}
				}
				break
			case 3: /* Colour */
				n := min(count, width-x)
				seg := out[x+line : x+line+n]
				for i := range seg {
					seg[i] = colour2
				}
				count -= n
				x += n
				break
			case 4: /* Copy */
				for count > 0 && x < width {
					n := min(count, width-x)
					if len(input) < n {
						return false
					}
					copy(out[x+line:x+line+n], input[:n])
					input = input[n:]
					count -= n
					x += n
				}
				break
			case 8: /* Bicolour */
				for count > 0 && x < width {
					if bicolour {
						out[x+line] = colour2
						bicolour = false
					} else {
						out[x+line] = colour1
						bicolour = true
						count++
					}

					count--
					x++
				}

				break

			case 0xd: /* White */
				n := min(count, width-x)
				seg := out[x+line : x+line+n]
				for i := range seg {
					seg[i] = 0xff
				}
				count -= n
				x += n
				break
			case 0xe: /* Black */
				n := min(count, width-x)
				clear(out[x+line : x+line+n])
				count -= n
				x += n
				break
			default:
				fmt.Printf("bitmap opcode 0x%x\n", opcode)
				return false
			}
		}
	}
	return true
}

// decompress2Pool reuses the intermediate []uint16 buffer across calls to
// decompress2, avoiding a large per-frame allocation.
var decompress2Pool sync.Pool

/* 2 byte bitmap decompress */
func decompress2(output *[]uint8, width, height int, input []uint8, size int) bool {
	needed := width * height

	var out []uint16
	if v := decompress2Pool.Get(); v != nil {
		out = v.([]uint16)
		if cap(out) < needed {
			out = make([]uint16, needed)
		} else {
			out = out[:needed]
		}
	} else {
		out = make([]uint16, needed)
	}
	defer func() { decompress2Pool.Put(out[:cap(out)]) }()

	var (
		prevline, line, count            int
		offset, code                     int
		x                                int = width
		opcode                           int
		lastopcode                       int = -1
		insertmix, bicolour, isfillormix bool
		mixmask, mask                    uint8
		colour1, colour2                 uint16
		mix                              uint16 = 0xffff
		fom_mask                         uint8
	)
	inputLen0 := len(input)

	for len(input) != 0 {
		fom_mask = 0
		code = CVAL(&input)
		opcode = code >> 4
		/* Handle different opcode forms */
		switch opcode {
		case 0xc, 0xd, 0xe:
			opcode -= 6
			count = code & 0xf
			offset = 16
			break
		case 0xf:
			opcode = code & 0xf
			if opcode < 9 {
				count = CVAL(&input)
				count |= CVAL(&input) << 8
			} else {
				count = 1
				if opcode < 0xb {
					count = 8
				}
			}
			offset = 0
			break
		default:
			opcode >>= 1
			count = code & 0x1f
			offset = 32
			break
		}

		/* Handle strange cases for counts */
		if offset != 0 {
			isfillormix = ((opcode == 2) || (opcode == 7))
			if count == 0 {
				if isfillormix {
					count = CVAL(&input) + 1
				} else {
					count = CVAL(&input) + offset
				}
			} else if isfillormix {
				count <<= 3
			}
		}
		/* Read preliminary data */
		switch opcode {
		case 0: /* Fill */
			if (lastopcode == opcode) && !((x == width) && (prevline == 0)) {
				insertmix = true
			}
			break
		case 8: /* Bicolour */
			CVAL2(&input, &colour1)
			CVAL2(&input, &colour2)
			break
		case 3: /* Colour */
			CVAL2(&input, &colour2)
			break
		case 6: /* SetMix/Mix */
			fallthrough
		case 7: /* SetMix/FillOrMix */
			CVAL2(&input, &mix)
			opcode -= 5
			break
		case 9: /* FillOrMix_1 */
			mask = 0x03
			opcode = 0x02
			fom_mask = 3
			break
		case 0x0a: /* FillOrMix_2 */
			mask = 0x05
			opcode = 0x02
			fom_mask = 5
			break
		}
		lastopcode = opcode
		mixmask = 0
		/* Output body */
		for count > 0 {
			if x >= width {
				if height <= 0 {
					rleFailLog("lines exhausted", width, height, inputLen0, inputLen0-len(input))
					return false
				}

				x = 0
				height--
				prevline = line
				line = height * width
			}
			switch opcode {
			case 0: /* Fill */
				if insertmix {
					if prevline == 0 {
						out[x+line] = mix
					} else {
						out[x+line] = out[prevline+x] ^ mix
					}
					insertmix = false
					count--
					x++
				}
				n := min(count, width-x)
				if prevline == 0 {
					clear(out[x+line : x+line+n])
				} else {
					copy(out[x+line:x+line+n], out[prevline+x:prevline+x+n])
				}
				count -= n
				x += n
				break
			case 1: /* Mix */
				n := min(count, width-x)
				if prevline == 0 {
					seg := out[x+line : x+line+n]
					for i := range seg {
						seg[i] = mix
					}
				} else {
					src := out[prevline+x : prevline+x+n]
					dst := out[x+line : x+line+n]
					for i := range dst {
						dst[i] = src[i] ^ mix
					}
				}
				count -= n
				x += n
				break
			case 2: /* Fill or Mix */
				if prevline == 0 {
					for count > 0 && x < width {
						mixmask <<= 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[x+line] = mix
						} else {
							out[x+line] = 0
						}

						count--
						x++
					}
				} else {
					for count > 0 && x < width {
						mixmask = mixmask << 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[x+line] = out[prevline+x] ^ mix
						} else {
							out[x+line] = out[prevline+x]
						}

						count--
						x++
					}
				}
				break
			case 3: /* Colour */
				n := min(count, width-x)
				seg := out[x+line : x+line+n]
				for i := range seg {
					seg[i] = colour2
				}
				count -= n
				x += n
				break
			case 4: /* Copy */
				for count > 0 && x < width {
					n := min(count, width-x)
					if len(input) < n*2 {
						rleFailLog("copy input exhausted", width, height, inputLen0, inputLen0-len(input))
						return false
					}
					copy(out[x+line:x+line+n], unsafe.Slice((*uint16)(unsafe.Pointer(&input[0])), n))
					input = input[n*2:]
					count -= n
					x += n
				}

				break
			case 8: /* Bicolour */
				for count > 0 && x < width {
					if bicolour {
						out[x+line] = colour2
						bicolour = false
					} else {
						out[x+line] = colour1
						bicolour = true
						count++
					}

					count--
					x++
				}

				break
			case 0xd: /* White */
				n2 := min(count, width-x)
				seg2 := out[x+line : x+line+n2]
				for i := range seg2 {
					seg2[i] = 0xffff
				}
				count -= n2
				x += n2
				break
			case 0xe: /* Black */
				n3 := min(count, width-x)
				clear(out[x+line : x+line+n3])
				count -= n3
				x += n3
				break
			default:
				rleFailLog(fmt.Sprintf("bad opcode 0x%x", opcode), width, height, inputLen0, inputLen0-len(input))
				return false
			}
		}
	}
	outBytes := *output
	for i, v := range out {
		outBytes[i*2] = byte(v >> 8)
		outBytes[i*2+1] = byte(v)
	}
	return true
}

// /* 3 byte bitmap decompress */
func decompress3(output *[]uint8, width, height int, input []uint8, size int) bool {
	var (
		prevline, line, count            int
		opcode, offset, code             int
		x                                int = width
		lastopcode                       int = -1
		insertmix, bicolour, isfillormix bool
		mixmask, mask                    uint8
		colour1                          = [3]uint8{0, 0, 0}
		colour2                          = [3]uint8{0, 0, 0}
		mix                              = [3]uint8{0xff, 0xff, 0xff}
		fom_mask                         uint8
	)
	out := *output
	for len(input) != 0 {
		fom_mask = 0
		code = CVAL(&input)
		opcode = code >> 4
		/* Handle different opcode forms */
		switch opcode {
		case 0xc, 0xd, 0xe:
			opcode -= 6
			count = code & 0xf
			offset = 16
			break
		case 0xf:
			opcode = code & 0xf
			if opcode < 9 {
				count = CVAL(&input)
				count |= CVAL(&input) << 8
			} else {
				count = 1
				if opcode < 0xb {
					count = 8
				}
			}
			offset = 0
			break
		default:
			opcode >>= 1
			count = code & 0x1f
			offset = 32
			break
		}

		/* Handle strange cases for counts */
		if offset != 0 {
			isfillormix = ((opcode == 2) || (opcode == 7))
			if count == 0 {
				if isfillormix {
					count = CVAL(&input) + 1
				} else {
					count = CVAL(&input) + offset
				}
			} else if isfillormix {
				count <<= 3
			}
		}
		/* Read preliminary data */
		switch opcode {
		case 0: /* Fill */
			if (lastopcode == opcode) && !((x == width) && (prevline == 0)) {
				insertmix = true
			}
			break
		case 8: /* Bicolour */
			CVAL3(&input, &colour1)
			CVAL3(&input, &colour2)
			break
		case 3: /* Colour */
			CVAL3(&input, &colour2)
			break
		case 6: /* SetMix/Mix */
			fallthrough
		case 7: /* SetMix/FillOrMix */
			CVAL3(&input, &mix)
			opcode -= 5
			break
		case 9: /* FillOrMix_1 */
			mask = 0x03
			opcode = 0x02
			fom_mask = 3
			break
		case 0x0a: /* FillOrMix_2 */
			mask = 0x05
			opcode = 0x02
			fom_mask = 5
			break
		}

		lastopcode = opcode
		mixmask = 0
		/* Output body */
		for count > 0 {
			if x >= width {
				if height <= 0 {
					return false
				}

				x = 0
				height--
				prevline = line
				line = height * width * 3
			}
			switch opcode {
			case 0: /* Fill */
				if insertmix {
					if prevline == 0 {
						out[3*x+line] = mix[0]
						out[3*x+line+1] = mix[1]
						out[3*x+line+2] = mix[2]
					} else {
						out[3*x+line] = out[prevline+3*x] ^ mix[0]
						out[3*x+line+1] = out[prevline+3*x+1] ^ mix[1]
						out[3*x+line+2] = out[prevline+3*x+2] ^ mix[2]
					}
					insertmix = false
					count--
					x++
				}
				n := min(count, width-x)
				if prevline == 0 {
					clear(out[3*x+line : 3*x+line+3*n])
				} else {
					dstBase := 3*x + line
					srcBase := prevline + 3*x
					copy(out[dstBase:dstBase+3*n], out[srcBase:srcBase+3*n])
				}
				count -= n
				x += n
				break
			case 1: /* Mix */
				n := min(count, width-x)
				dst1 := out[3*x+line : 3*x+line+3*n]
				if prevline == 0 {
					// Exponential-doubling copy: O(log n) memcpy calls
					dst1[0], dst1[1], dst1[2] = mix[0], mix[1], mix[2]
					for wrote := 3; wrote < len(dst1); {
						wrote += copy(dst1[wrote:], dst1[:wrote])
					}
				} else {
					src1 := out[prevline+3*x : prevline+3*x+3*n]
					for i := 0; i+2 < len(dst1); i += 3 {
						dst1[i] = src1[i] ^ mix[0]
						dst1[i+1] = src1[i+1] ^ mix[1]
						dst1[i+2] = src1[i+2] ^ mix[2]
					}
				}
				count -= n
				x += n
				break
			case 2: /* Fill or Mix */
				if prevline == 0 {
					base := 3*x + line
					for count > 0 && x < width {
						mixmask = mixmask << 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[base] = mix[0]
							out[base+1] = mix[1]
							out[base+2] = mix[2]
						} else {
							out[base] = 0
							out[base+1] = 0
							out[base+2] = 0
						}
						base += 3
						count--
						x++
					}
				} else {
					base := 3*x + line
					prev := prevline + 3*x
					for count > 0 && x < width {
						mixmask = mixmask << 1
						if mixmask == 0 {
							mask = fom_mask
							if fom_mask == 0 {
								mask = uint8(CVAL(&input))
								mixmask = 1
							}
						}
						if mask&mixmask != 0 {
							out[base] = out[prev] ^ mix[0]
							out[base+1] = out[prev+1] ^ mix[1]
							out[base+2] = out[prev+2] ^ mix[2]
						} else {
							out[base] = out[prev]
							out[base+1] = out[prev+1]
							out[base+2] = out[prev+2]
						}
						base += 3
						prev += 3
						count--
						x++
					}
				}
				break
			case 3: /* Colour */
				n := min(count, width-x)
				seg3 := out[3*x+line : 3*x+line+3*n]
				seg3[0], seg3[1], seg3[2] = colour2[0], colour2[1], colour2[2]
				for wrote := 3; wrote < len(seg3); {
					wrote += copy(seg3[wrote:], seg3[:wrote])
				}
				count -= n
				x += n
				break
			case 4: /* Copy */
				for count > 0 && x < width {
					n := min(count, width-x)
					if len(input) < n*3 {
						return false
					}
					copy(out[3*x+line:3*x+line+n*3], input[:n*3])
					input = input[n*3:]
					count -= n
					x += n
				}
				break
			case 8: /* Bicolour */
				base8 := 3*x + line
				for count > 0 && x < width {
					if bicolour {
						out[base8] = colour2[0]
						out[base8+1] = colour2[1]
						out[base8+2] = colour2[2]
						bicolour = false
					} else {
						out[base8] = colour1[0]
						out[base8+1] = colour1[1]
						out[base8+2] = colour1[2]
						bicolour = true
						count++
					}
					base8 += 3
					count--
					x++
				}
				break
			case 0xd: /* White */
				n3 := min(count, width-x)
				seg3 := out[3*x+line : 3*x+line+3*n3]
				for i := range seg3 {
					seg3[i] = 0xff
				}
				count -= n3
				x += n3
				break
			case 0xe: /* Black */
				n2 := min(count, width-x)
				clear(out[3*x+line : 3*x+line+3*n2])
				count -= n2
				x += n2
				break
			default:
				fmt.Printf("bitmap opcode 0x%x\n", opcode)
				return false
			}
		}
	}

	return true
}

/* decompress a colour plane */
func processPlane(in *[]uint8, width, height int, output *[]uint8, j int) int {
	var (
		indexw   int
		indexh   int
		code     int
		collen   int
		replen   int
		color    uint8
		x        uint8
		revcode  int
		lastline int
		thisline int
	)
	ln := len(*in)
	out := *output // hoist pointer dereference; writes to out[i] affect the underlying array

	lastline = 0
	indexh = 0
	i := 0
	for indexh < height {
		thisline = j + (width * height * 4) - ((indexh + 1) * width * 4)
		color = 0
		indexw = 0
		i = thisline

		if lastline == 0 {
			for indexw < width {
				code = CVAL(in)
				replen = int(code & 0xf)
				collen = int((code >> 4) & 0xf)
				revcode = (replen << 4) | collen
				if (revcode <= 47) && (revcode >= 16) {
					replen = revcode
					collen = 0
				}
				for collen > 0 {
					color = uint8(CVAL(in))
					out[i] = color
					i += 4

					indexw++
					collen--
				}
				for replen > 0 {
					out[i] = color
					i += 4
					indexw++
					replen--
				}
			}
		} else {
			// prevOffset is constant per row: indexw*4+lastline == i+(lastline-thisline)
			// because i == thisline+indexw*4. Pre-computing it eliminates a multiply
			// per pixel in both inner loops.
			prevOffset := lastline - thisline
			for indexw < width {
				code = CVAL(in)
				replen = int(code & 0xf)
				collen = int((code >> 4) & 0xf)
				revcode = (replen << 4) | collen
				if (revcode <= 47) && (revcode >= 16) {
					replen = revcode
					collen = 0
				}
				for collen > 0 {
					x = uint8(CVAL(in))
					if x&1 != 0 {
						x = x >> 1
						x = x + 1
						color = -x
					} else {
						x = x >> 1
						color = x
					}
					x = out[i+prevOffset] + color
					out[i] = x
					i += 4
					indexw++
					collen--
				}
				for replen > 0 {
					x = out[i+prevOffset] + color
					out[i] = x
					i += 4
					indexw++
					replen--
				}
			}
		}
		indexh++
		lastline = thisline
	}
	return ln - len(*in)
}

/* 4 byte bitmap decompress */
func decompress4(output *[]uint8, width, height int, input []uint8, size int) bool {
	var (
		code             int
		onceBytes, total int
	)

	code = CVAL(&input)
	rle := code&0x10 != 0
	noAlpha := code&0x20 != 0

	if !rle {
		return false
	}

	total = 1
	out := *output

	if noAlpha {
		// No alpha plane in the stream; fill alpha channel with 0xFF.
		for i := 3; i < len(out); i += 4 {
			out[i] = 0xFF
		}
	} else {
		onceBytes = processPlane(&input, width, height, output, 3)
		total += onceBytes
	}

	onceBytes = processPlane(&input, width, height, output, 2)
	total += onceBytes

	onceBytes = processPlane(&input, width, height, output, 1)
	total += onceBytes

	onceBytes = processPlane(&input, width, height, output, 0)
	total += onceBytes

	return true
}

// DecompressInto decompresses bitmap data into dst, reusing dst if it has
// sufficient capacity (size = width*height*bpp). If dst is nil or too small
// a new slice is allocated. Returns the (re)used output slice.
func DecompressInto(input []uint8, dst []uint8, width, height int, bpp int) ([]uint8, bool) {
	size := width * height * bpp
	if cap(dst) >= size {
		dst = dst[:size]
	} else {
		dst = make([]uint8, size)
	}
	ok := false
	switch bpp {
	case 1:
		ok = decompress1(&dst, width, height, input, size)
	case 2:
		ok = decompress2(&dst, width, height, input, size)
	case 3:
		ok = decompress3(&dst, width, height, input, size)
	case 4:
		ok = decompress4(&dst, width, height, input, size)
	default:
		fmt.Printf("bpp %d\n", bpp)
	}
	return dst, ok
}

/* main decompress function */
func Decompress(input []uint8, width, height int, bpp int) []uint8 {
	out, _ := DecompressInto(input, nil, width, height, bpp)
	return out
}