package util

import (
	"bytes"
	"fmt"
	"image"
	"image/color"
	"image/draw"
	"image/gif"
	"math"
	"math/rand"
	"time"

	"github.com/openimsdk/tools/errs"
)

// GenerateCaptchaImageFromCode 根据给定的验证码生成动态GIF图片
// 返回GIF图片的字节数组
func GenerateCaptchaImageFromCode(code string) (imgBytes []byte, err error) {
	// 图片尺寸 - 宽度280px，高度50px
	width := 280
	height := 50

	// GIF动画参数
	frameCount := 12 // 12帧动画，更流畅
	delay := 8       // 每帧延迟8（单位：1/100秒）

	// 创建统一的调色板（所有帧共享）
	sharedPalette := createSharedPalette()

	// 创建GIF
	g := &gif.GIF{
		Image: []*image.Paletted{},
		Delay: []int{},
	}

	// 使用固定种子保证数字位置基本一致
	baseSeed := time.Now().UnixNano()

	// 预生成每帧的基础数据（干扰线、圆圈等的位置）
	noiseData := generateNoiseData(baseSeed, frameCount, width, height)

	// 生成每一帧
	for i := 0; i < frameCount; i++ {
		frame := image.NewRGBA(image.Rect(0, 0, width, height))

		// 设置背景色（浅灰色，稍微模糊）
		bgColor := color.RGBA{235, 235, 235, 255}
		draw.Draw(frame, frame.Bounds(), &image.Uniform{bgColor}, image.Point{}, draw.Src)

		// 使用随机数生成器（每帧略有不同）
		rng := rand.New(rand.NewSource(baseSeed + int64(i*1000)))

		// 绘制丰富的背景 - 添加渐变背景
		drawGradientBackground(frame, rng, width, height)

		// 绘制移动的背景圆圈（类似bubbles效果）
		drawAnimatedCircles(frame, noiseData, i, width, height)

		// 绘制额外的背景形状（矩形、椭圆等）
		drawAdditionalShapes(frame, rng, width, height)

		// 添加动态干扰线（位置会变化）
		drawAnimatedNoiseLines(frame, noiseData, i, width, height)

		// 决定是否显示数字（每隔几帧就隐藏数字，造成闪烁效果）
		// 例如：0,1,2显示数字，3,4隐藏，5,6显示，7,8隐藏，9,10显示，11隐藏
		showNumbers := (i % 3) != 2 // 每3帧中有2帧显示数字，1帧隐藏

		if showNumbers {
			// 绘制验证码文字（位置会抖动）
			drawNumbersWithWiggle(frame, code, rng, width, height, i, frameCount)
		}

		// 添加动态干扰点（位置会变化）
		drawAnimatedNoiseDots(frame, noiseData, i, width, height)

		// 添加模糊噪点 - 增加噪点密度
		addBlurNoise(frame, rng)

		// 添加额外的随机干扰线
		drawRandomNoiseLines(frame, rng, width, height)

		// 转换为调色板图像（GIF需要）
		// 使用统一的调色板
		paletted := convertToPalettedWithPalette(frame, sharedPalette)

		if paletted == nil {
			return nil, errs.New(fmt.Sprintf("failed to convert frame %d to paletted", i+1))
		}

		g.Image = append(g.Image, paletted)
		g.Delay = append(g.Delay, delay)
	}

	// 编码为GIF
	var buf bytes.Buffer
	err = gif.EncodeAll(&buf, g)
	if err != nil {
		return nil, errs.WrapMsg(err, "encode gif failed")
	}

	// 验证数据不为空
	if buf.Len() == 0 {
		return nil, errs.New("generated gif data is empty")
	}

	return buf.Bytes(), nil
}

// NoiseData 存储每帧的干扰数据
type NoiseData struct {
	lines   [][]LineData
	circles [][]CircleData
	dots    [][]DotData
}

type LineData struct {
	x1, y1, x2, y2 int
	color          color.RGBA
	thickness      int
}

type CircleData struct {
	x, y, radius int
	color        color.RGBA
}

type DotData struct {
	x, y  int
	color color.RGBA
	size  int
}

// generateNoiseData 预生成所有帧的干扰数据
func generateNoiseData(baseSeed int64, frameCount, width, height int) *NoiseData {
	rng := rand.New(rand.NewSource(baseSeed))

	data := &NoiseData{
		lines:   make([][]LineData, frameCount),
		circles: make([][]CircleData, frameCount),
		dots:    make([][]DotData, frameCount),
	}

	// 生成干扰线数据（每帧位置略有变化）- 增加干扰线数量
	lineCount := 20 // 从10增加到20
	for frame := 0; frame < frameCount; frame++ {
		lines := make([]LineData, lineCount)
		for i := 0; i < lineCount; i++ {
			// 基础位置
			baseX1 := rng.Intn(width)
			baseY1 := rng.Intn(height)
			baseX2 := rng.Intn(width)
			baseY2 := rng.Intn(height)

			// 每帧添加偏移，形成移动效果
			offsetX := int(float64(frame) * 2.5 * float64(rng.Float64()-0.5))
			offsetY := int(float64(frame) * 2.5 * float64(rng.Float64()-0.5))

			lines[i] = LineData{
				x1: clampCoord(baseX1+offsetX, width),
				y1: clampCoord(baseY1+offsetY, height),
				x2: clampCoord(baseX2+offsetX, width),
				y2: clampCoord(baseY2+offsetY, height),
				color: color.RGBA{
					uint8(150 + rng.Intn(80)), // 更宽的颜色范围
					uint8(150 + rng.Intn(80)),
					uint8(150 + rng.Intn(80)),
					200 + uint8(rng.Intn(55)), // 半透明
				},
				thickness: 1 + rng.Intn(3), // 增加线条粗细变化
			}
		}
		data.lines[frame] = lines
	}

	// 生成背景圆圈数据（移动的bubbles）- 增加圆圈数量和大小变化
	circleCount := 15 // 从8增加到15
	for frame := 0; frame < frameCount; frame++ {
		circles := make([]CircleData, circleCount)
		for i := 0; i < circleCount; i++ {
			// 基础位置
			baseX := rng.Intn(width*2) - width/2
			baseY := rng.Intn(height*2) - height/2

			// 每帧移动
			moveX := int(float64(frame) * 1.5 * float64(rng.Float64()-0.5))
			moveY := int(float64(frame) * 1.5 * float64(rng.Float64()-0.5))

			circles[i] = CircleData{
				x:      clampCoord(baseX+moveX, width),
				y:      clampCoord(baseY+moveY, height),
				radius: 8 + rng.Intn(35), // 更大的半径范围（8-43）
				color: color.RGBA{
					uint8(180 + rng.Intn(50)), // 更宽的颜色范围
					uint8(180 + rng.Intn(50)),
					uint8(180 + rng.Intn(50)),
					150 + uint8(rng.Intn(105)), // 更宽的透明度范围
				},
			}
		}
		data.circles[frame] = circles
	}

	// 生成干扰点数据（闪烁效果）- 增加点数量
	dotCount := 200 // 从100增加到200
	for frame := 0; frame < frameCount; frame++ {
		dots := make([]DotData, dotCount)
		for i := 0; i < dotCount; i++ {
			x := rng.Intn(width)
			y := rng.Intn(height)

			// 某些点会在某些帧消失（闪烁效果）
			visible := frame%3 != i%3 || rng.Float64() > 0.3

			dots[i] = DotData{
				x: x,
				y: y,
				color: color.RGBA{
					uint8(120 + rng.Intn(110)), // 更宽的颜色范围
					uint8(120 + rng.Intn(110)),
					uint8(120 + rng.Intn(110)),
					func() uint8 {
						if visible {
							return 200 + uint8(rng.Intn(55))
						}
						return uint8(80 + rng.Intn(120))
					}(),
				},
				size: 1 + rng.Intn(3), // 更大的点尺寸（1-3）
			}
		}
		data.dots[frame] = dots
	}

	return data
}

func clampCoord(v, max int) int {
	if v < 0 {
		return 0
	}
	if v >= max {
		return max - 1
	}
	return v
}

// createSharedPalette 创建统一的调色板（所有帧共享）
func createSharedPalette() color.Palette {
	palette := make(color.Palette, 256)

	// 添加灰色渐变（0-239）
	for i := 0; i < 240; i++ {
		val := uint8(i * 255 / 240)
		palette[i] = color.RGBA{val, val, val, 255}
	}

	// 添加常用颜色（240-255）
	colorMap := map[int]color.RGBA{
		240: {30, 30, 30, 255},
		241: {60, 60, 60, 255},
		242: {50, 50, 50, 255},
		243: {40, 40, 80, 255},
		244: {80, 40, 40, 255},
		245: {50, 80, 50, 255},
		246: {100, 30, 30, 255},
		247: {30, 100, 30, 255},
		248: {30, 30, 100, 255},
		249: {140, 140, 140, 255},
		250: {160, 160, 160, 255},
		251: {180, 180, 180, 255},
		252: {200, 200, 200, 255},
		253: {220, 220, 220, 255},
		254: {235, 235, 235, 255},
		255: {255, 255, 255, 255},
	}

	for idx, col := range colorMap {
		if idx < 256 {
			palette[idx] = col
		}
	}

	return palette
}

// convertToPalettedWithPalette 使用指定调色板将RGBA图像转换为Paletted图像
func convertToPalettedWithPalette(img *image.RGBA, palette color.Palette) *image.Paletted {
	bounds := img.Bounds()

	// 创建Paletted图像
	paletted := image.NewPaletted(bounds, palette)

	// 转换：找到最接近的调色板颜色
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			c := img.At(x, y)
			// 找到调色板中最接近的颜色
			idx := findClosestColor(c, palette)
			paletted.SetColorIndex(x, y, uint8(idx))
		}
	}

	return paletted
}

// findClosestColor 在调色板中找到最接近的颜色索引
func findClosestColor(c color.Color, palette color.Palette) int {
	r, g, b, _ := c.RGBA()
	minDist := uint32(^uint32(0))
	bestIdx := 0

	for i := 0; i < len(palette); i++ {
		cr, cg, cb, _ := palette[i].RGBA()
		// 计算欧氏距离
		dr := (r >> 8) - (cr >> 8)
		dg := (g >> 8) - (cg >> 8)
		db := (b >> 8) - (cb >> 8)
		dist := dr*dr + dg*dg + db*db

		if dist < minDist {
			minDist = dist
			bestIdx = i
		}
	}

	return bestIdx
}

// drawGradientBackground 绘制渐变背景
func drawGradientBackground(img *image.RGBA, rng *rand.Rand, width, height int) {
	// 随机选择渐变方向
	vertical := rng.Intn(2) == 0

	if vertical {
		// 垂直渐变
		startR := uint8(220 + rng.Intn(35))
		startG := uint8(220 + rng.Intn(35))
		startB := uint8(220 + rng.Intn(35))
		endR := uint8(200 + rng.Intn(55))
		endG := uint8(200 + rng.Intn(55))
		endB := uint8(200 + rng.Intn(55))

		for y := 0; y < height; y++ {
			ratio := float64(y) / float64(height)
			r := uint8(float64(startR)*(1-ratio) + float64(endR)*ratio)
			g := uint8(float64(startG)*(1-ratio) + float64(endG)*ratio)
			b := uint8(float64(startB)*(1-ratio) + float64(endB)*ratio)

			for x := 0; x < width; x++ {
				img.Set(x, y, color.RGBA{r, g, b, 255})
			}
		}
	} else {
		// 水平渐变
		startR := uint8(220 + rng.Intn(35))
		startG := uint8(220 + rng.Intn(35))
		startB := uint8(220 + rng.Intn(35))
		endR := uint8(200 + rng.Intn(55))
		endG := uint8(200 + rng.Intn(55))
		endB := uint8(200 + rng.Intn(55))

		for x := 0; x < width; x++ {
			ratio := float64(x) / float64(width)
			r := uint8(float64(startR)*(1-ratio) + float64(endR)*ratio)
			g := uint8(float64(startG)*(1-ratio) + float64(endG)*ratio)
			b := uint8(float64(startB)*(1-ratio) + float64(endB)*ratio)

			for y := 0; y < height; y++ {
				img.Set(x, y, color.RGBA{r, g, b, 255})
			}
		}
	}
}

// drawAdditionalShapes 绘制额外的背景形状
func drawAdditionalShapes(img *image.RGBA, rng *rand.Rand, width, height int) {
	shapeCount := 5 + rng.Intn(8) // 5-12个形状

	for i := 0; i < shapeCount; i++ {
		shapeType := rng.Intn(3)
		x := rng.Intn(width)
		y := rng.Intn(height)

		// 随机颜色（浅色，半透明）
		col := color.RGBA{
			uint8(190 + rng.Intn(45)),
			uint8(190 + rng.Intn(45)),
			uint8(190 + rng.Intn(45)),
			uint8(100 + rng.Intn(100)),
		}

		switch shapeType {
		case 0: // 矩形
			w := 15 + rng.Intn(40)
			h := 15 + rng.Intn(40)
			drawRect(img, x, y, w, h, col)
		case 1: // 椭圆
			rx := 10 + rng.Intn(25)
			ry := 10 + rng.Intn(25)
			drawEllipse(img, x, y, rx, ry, col)
		case 2: // 小圆圈
			radius := 5 + rng.Intn(15)
			drawCircle(img, x, y, radius, col)
		}
	}
}

// drawRect 绘制矩形
func drawRect(img *image.RGBA, x, y, w, h int, c color.Color) {
	for dy := 0; dy < h && y+dy < img.Bounds().Dy(); dy++ {
		if y+dy < 0 {
			continue
		}
		for dx := 0; dx < w && x+dx < img.Bounds().Dx(); dx++ {
			if x+dx < 0 {
				continue
			}
			r, g, b, _ := img.At(x+dx, y+dy).RGBA()
			cr, cg, cb, ca := c.RGBA()

			alpha := uint32(ca >> 8)
			invAlpha := 255 - alpha

			newR := uint8(((uint32(r>>8) * invAlpha) + (uint32(cr>>8) * alpha)) / 255)
			newG := uint8(((uint32(g>>8) * invAlpha) + (uint32(cg>>8) * alpha)) / 255)
			newB := uint8(((uint32(b>>8) * invAlpha) + (uint32(cb>>8) * alpha)) / 255)

			img.Set(x+dx, y+dy, color.RGBA{newR, newG, newB, 255})
		}
	}
}

// drawEllipse 绘制椭圆
func drawEllipse(img *image.RGBA, cx, cy, rx, ry int, c color.Color) {
	for y := -ry; y <= ry; y++ {
		for x := -rx; x <= rx; x++ {
			// 椭圆方程: (x/rx)^2 + (y/ry)^2 <= 1
			if float64(x*x)/(float64(rx*rx))+float64(y*y)/(float64(ry*ry)) <= 1.0 {
				px := cx + x
				py := cy + y
				if px >= 0 && px < img.Bounds().Dx() && py >= 0 && py < img.Bounds().Dy() {
					r, g, b, _ := img.At(px, py).RGBA()
					cr, cg, cb, ca := c.RGBA()

					alpha := uint32(ca >> 8)
					invAlpha := 255 - alpha

					newR := uint8(((uint32(r>>8) * invAlpha) + (uint32(cr>>8) * alpha)) / 255)
					newG := uint8(((uint32(g>>8) * invAlpha) + (uint32(cg>>8) * alpha)) / 255)
					newB := uint8(((uint32(b>>8) * invAlpha) + (uint32(cb>>8) * alpha)) / 255)

					img.Set(px, py, color.RGBA{newR, newG, newB, 255})
				}
			}
		}
	}
}

// drawRandomNoiseLines 绘制额外的随机干扰线
func drawRandomNoiseLines(img *image.RGBA, rng *rand.Rand, width, height int) {
	lineCount := 8 + rng.Intn(12) // 8-19条随机线

	for i := 0; i < lineCount; i++ {
		x1 := rng.Intn(width)
		y1 := rng.Intn(height)
		x2 := rng.Intn(width)
		y2 := rng.Intn(height)

		col := color.RGBA{
			uint8(160 + rng.Intn(70)),
			uint8(160 + rng.Intn(70)),
			uint8(160 + rng.Intn(70)),
			uint8(150 + rng.Intn(105)),
		}

		thickness := 1 + rng.Intn(2)
		drawThickLine(img, x1, y1, x2, y2, col, thickness)
	}
}

// addBlurNoise 添加模糊噪点效果 - 增加噪点密度
func addBlurNoise(img *image.RGBA, rng *rand.Rand) {
	// 增加随机噪点，使图片看起来更模糊（从1/50增加到1/30）
	for i := 0; i < img.Bounds().Dx()*img.Bounds().Dy()/30; i++ {
		x := rng.Intn(img.Bounds().Dx())
		y := rng.Intn(img.Bounds().Dy())

		// 获取当前像素
		r, g, b, _ := img.At(x, y).RGBA()
		rVal := uint8(r >> 8)
		gVal := uint8(g >> 8)
		bVal := uint8(b >> 8)

		// 添加轻微随机变化
		noise := int8(rng.Intn(21) - 10) // -10 到 10
		newR := clamp(int(rVal) + int(noise))
		newG := clamp(int(gVal) + int(noise))
		newB := clamp(int(bVal) + int(noise))

		img.Set(x, y, color.RGBA{uint8(newR), uint8(newG), uint8(newB), 255})
	}
}

func clamp(v int) int {
	if v < 0 {
		return 0
	}
	if v > 255 {
		return 255
	}
	return v
}

// drawNumbersWithWiggle 绘制数字，带抖动效果（类似wiggle）- 增加随机分布
func drawNumbersWithWiggle(img *image.RGBA, code string, rng *rand.Rand, width, height int, frameIndex, totalFrames int) {
	// 根据宽度和高度调整字符大小（适配新的280x50尺寸）
	charWidth := width / 18      // 约15（280宽度时为15.5）
	charHeight := height * 4 / 5 // 约40（50高度时为40）
	charSpacing := width / 25    // 字符间距，稍微减小以适应更小的空间

	// 基础起始位置 - 更随机化
	baseStartX := width/12 + rng.Intn(width/20) // 随机起始X位置
	baseStartY := height/8 + rng.Intn(height/6) // 随机起始Y位置，允许上下移动（适配50px高度）

	// 数字颜色（深色但稍微模糊，降低对比度）
	colors := []color.RGBA{
		{30, 30, 30, 255}, // 深灰（不是纯黑，更模糊）
		{60, 60, 60, 255}, // 中灰
		{40, 40, 80, 255}, // 深蓝（模糊）
		{80, 40, 40, 255}, // 深红（模糊）
		{50, 80, 50, 255}, // 深绿（模糊）
		{50, 50, 50, 255}, // 灰色
	}

	// 计算抖动偏移（使用正弦波创建平滑的抖动效果）
	wiggleX := float64(frameIndex) / float64(totalFrames) * 2 * 3.14159
	wiggleY := float64(frameIndex) / float64(totalFrames) * 2 * 3.14159 * 1.3

	for i, char := range code {
		// 随机选择颜色（偏深色但不要太黑，更模糊）
		charColor := colors[rng.Intn(len(colors))]

		// 基础位置 - 每个字符位置增加随机偏移
		charRandomOffsetX := rng.Intn(width/25) - width/50  // ±5像素的随机偏移
		charRandomOffsetY := rng.Intn(height/8) - height/16 // ±3像素的随机偏移

		baseX := baseStartX + i*(charWidth+charSpacing) + charRandomOffsetX
		baseY := baseStartY + charRandomOffsetY

		// 添加抖动效果（每个字符的抖动幅度和相位不同）- 增加抖动幅度
		charWiggleX := math.Sin(wiggleX+float64(i)*0.8) * 4.0 // 从2.0增加到4.0
		charWiggleY := math.Sin(wiggleY+float64(i)*1.1) * 4.0 // 从2.0增加到4.0

		// 额外的随机偏移 - 增加随机范围
		xOffset := int(charWiggleX) + rng.Intn(7) - 3 // 从±1增加到±3
		yOffset := int(charWiggleY) + rng.Intn(7) - 3 // 从±1增加到±3

		x := baseX + xOffset
		y := baseY + yOffset

		// 确保不超出边界
		if x < 0 {
			x = 0
		}
		if x+charWidth > width {
			x = width - charWidth
		}
		if y < 0 {
			y = 0
		}
		if y+charHeight > height {
			y = height - charHeight
		}

		// 绘制数字（使用简化版本：绘制矩形块模拟数字）
		drawSimpleNumber(img, byte(char), x, y, charWidth, charHeight, charColor)
	}
}

// drawSimpleNumber 绘制单个数字（简化版本，根据尺寸缩放）
func drawSimpleNumber(img *image.RGBA, digit byte, x, y, width, height int, c color.Color) {
	digitValue := int(digit - '0')

	// 缩放比例（相对于原始16x24大小）
	scaleX := float64(width) / 16.0
	scaleY := float64(height) / 24.0

	// 根据数字绘制不同的小矩形块来模拟数字形状（原始坐标）
	basePatterns := [][]struct{ x, y, w, h int }{
		// 0
		{{2, 2, 14, 2}, {2, 2, 2, 20}, {14, 2, 2, 20}, {2, 20, 14, 2}},
		// 1
		{{8, 2, 2, 20}},
		// 2
		{{2, 2, 12, 2}, {12, 2, 2, 10}, {2, 10, 12, 2}, {2, 10, 2, 10}, {2, 20, 12, 2}},
		// 3
		{{2, 2, 12, 2}, {12, 2, 2, 20}, {2, 10, 10, 2}, {2, 20, 12, 2}},
		// 4
		{{2, 2, 2, 10}, {2, 10, 10, 2}, {12, 2, 2, 20}},
		// 5
		{{2, 2, 12, 2}, {2, 2, 2, 10}, {2, 10, 12, 2}, {12, 10, 2, 10}, {2, 20, 12, 2}},
		// 6
		{{2, 2, 12, 2}, {2, 2, 2, 20}, {12, 10, 2, 10}, {2, 10, 10, 2}, {2, 20, 12, 2}},
		// 7
		{{2, 2, 12, 2}, {12, 2, 2, 20}},
		// 8
		{{2, 2, 12, 2}, {2, 2, 2, 10}, {12, 2, 2, 10}, {2, 10, 12, 2}, {2, 10, 2, 10}, {12, 10, 2, 10}, {2, 20, 12, 2}},
		// 9
		{{2, 2, 12, 2}, {2, 2, 2, 10}, {12, 2, 2, 20}, {2, 10, 10, 2}},
	}

	if digitValue >= 0 && digitValue <= 9 {
		pattern := basePatterns[digitValue]
		for _, p := range pattern {
			// 缩放坐标
			px := int(float64(p.x) * scaleX)
			py := int(float64(p.y) * scaleY)
			pw := int(float64(p.w) * scaleX)
			ph := int(float64(p.h) * scaleY)

			// 确保最小尺寸
			if pw < 1 {
				pw = 1
			}
			if ph < 1 {
				ph = 1
			}

			rect := image.Rect(x+px, y+py, x+px+pw, y+py+ph)
			draw.Draw(img, rect, &image.Uniform{c}, image.Point{}, draw.Over)
		}
	}
}

// drawAnimatedCircles 绘制移动的背景圆圈
func drawAnimatedCircles(img *image.RGBA, data *NoiseData, frameIndex int, width, height int) {
	if frameIndex >= len(data.circles) {
		return
	}

	for _, circle := range data.circles[frameIndex] {
		drawCircle(img, circle.x, circle.y, circle.radius, circle.color)
	}
}

// drawCircle 绘制圆圈
func drawCircle(img *image.RGBA, cx, cy, radius int, c color.Color) {
	for y := -radius; y <= radius; y++ {
		for x := -radius; x <= radius; x++ {
			if x*x+y*y <= radius*radius {
				px := cx + x
				py := cy + y
				if px >= 0 && px < img.Bounds().Dx() && py >= 0 && py < img.Bounds().Dy() {
					// 获取当前像素并混合颜色
					r, g, b, _ := img.At(px, py).RGBA()
					cr, cg, cb, ca := c.RGBA()

					// Alpha混合
					alpha := uint32(ca >> 8)
					invAlpha := 255 - alpha

					newR := uint8(((uint32(r>>8) * invAlpha) + (uint32(cr>>8) * alpha)) / 255)
					newG := uint8(((uint32(g>>8) * invAlpha) + (uint32(cg>>8) * alpha)) / 255)
					newB := uint8(((uint32(b>>8) * invAlpha) + (uint32(cb>>8) * alpha)) / 255)

					img.Set(px, py, color.RGBA{newR, newG, newB, 255})
				}
			}
		}
	}
}

// drawAnimatedNoiseLines 绘制动态干扰线
func drawAnimatedNoiseLines(img *image.RGBA, data *NoiseData, frameIndex int, width, height int) {
	if frameIndex >= len(data.lines) {
		return
	}

	for _, line := range data.lines[frameIndex] {
		drawThickLine(img, line.x1, line.y1, line.x2, line.y2, line.color, line.thickness)
	}
}

// drawAnimatedNoiseDots 绘制动态干扰点
func drawAnimatedNoiseDots(img *image.RGBA, data *NoiseData, frameIndex int, width, height int) {
	if frameIndex >= len(data.dots) {
		return
	}

	for _, dot := range data.dots[frameIndex] {
		if dot.color.A < 50 {
			continue // 跳过几乎透明的点
		}

		// 绘制点（可能是1x1或2x2）
		for dx := 0; dx < dot.size && dot.x+dx < width; dx++ {
			for dy := 0; dy < dot.size && dot.y+dy < height; dy++ {
				img.Set(dot.x+dx, dot.y+dy, dot.color)
			}
		}
	}
}

// drawThickLine 绘制粗线
func drawThickLine(img *image.RGBA, x1, y1, x2, y2 int, c color.Color, thickness int) {
	for i := 0; i < thickness; i++ {
		offsetX := i - thickness/2
		offsetY := i - thickness/2
		drawLine(img, x1+offsetX, y1+offsetY, x2+offsetX, y2+offsetY, c)
	}
}

// drawLine 绘制直线（Bresenham算法简化版）
func drawLine(img *image.RGBA, x1, y1, x2, y2 int, c color.Color) {
	dx := abs(x2 - x1)
	dy := abs(y2 - y1)
	sx := 1
	if x1 > x2 {
		sx = -1
	}
	sy := 1
	if y1 > y2 {
		sy = -1
	}
	err := dx - dy

	x, y := x1, y1
	for {
		if x >= 0 && x < img.Bounds().Dx() && y >= 0 && y < img.Bounds().Dy() {
			img.Set(x, y, c)
		}
		if x == x2 && y == y2 {
			break
		}
		e2 := 2 * err
		if e2 > -dy {
			err -= dy
			x += sx
		}
		if e2 < dx {
			err += dx
			y += sy
		}
	}
}

// addNoiseDots 添加干扰点（更多更密集）
func addNoiseDots(img *image.RGBA, rng *rand.Rand, count int) {
	for i := 0; i < count; i++ {
		x := rng.Intn(img.Bounds().Dx())
		y := rng.Intn(img.Bounds().Dy())

		// 随机颜色（浅色，增加模糊效果）
		brightness := 140 + rng.Intn(90) // 140-230之间
		dotColor := color.RGBA{
			uint8(brightness + rng.Intn(30) - 15),
			uint8(brightness + rng.Intn(30) - 15),
			uint8(brightness + rng.Intn(30) - 15),
			255,
		}

		// 有时绘制小区域而不是单个点（更密集的干扰）
		if rng.Intn(3) == 0 {
			// 绘制2x2的小块
			for dx := 0; dx < 2 && x+dx < img.Bounds().Dx(); dx++ {
				for dy := 0; dy < 2 && y+dy < img.Bounds().Dy(); dy++ {
					img.Set(x+dx, y+dy, dotColor)
				}
			}
		} else {
			img.Set(x, y, dotColor)
		}
	}
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}