package imglib

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"image/png"
	"math"
	"os"
	"path/filepath"
	"strings"

	"github.com/boombuler/barcode"
	"github.com/boombuler/barcode/code128"
	"github.com/boombuler/barcode/code39"
	"github.com/boombuler/barcode/ean"
	"github.com/disintegration/imaging"
	"github.com/fogleman/gg"
	"github.com/golang/freetype"
	"github.com/golang/freetype/truetype"
	"github.com/makiuchi-d/gozxing"
	"github.com/makiuchi-d/gozxing/qrcode"
	"github.com/nfnt/resize"
	"golang.org/x/image/draw"
	"golang.org/x/image/math/fixed"
)

// ======================= 配置结构体 =======================

// Config 白色占比检测配置
type Config struct {
	OutputDir          string
	FileName           string
	MatchDir           string
	UnmatchDir         string
	EqualHeightDir     string
	WhiteDir           string
	WhiteBorderPngDir  string
	WhiteHeightZoomDir string
	CropDir            string
	MinWhitePct        float64
	MaxWhitePct        float64
	Extensions         []string
}

// ======================= 纯白占比检测 =======================

// CalculateWhitePercentage 计算图片中纯白色像素占比
func CalculateWhitePercentage(input ImageInput) (float64, error) {
	img, _, err := input.Load()
	if err != nil {
		return 0, err
	}
	return calculateWhitePercentageFromImage(img)
}

func calculateWhitePercentageFromImage(img image.Image) (float64, error) {
	bounds := img.Bounds()
	totalPixels := bounds.Dx() * bounds.Dy()
	if totalPixels == 0 {
		return 0, nil
	}
	whitePixels := 0
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r, g, b, _ := img.At(x, y).RGBA()
			if r == 0xFFFF && g == 0xFFFF && b == 0xFFFF {
				whitePixels++
			}
		}
	}
	return float64(whitePixels) / float64(totalPixels), nil
}

// ======================= 白底居中合成 =======================

// CreateWhiteBottomCenteredImage 将图片居中放置到指定尺寸的白色背景上
func CreateWhiteBottomCenteredImage(input ImageInput, width, height int) (*image.RGBA, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	dst := image.NewRGBA(image.Rect(0, 0, width, height))
	bgColor := color.RGBA{R: 255, G: 255, B: 255, A: 255}
	draw.Draw(dst, dst.Bounds(), &image.Uniform{C: bgColor}, image.Point{}, draw.Src)

	srcBounds := img.Bounds()
	x := (width - srcBounds.Dx()) / 2
	y := (height - srcBounds.Dy()) / 2
	draw.Draw(dst, image.Rect(x, y, x+srcBounds.Dx(), y+srcBounds.Dy()), img, image.Point{}, draw.Over)
	return dst, nil
}

// ======================= 等比例高度缩放 =======================

// ResizeToHeight 按目标高度等比例缩放图片（Lanczos3）
func ResizeToHeight(input ImageInput, targetHeight int) (image.Image, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	bounds := img.Bounds()
	ratio := float64(targetHeight) / float64(bounds.Dy())
	targetWidth := uint(float64(bounds.Dx()) * ratio)
	return resize.Resize(targetWidth, uint(targetHeight), img, resize.Lanczos3), nil
}

// ======================= 去白边 =======================

// RemoveWhiteBorder 去掉图片白色边框并返回 PNG 格式图片
func RemoveWhiteBorder(input ImageInput) (image.Image, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	converter := newImageToPNGConverter(240, 0, &color.RGBA{R: 255, G: 255, B: 255, A: 255}, nil, false, png.DefaultCompression, 95)
	return converter.convertToPNG(img, true), nil
}

// RemoveWhiteBorderWithConfig 带自定义配置的去白边
func RemoveWhiteBorderWithConfig(input ImageInput, threshold, margin int) (image.Image, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	converter := newImageToPNGConverter(threshold, margin, &color.RGBA{R: 255, G: 255, B: 255, A: 255}, nil, false, png.DefaultCompression, 95)
	return converter.convertToPNG(img, true), nil
}

// ======================= 自适应尺寸缩放 =======================

// ResizeToDimensions 按目标宽高等比例缩放图片（自实现 Lanczos3）
func ResizeToDimensions(input ImageInput, dstWidth, dstHeight int) (*image.RGBA, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	return resizeImageOptimized(img, dstWidth, dstHeight), nil
}

// ======================= 图片裁切 =======================

// Crop 按指定区域裁切图片
func Crop(input ImageInput, x, y, width, height int) (*image.RGBA, error) {
	img, _, err := input.Load()
	if err != nil {
		return nil, err
	}
	return basicCrop(img, x, y, width, height)
}

func basicCrop(src image.Image, x, y, width, height int) (*image.RGBA, error) {
	srcBounds := src.Bounds()
	srcWidth := srcBounds.Dx()
	srcHeight := srcBounds.Dy()

	if x < 0 || y < 0 || width <= 0 || height <= 0 {
		return nil, fmt.Errorf("invalid crop parameters: x=%d, y=%d, width=%d, height=%d", x, y, width, height)
	}
	if x >= srcWidth || y >= srcHeight {
		return nil, fmt.Errorf("crop start point (%d, %d) is outside image bounds (%dx%d)", x, y, srcWidth, srcHeight)
	}
	if x+width > srcWidth {
		width = srcWidth - x
	}
	if y+height > srcHeight {
		height = srcHeight - y
	}

	cropped := image.NewRGBA(image.Rect(0, 0, width, height))
	for cy := 0; cy < height; cy++ {
		for cx := 0; cx < width; cx++ {
			cropped.Set(cx, cy, src.At(x+cx, y+cy))
		}
	}
	return cropped, nil
}

// ======================= Lanczos3 缩放算法 =======================

func resizeImageOptimized(src image.Image, dstWidth, dstHeight int) *image.RGBA {
	srcBounds := src.Bounds()
	srcWidth := srcBounds.Dx()
	srcHeight := srcBounds.Dy()

	dst := image.NewRGBA(image.Rect(0, 0, dstWidth, dstHeight))
	xScale := float64(srcWidth) / float64(dstWidth)
	yScale := float64(srcHeight) / float64(dstHeight)
	radius := 3.0

	xWeights := make([][]float64, dstWidth)
	xIndices := make([][]int, dstWidth)

	for x := 0; x < dstWidth; x++ {
		srcX := float64(x) * xScale
		startX := int(math.Max(0, math.Floor(srcX-radius+0.5)))
		endX := int(math.Min(float64(srcWidth-1), math.Floor(srcX+radius)))

		weights := make([]float64, 0, endX-startX+1)
		indices := make([]int, 0, endX-startX+1)
		for sx := startX; sx <= endX; sx++ {
			xDist := float64(sx) + 0.5 - srcX
			weight := lanczos3(xDist)
			if weight != 0 {
				weights = append(weights, weight)
				indices = append(indices, sx)
			}
		}
		xWeights[x] = weights
		xIndices[x] = indices
	}

	for y := 0; y < dstHeight; y++ {
		srcY := float64(y) * yScale
		startY := int(math.Max(0, math.Floor(srcY-radius+0.5)))
		endY := int(math.Min(float64(srcHeight-1), math.Floor(srcY+radius)))

		yWeights := make([]float64, 0, endY-startY+1)
		yIndices := make([]int, 0, endY-startY+1)
		for sy := startY; sy <= endY; sy++ {
			yDist := float64(sy) + 0.5 - srcY
			weight := lanczos3(yDist)
			if weight != 0 {
				yWeights = append(yWeights, weight)
				yIndices = append(yIndices, sy)
			}
		}

		for x := 0; x < dstWidth; x++ {
			var rSum, gSum, bSum, aSum, weightSum float64
			for i, sy := range yIndices {
				yWeight := yWeights[i]
				for j, sx := range xIndices[x] {
					xWeight := xWeights[x][j]
					weight := xWeight * yWeight

					srcColor := src.At(sx+srcBounds.Min.X, sy+srcBounds.Min.Y)
					r, g, b, a := srcColor.RGBA()
					rSum += float64(r>>8) * weight
					gSum += float64(g>>8) * weight
					bSum += float64(b>>8) * weight
					aSum += float64(a>>8) * weight
					weightSum += weight
				}
			}
			if weightSum == 0 {
				weightSum = 1
			}
			r := clamp(rSum / weightSum)
			g := clamp(gSum / weightSum)
			b := clamp(bSum / weightSum)
			a := clamp(aSum / weightSum)
			dst.SetRGBA(x, y, color.RGBA{r, g, b, a})
		}
	}
	return dst
}

func lanczos3(x float64) float64 {
	if x == 0 {
		return 1.0
	}
	if x < -3 || x > 3 {
		return 0.0
	}
	return (3 * math.Sin(math.Pi*x) * math.Sin(math.Pi*x/3)) / (math.Pi * math.Pi * x * x)
}

func clamp(v float64) uint8 {
	if v < 0 {
		return 0
	}
	if v > 255 {
		return 255
	}
	return uint8(v + 0.5)
}

// ======================= 去白边辅助 =======================

type ImageToPNGConverter struct {
	Threshold        int
	Margin           int
	BgColor          color.RGBA
	DetectColor      *color.RGBA
	KeepTransparent  bool
	PNGCompressLevel png.CompressionLevel
	Quality          int
}

func newImageToPNGConverter(threshold, margin int, bgColor, detectColor *color.RGBA,
	keepTransparent bool, compressLevel png.CompressionLevel, quality int) *ImageToPNGConverter {
	bg := color.RGBA{R: 255, G: 255, B: 255, A: 255}
	if bgColor != nil {
		bg = *bgColor
	}
	return &ImageToPNGConverter{
		Threshold:        threshold,
		Margin:           margin,
		BgColor:          bg,
		DetectColor:      detectColor,
		KeepTransparent:  keepTransparent,
		PNGCompressLevel: compressLevel,
		Quality:          quality,
	}
}

func (c *ImageToPNGConverter) convertToPNG(img image.Image, addBackground bool) image.Image {
	trimmed := c.trimImage(img)
	_, hasAlpha := trimmed.(*image.NRGBA)
	if !hasAlpha {
		_, hasAlpha = trimmed.(*image.RGBA)
	}

	if hasAlpha {
		if c.KeepTransparent {
			return trimmed
		} else if addBackground {
			bg := image.NewRGBA(trimmed.Bounds())
			draw.Draw(bg, bg.Bounds(), &image.Uniform{C: c.BgColor}, image.Point{}, draw.Src)
			draw.Draw(bg, bg.Bounds(), trimmed, trimmed.Bounds().Min, draw.Over)
			return bg
		}
	} else {
		if c.KeepTransparent {
			rgba := image.NewRGBA(trimmed.Bounds())
			draw.Draw(rgba, rgba.Bounds(), trimmed, trimmed.Bounds().Min, draw.Src)
			return rgba
		}
		return trimmed
	}
	return trimmed
}

func (c *ImageToPNGConverter) trimImage(img image.Image) image.Image {
	return imaging.Crop(img, c.findBorders(img))
}

func (c *ImageToPNGConverter) findBorders(img image.Image) image.Rectangle {
	bounds := img.Bounds()
	width := bounds.Dx()
	height := bounds.Dy()

	_, hasAlpha := img.(*image.NRGBA)
	if !hasAlpha {
		_, hasAlpha = img.(*image.RGBA)
	}

	left := width
	top := height
	right := 0
	bottom := 0

	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			pixel := img.At(x, y)
			if !c.isBackgroundColor(pixel, hasAlpha) {
				if x < left {
					left = x
				}
				if x > right {
					right = x
				}
				if y < top {
					top = y
				}
				if y > bottom {
					bottom = y
				}
			}
		}
	}

	if left > right || top > bottom {
		return bounds
	}

	left = max(bounds.Min.X, left-c.Margin)
	top = max(bounds.Min.Y, top-c.Margin)
	right = min(bounds.Max.X, right+c.Margin+1)
	bottom = min(bounds.Max.Y, bottom+c.Margin+1)

	return image.Rect(left, top, right, bottom)
}

func (c *ImageToPNGConverter) isBackgroundColor(pixel color.Color, hasAlpha bool) bool {
	r, g, b, a := pixel.RGBA()
	r8 := uint8(r >> 8)
	g8 := uint8(g >> 8)
	b8 := uint8(b >> 8)
	a8 := uint8(a >> 8)

	if hasAlpha && a8 < 25 {
		return true
	}

	if c.DetectColor != nil {
		dr, dg, db, _ := c.DetectColor.RGBA()
		dr8 := uint8(dr >> 8)
		dg8 := uint8(dg >> 8)
		db8 := uint8(db >> 8)
		threshold8 := uint8(255 - c.Threshold)
		return absDiff(r8, dr8) <= threshold8 &&
			absDiff(g8, dg8) <= threshold8 &&
			absDiff(b8, db8) <= threshold8
	}

	threshold8 := uint8(c.Threshold)
	return r8 >= threshold8 &&
		g8 >= threshold8 &&
		b8 >= threshold8
}

func absDiff(a, b uint8) uint8 {
	if a > b {
		return a - b
	}
	return b - a
}

// ======================= 二维码识别 =======================

// ScanQRCode 识别图片中的二维码
func ScanQRCode(input ImageInput) (string, error) {
	img, _, err := input.Load()
	if err != nil {
		return "", err
	}
	return scanQRCodeFromImage(img)
}

func scanQRCodeFromImage(img image.Image) (string, error) {
	bmp, err := gozxing.NewBinaryBitmapFromImage(img)
	if err != nil {
		return "", fmt.Errorf("创建位图失败: %v", err)
	}
	reader := qrcode.NewQRCodeReader()
	result, err := reader.Decode(bmp, nil)
	if err != nil {
		return "", analyzeQRCodeError(err)
	}
	return result.GetText(), nil
}

func analyzeQRCodeError(err error) error {
	if err == nil {
		return nil
	}
	switch e := err.(type) {
	case gozxing.ChecksumException:
		return fmt.Errorf("二维码校验失败（可能部分损坏或被遮挡）: %v", e)
	case gozxing.FormatException:
		return fmt.Errorf("二维码格式错误: %v", e)
	case gozxing.NotFoundException:
		return fmt.Errorf("未找到二维码: %v", e)
	default:
		return fmt.Errorf("解码失败: %v", err)
	}
}

// ScanQRCodeWithBounds 识别二维码并返回裁剪后的二维码区域图片
func ScanQRCodeWithBounds(input ImageInput) (string, *image.RGBA, error) {
	img, _, err := input.Load()
	if err != nil {
		return "", nil, err
	}

	bmp, err := gozxing.NewBinaryBitmapFromImage(img)
	if err != nil {
		return "", nil, fmt.Errorf("创建位图失败: %v", err)
	}
	reader := qrcode.NewQRCodeReader()
	result, err := reader.Decode(bmp, nil)
	if err != nil {
		return "", nil, analyzeQRCodeError(err)
	}

	text := result.GetText()
	points := result.GetResultPoints()
	if len(points) < 3 {
		return text, nil, nil
	}

	minX, minY := int(points[0].GetX()), int(points[0].GetY())
	maxX, maxY := minX, minY
	for _, point := range points {
		x, y := int(point.GetX()), int(point.GetY())
		if x < minX {
			minX = x
		}
		if x > maxX {
			maxX = x
		}
		if y < minY {
			minY = y
		}
		if y > maxY {
			maxY = y
		}
	}

	margin := 10
	minX -= margin
	minY -= margin
	maxX += margin
	maxY += margin

	bounds := img.Bounds()
	if minX < bounds.Min.X {
		minX = bounds.Min.X
	}
	if minY < bounds.Min.Y {
		minY = bounds.Min.Y
	}
	if maxX > bounds.Max.X {
		maxX = bounds.Max.X
	}
	if maxY > bounds.Max.Y {
		maxY = bounds.Max.Y
	}

	qrRect := image.Rect(minX, minY, maxX, maxY)
	qrImg := image.NewRGBA(qrRect)
	draw.Draw(qrImg, qrImg.Bounds(), img, qrRect.Min, draw.Src)

	return text, qrImg, nil
}

// ======================= 二维码生成 =======================

// GenerateQRCode 生成二维码图片
func GenerateQRCode(content string, width, height int) (*image.RGBA, error) {
	writer := qrcode.NewQRCodeWriter()
	hints := make(map[gozxing.EncodeHintType]interface{})
	hints[gozxing.EncodeHintType_ERROR_CORRECTION] = "H"
	hints[gozxing.EncodeHintType_CHARACTER_SET] = "UTF-8"
	hints[gozxing.EncodeHintType_MARGIN] = 4

	bitMatrix, err := writer.Encode(content, gozxing.BarcodeFormat_QR_CODE, width, height, hints)
	if err != nil {
		return nil, fmt.Errorf("生成二维码失败: %v", err)
	}

	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			if bitMatrix.Get(x, y) {
				img.Set(x, y, color.Black)
			} else {
				img.Set(x, y, color.White)
			}
		}
	}
	return img, nil
}

// ======================= 条形码生成 =======================

const (
	Code128 = "code128"
	EAN13   = "ean13"
	Code39  = "code39"
)

// GenerateBarcode 生成条形码图片（底部含文字标签）
func GenerateBarcode(barcodeType, content string) (image.Image, error) {
	switch barcodeType {
	case Code128:
		return generateCode128(content)
	case EAN13:
		return generateEAN13(content)
	case Code39:
		return generateCode39(content)
	}
	return nil, fmt.Errorf("不支持的条形码类型: %s", barcodeType)
}

func generateCode128(content string) (image.Image, error) {
	code, err := code128.Encode(content)
	if err != nil {
		return nil, fmt.Errorf("创建条形码失败: %v", err)
	}
	scaledCode, err := barcode.Scale(code, 250, 85)
	if err != nil {
		return nil, fmt.Errorf("缩放条形码失败: %v", err)
	}
	return addBarcodeLabel(scaledCode, content), nil
}

func generateEAN13(content string) (image.Image, error) {
	code, err := ean.Encode(content)
	if err != nil {
		return nil, fmt.Errorf("创建条形码失败: %v", err)
	}
	scaledCode, err := barcode.Scale(code, 250, 85)
	if err != nil {
		return nil, fmt.Errorf("缩放条形码失败: %v", err)
	}
	return addBarcodeLabel(scaledCode, content), nil
}

func generateCode39(content string) (image.Image, error) {
	code, err := code39.Encode(content, true, true)
	if err != nil {
		return nil, fmt.Errorf("创建条形码失败: %v", err)
	}
	scaledCode, err := barcode.Scale(code, 250, 85)
	if err != nil {
		return nil, fmt.Errorf("缩放条形码失败: %v", err)
	}
	return addBarcodeLabel(scaledCode, content), nil
}

func addBarcodeLabel(barcodeImg image.Image, label string) image.Image {
	imgWidth := 250
	imgHeight := 110
	dc := gg.NewContext(imgWidth, imgHeight)
	dc.SetColor(color.White)
	dc.Clear()
	dc.DrawImage(barcodeImg, 0, 10)

	if err := dc.LoadFontFace("Arial.ttf", 14); err != nil {
		_ = dc.LoadFontFace("/System/Library/Fonts/Helvetica.ttc", 14)
	}

	dc.SetColor(color.Black)
	textY := 105.0
	textWidth, _ := dc.MeasureString(label)
	textX := (float64(imgWidth) - textWidth) / 2
	dc.DrawString(label, textX, textY)
	return dc.Image()
}

// ======================= 中文文字图片 =======================

// CreateChineseTextImage 将中文文本渲染为图片，超出部分显示省略号
func CreateChineseTextImage(text string, width, height int, fontSize float64) (*image.RGBA, error) {
	f, err := GetFont()
	if err != nil {
		return nil, err
	}

	img := image.NewRGBA(image.Rect(0, 0, width, height))
	white := color.RGBA{255, 255, 255, 255}
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			img.Set(x, y, white)
		}
	}

	c := freetype.NewContext()
	c.SetDPI(72)
	c.SetFont(f)
	c.SetFontSize(fontSize)
	c.SetClip(img.Bounds())
	c.SetDst(img)
	c.SetSrc(image.NewUniform(color.Black))

	availableWidth := width - 100
	charsPerLine := int(float64(availableWidth) / fontSize * 1.7)
	if charsPerLine < 10 {
		charsPerLine = 10
	}

	lineSpacing := int(c.PointToFixed(fontSize*1.5) >> 6)
	topMargin := 50 + int(c.PointToFixed(fontSize)>>6)
	bottomMargin := 50
	maxLines := (height - topMargin - bottomMargin) / lineSpacing
	if maxLines <= 0 {
		maxLines = 1
	}

	allLines, _ := simpleAutoWrap(text, charsPerLine)
	hasMore := len(allLines) > maxLines
	displayLines := allLines
	if hasMore {
		displayLines = allLines[:maxLines-1]
		lastLine := allLines[maxLines-1]
		lastLineChars := 0
		var truncatedLine strings.Builder
		for _, r := range lastLine {
			charWidth := 1
			if r >= 0x4E00 && r <= 0x9FFF {
				charWidth = 2
			} else if r >= 0x3000 && r <= 0x303F {
				charWidth = 2
			}
			if lastLineChars+charWidth > charsPerLine-3 {
				break
			}
			truncatedLine.WriteRune(r)
			lastLineChars += charWidth
		}
		displayLines = append(displayLines, truncatedLine.String()+" ...")
	} else {
		displayLines = allLines
		if len(displayLines) > maxLines {
			displayLines = displayLines[:maxLines]
		}
	}

	startX := 50
	startY := topMargin
	pt := freetype.Pt(startX, startY)
	for i, line := range displayLines {
		if i*lineSpacing > height-bottomMargin {
			break
		}
		if _, err := c.DrawString(line, pt); err != nil {
			return nil, fmt.Errorf("绘制文字失败: %v", err)
		}
		pt.Y += c.PointToFixed(fontSize * 1.5)
	}
	return img, nil
}

// DrawChineseInfo 在现有 RGBA 图片上绘制书名、作者、出版社信息
func DrawChineseInfo(img *image.RGBA, title, author, publisher string) error {
	fontObj, err := GetFont()
	if err != nil {
		return err
	}

	c := freetype.NewContext()
	c.SetDPI(72)
	c.SetFont(fontObj)
	c.SetSrc(image.NewUniform(color.Black))
	c.SetClip(img.Bounds())
	c.SetDst(img)

	maxWidth := 400

	c.SetFontSize(45)
	titleLines := wrapText(title, fontObj, 45, maxWidth)
	if len(titleLines) > 3 {
		titleLines = titleLines[:3]
	}
	titleY := 250
	titleLineHeight := 60
	for i, line := range titleLines {
		lineWidth := calculateStringWidth(line, fontObj, 45)
		pt := freetype.Pt((800-int(lineWidth))/2+30, titleY+i*titleLineHeight)
		if _, err := c.DrawString(line, pt); err != nil {
			return fmt.Errorf("绘制书名失败: %v", err)
		}
	}

	c.SetFontSize(28)
	authorLines := wrapText(author, fontObj, 28, maxWidth)
	if len(authorLines) > 2 {
		authorLines = authorLines[:2]
	}
	authorY := 420
	authorLineHeight := 40
	for i, line := range authorLines {
		lineWidth := calculateStringWidth(line, fontObj, 28)
		pt := freetype.Pt((800-int(lineWidth))/2+30, authorY+i*authorLineHeight)
		if _, err := c.DrawString(line, pt); err != nil {
			return fmt.Errorf("绘制作者失败: %v", err)
		}
	}

	c.SetFontSize(18)
	publisherLines := wrapText(publisher, fontObj, 18, maxWidth)
	if len(publisherLines) > 1 {
		publisherLines = publisherLines[:1]
	}
	publisherY := 700
	publisherLineHeight := 30
	for i, line := range publisherLines {
		lineWidth := calculateStringWidth(line, fontObj, 18)
		pt := freetype.Pt((800-int(lineWidth))/2+30, publisherY+i*publisherLineHeight)
		if _, err := c.DrawString(line, pt); err != nil {
			return fmt.Errorf("绘制出版社失败: %v", err)
		}
	}

	return drawBottomRightText(img, fontObj)
}

func drawBottomRightText(img *image.RGBA, fontObj *truetype.Font) error {
	line1 := "此为实例图片"
	line2 := "联系客服获取实图"
	fontSize := 8.0
	rightMargin := 10
	bottomMargin := 10
	lineHeight := int(fontSize * 1.5)

	c := freetype.NewContext()
	c.SetDPI(72)
	c.SetFont(fontObj)
	c.SetClip(img.Bounds())
	c.SetDst(img)
	c.SetFontSize(fontSize)

	line2Width := calculateStringWidth(line2, fontObj, fontSize)
	x2 := img.Bounds().Dx() - line2Width - rightMargin
	y2 := img.Bounds().Dy() - bottomMargin

	line1Width := calculateStringWidth(line1, fontObj, fontSize)
	x1 := img.Bounds().Dx() - line1Width - rightMargin
	y1 := y2 - lineHeight

	strokeRadius := 1.0
	strokeColor := color.RGBA{128, 128, 128, 150}
	c.SetSrc(image.NewUniform(strokeColor))

	offsets := []struct{ dx, dy float64 }{
		{-strokeRadius, -strokeRadius}, {0, -strokeRadius}, {strokeRadius, -strokeRadius},
		{-strokeRadius, 0}, {strokeRadius, 0},
		{-strokeRadius, strokeRadius}, {0, strokeRadius}, {strokeRadius, strokeRadius},
	}
	for _, offset := range offsets {
		pt2 := freetype.Pt(int(float64(x2)+offset.dx), int(float64(y2)+offset.dy))
		if _, err := c.DrawString(line2, pt2); err != nil {
			return err
		}
		pt1 := freetype.Pt(int(float64(x1)+offset.dx), int(float64(y1)+offset.dy))
		if _, err := c.DrawString(line1, pt1); err != nil {
			return err
		}
	}

	textColor := color.RGBA{255, 255, 255, 255}
	c.SetSrc(image.NewUniform(textColor))
	pt2 := freetype.Pt(x2, y2)
	if _, err := c.DrawString(line2, pt2); err != nil {
		return err
	}
	pt1 := freetype.Pt(x1, y1)
	if _, err := c.DrawString(line1, pt1); err != nil {
		return err
	}
	return nil
}

func simpleAutoWrap(text string, maxCharsPerLine int) ([]string, bool) {
	var lines []string
	var currentLine strings.Builder
	charCount := 0

	for _, r := range text {
		if r == '\n' {
			if currentLine.Len() > 0 {
				lines = append(lines, currentLine.String())
				currentLine.Reset()
				charCount = 0
			}
			continue
		}
		charWidth := 1
		if r >= 0x4E00 && r <= 0x9FFF {
			charWidth = 2
		} else if r >= 0x3000 && r <= 0x303F {
			charWidth = 2
		}
		if charCount+charWidth > maxCharsPerLine && currentLine.Len() > 0 {
			lines = append(lines, currentLine.String())
			currentLine.Reset()
			charCount = 0
		}
		currentLine.WriteRune(r)
		charCount += charWidth
	}
	if currentLine.Len() > 0 {
		lines = append(lines, currentLine.String())
	}
	return lines, false
}

func wrapText(text string, fontObj *truetype.Font, fontSize float64, maxWidth int) []string {
	var lines []string
	var currentLine strings.Builder
	currentLine.Grow(len(text))
	var currentWidth int

	for _, ch := range text {
		charWidth := calculateStringWidth(string(ch), fontObj, fontSize)
		if ch == '\n' {
			if currentLine.Len() > 0 {
				lines = append(lines, currentLine.String())
				currentLine.Reset()
			}
			currentWidth = 0
			continue
		}
		if currentWidth+charWidth > maxWidth && currentLine.Len() > 0 {
			lines = append(lines, currentLine.String())
			currentLine.Reset()
			currentLine.WriteRune(ch)
			currentWidth = charWidth
		} else {
			currentLine.WriteRune(ch)
			currentWidth += charWidth
		}
	}
	if currentLine.Len() > 0 {
		lines = append(lines, currentLine.String())
	}
	return lines
}

func calculateStringWidth(text string, fontObj *truetype.Font, fontSize float64) int {
	width := 0
	for _, ch := range text {
		idx := fontObj.Index(ch)
		advance := fontObj.HMetric(fixed.Int26_6(fontSize), idx).AdvanceWidth
		width += int(advance)
	}
	return width
}

// ======================= 水印处理 =======================

// WatermarkConfig 水印配置
type WatermarkConfig struct {
	SourceImage  ImageInput  // 源图片输入
	WatermarkImg ImageInput  // 水印图片输入
	Opacity      float64     // 不透明度 (0.0-1.0)
	Position     string      // 位置: center, top-left, top-right, bottom-left, bottom-right, tile
	TileSpacing  int         // 平铺间距
	Scale        float64     // 水印缩放比例 (0.0-1.0)
	Rotation     float64     // 旋转角度（预留）
	XOffset      int         // X轴偏移
	YOffset      int         // Y轴偏移
	Timeout      int         // 下载超时（秒）
	OutputFormat string      // 输出格式: "jpeg", "png", "auto"
	JPEGQuality  int         // JPEG质量 (1-100)
	TargetWidth  int         // 目标宽度
	TargetHeight int         // 目标高度
	ResizeMode   string      // 缩放模式: "fit", "fill", "stretch"
}

// ApplyWatermark 对图片应用水印
func ApplyWatermark(config WatermarkConfig) (*image.RGBA, error) {
	srcImg, _, err := config.SourceImage.Load()
	if err != nil {
		return nil, fmt.Errorf("加载源图片失败: %v", err)
	}

	watermarkImg, _, err := config.WatermarkImg.Load()
	if err != nil {
		return nil, fmt.Errorf("加载水印图片失败: %v", err)
	}

	watermarkBounds := watermarkImg.Bounds()
	dst := image.NewRGBA(watermarkBounds)

	srcBounds := srcImg.Bounds()
	x := (watermarkBounds.Dx() - srcBounds.Dx()) / 2
	y := (watermarkBounds.Dy() - srcBounds.Dy()) / 2
	draw.Draw(dst, image.Rect(x, y, x+srcBounds.Dx(), y+srcBounds.Dy()), srcImg, image.Point{}, draw.Src)

	if err := applyWatermarkToImage(dst, watermarkImg, config); err != nil {
		return nil, err
	}
	return dst, nil
}

func applyWatermarkToImage(dst *image.RGBA, watermark image.Image, config WatermarkConfig) error {
	watermark = scaleWatermarkImage(watermark, config.Scale)
	switch config.Position {
	case "tile":
		drawTileWatermark(dst, watermark, config)
	default:
		drawSingleWatermark(dst, watermark, config)
	}
	return nil
}

func scaleWatermarkImage(watermark image.Image, scale float64) image.Image {
	if scale <= 0 || scale >= 1 {
		return watermark
	}
	bounds := watermark.Bounds()
	newWidth := uint(float64(bounds.Dx()) * scale)
	newHeight := uint(float64(bounds.Dy()) * scale)
	if newWidth > 0 && newHeight > 0 {
		return resize.Resize(newWidth, newHeight, watermark, resize.Lanczos3)
	}
	return watermark
}

func drawSingleWatermark(dst *image.RGBA, watermark image.Image, config WatermarkConfig) {
	bounds := dst.Bounds()
	wb := watermark.Bounds()
	ww := wb.Dx()
	wh := wb.Dy()

	var x, y int
	switch config.Position {
	case "center":
		x = (bounds.Dx()-ww)/2 + config.XOffset
		y = (bounds.Dy()-wh)/2 + config.YOffset
	case "top-left":
		x = config.XOffset
		y = config.YOffset
	case "top-right":
		x = bounds.Dx() - ww - config.XOffset
		y = config.YOffset
	case "bottom-left":
		x = config.XOffset
		y = bounds.Dy() - wh - config.YOffset
	case "bottom-right":
		x = bounds.Dx() - ww - config.XOffset
		y = bounds.Dy() - wh - config.YOffset
	default:
		x = (bounds.Dx()-ww)/2 + config.XOffset
		y = (bounds.Dy()-wh)/2 + config.YOffset
	}
	x = max(0, min(x, bounds.Dx()-ww))
	y = max(0, min(y, bounds.Dy()-wh))

	drawWatermarkWithOpacity(dst, watermark, x, y, config.Opacity)
}

func drawTileWatermark(dst *image.RGBA, watermark image.Image, config WatermarkConfig) {
	bounds := dst.Bounds()
	wb := watermark.Bounds()
	ww := wb.Dx()
	wh := wb.Dy()

	spacing := config.TileSpacing
	if spacing < 0 {
		spacing = 0
	}

	stepX := ww + spacing
	stepY := wh + spacing
	startX := (bounds.Dx() % stepX) / 2
	startY := (bounds.Dy() % stepY) / 2

	for y := startY; y < bounds.Dy(); y += stepY {
		for x := startX; x < bounds.Dx(); x += stepX {
			drawWatermarkWithOpacity(dst, watermark, x, y, config.Opacity)
		}
	}
}

func drawWatermarkWithOpacity(dst *image.RGBA, watermark image.Image, x, y int, opacity float64) {
	if opacity < 0 {
		opacity = 0
	}
	if opacity > 1 {
		opacity = 1
	}

	wb := watermark.Bounds()
	for wy := 0; wy < wb.Dy(); wy++ {
		for wx := 0; wx < wb.Dx(); wx++ {
			dx := x + wx
			dy := y + wy
			if dx < 0 || dx >= dst.Bounds().Dx() || dy < 0 || dy >= dst.Bounds().Dy() {
				continue
			}

			wColor := watermark.At(wx, wy)
			wr, wg, wb, wa := wColor.RGBA()
			if wa > 0 {
				wr8 := uint8(wr >> 8)
				wg8 := uint8(wg >> 8)
				wb8 := uint8(wb >> 8)
				wa8 := uint8(wa >> 8)

				dstColor := dst.At(dx, dy)
				dr, dg, db, _ := dstColor.RGBA()
				dr8 := uint8(dr >> 8)
				dg8 := uint8(dg >> 8)
				db8 := uint8(db >> 8)

				alpha := float64(wa8) / 255.0 * opacity
				r := uint8(float64(dr8)*(1-alpha) + float64(wr8)*alpha)
				g := uint8(float64(dg8)*(1-alpha) + float64(wg8)*alpha)
				b := uint8(float64(db8)*(1-alpha) + float64(wb8)*alpha)
				dst.Set(dx, dy, color.RGBA{r, g, b, 255})
			}
		}
	}
}

// ======================= 输出辅助 =======================

// EncodeToBytes 将图片编码为字节数组
func EncodeToBytes(img image.Image, format string, quality int) ([]byte, error) {
	var buf bytes.Buffer
	switch strings.ToLower(format) {
	case "jpeg", "jpg":
		if quality <= 0 || quality > 100 {
			quality = 95
		}
		if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil {
			return nil, fmt.Errorf("JPEG编码失败: %v", err)
		}
	case "png":
		if err := png.Encode(&buf, img); err != nil {
			return nil, fmt.Errorf("PNG编码失败: %v", err)
		}
	default:
		if err := png.Encode(&buf, img); err != nil {
			return nil, fmt.Errorf("PNG编码失败: %v", err)
		}
	}
	return buf.Bytes(), nil
}

// EncodeToBase64 将图片编码为带前缀的 Base64 字符串
func EncodeToBase64(img image.Image, format string, quality int) (string, error) {
	data, err := EncodeToBytes(img, format, quality)
	if err != nil {
		return "", err
	}
	var prefix string
	switch strings.ToLower(format) {
	case "jpeg", "jpg":
		prefix = "data:image/jpeg;base64,"
	case "png":
		prefix = "data:image/png;base64,"
	default:
		prefix = "data:image/jpeg;base64,"
	}
	return prefix + base64.StdEncoding.EncodeToString(data), nil
}

// SaveToFile 将图片保存到文件
func SaveToFile(img image.Image, path string) error {
	outFile, err := os.Create(path)
	if err != nil {
		return err
	}
	defer outFile.Close()

	ext := strings.ToLower(filepath.Ext(path))
	switch ext {
	case ".jpg", ".jpeg":
		return jpeg.Encode(outFile, img, &jpeg.Options{Quality: 95})
	case ".png":
		return png.Encode(outFile, img)
	default:
		return png.Encode(outFile, img)
	}
}

// SaveJPEG 将图片保存为 JPEG 文件
func SaveJPEG(img image.Image, path string, quality int) error {
	outFile, err := os.Create(path)
	if err != nil {
		return err
	}
	defer outFile.Close()
	if quality <= 0 || quality > 100 {
		quality = 95
	}
	return jpeg.Encode(outFile, img, &jpeg.Options{Quality: quality})
}

// SavePNG 将图片保存为 PNG 文件
func SavePNG(img image.Image, path string) error {
	outFile, err := os.Create(path)
	if err != nil {
		return err
	}
	defer outFile.Close()
	return png.Encode(outFile, img)
}

// ======================= JSON 辅助（兼容原有 C 接口） =======================

// WatermarkConfigJSON 兼容原有 WatermarkConfig JSON 配置
type WatermarkConfigJSON struct {
	SourceImageURL  string  `json:"source_image_url"`
	WatermarkURL    string  `json:"watermark_url"`
	WatermarkBase64 string  `json:"watermark_base64"`
	Opacity         float64 `json:"opacity"`
	Position        string  `json:"position"`
	TileSpacing     int     `json:"tile_spacing"`
	Scale           float64 `json:"scale"`
	Rotation        float64 `json:"rotation"`
	XOffset         int     `json:"x_offset"`
	YOffset         int     `json:"y_offset"`
	Timeout         int     `json:"timeout"`
	OutputFormat    string  `json:"output_format"`
	JPEGQuality     int     `json:"jpeg_quality"`
	TargetWidth     int     `json:"target_width"`
	TargetHeight    int     `json:"target_height"`
	ResizeMode      string  `json:"resize_mode"`
}

// ApplyWatermarkFromJSON 从 JSON 配置应用水印（兼容原有接口）
func ApplyWatermarkFromJSON(jsonStr string) ([]byte, string, error) {
	var cfg WatermarkConfigJSON
	if err := json.Unmarshal([]byte(jsonStr), &cfg); err != nil {
		return nil, "", fmt.Errorf("解析配置失败: %v", err)
	}

	wmCfg := WatermarkConfig{
		SourceImage:  ImageInput{URL: cfg.SourceImageURL},
		WatermarkImg: ImageInput{URL: cfg.WatermarkURL, Base64: cfg.WatermarkBase64},
		Opacity:      cfg.Opacity,
		Position:     cfg.Position,
		TileSpacing:  cfg.TileSpacing,
		Scale:        cfg.Scale,
		Rotation:     cfg.Rotation,
		XOffset:      cfg.XOffset,
		YOffset:      cfg.YOffset,
		Timeout:      cfg.Timeout,
		OutputFormat: cfg.OutputFormat,
		JPEGQuality:  cfg.JPEGQuality,
		TargetWidth:  cfg.TargetWidth,
		TargetHeight: cfg.TargetHeight,
		ResizeMode:   cfg.ResizeMode,
	}

	dst, err := ApplyWatermark(wmCfg)
	if err != nil {
		return nil, "", err
	}

	// 按目标尺寸缩放
	finalImg := resizeOutputImage(dst, wmCfg)

	outputFormat := cfg.OutputFormat
	if outputFormat == "" || outputFormat == "auto" {
		outputFormat = "jpeg"
	}

	imgBytes, err := EncodeToBytes(finalImg, outputFormat, cfg.JPEGQuality)
	if err != nil {
		return nil, "", err
	}
	return imgBytes, outputFormat, nil
}

func resizeOutputImage(img image.Image, config WatermarkConfig) image.Image {
	if config.TargetWidth <= 0 && config.TargetHeight <= 0 {
		return img
	}

	srcBounds := img.Bounds()
	srcW := srcBounds.Dx()
	srcH := srcBounds.Dy()

	targetW := config.TargetWidth
	targetH := config.TargetHeight
	if targetW <= 0 {
		targetW = int(float64(targetH) * float64(srcW) / float64(srcH))
	}
	if targetH <= 0 {
		targetH = int(float64(targetW) * float64(srcH) / float64(srcW))
	}

	switch config.ResizeMode {
	case "fit":
		return resizeFit(img, srcW, srcH, targetW, targetH)
	case "fill":
		return resizeFill(img, srcW, srcH, targetW, targetH)
	case "stretch":
		return resize.Resize(uint(targetW), uint(targetH), img, resize.Lanczos3)
	default:
		return resize.Resize(uint(targetW), uint(targetH), img, resize.Lanczos3)
	}
}

func resizeFit(img image.Image, srcW, srcH, targetW, targetH int) image.Image {
	scaleX := float64(targetW) / float64(srcW)
	scaleY := float64(targetH) / float64(srcH)
	scale := math.Min(scaleX, scaleY)

	newW := int(float64(srcW) * scale)
	newH := int(float64(srcH) * scale)

	scaled := resize.Resize(uint(newW), uint(newH), img, resize.Lanczos3)

	dst := image.NewRGBA(image.Rect(0, 0, targetW, targetH))
	draw.Draw(dst, dst.Bounds(), &image.Uniform{C: color.White}, image.Point{}, draw.Src)

	x := (targetW - newW) / 2
	y := (targetH - newH) / 2
	draw.Draw(dst, image.Rect(x, y, x+newW, y+newH), scaled, image.Point{}, draw.Over)
	return dst
}

func resizeFill(img image.Image, srcW, srcH, targetW, targetH int) image.Image {
	scaleX := float64(targetW) / float64(srcW)
	scaleY := float64(targetH) / float64(srcH)
	scale := math.Max(scaleX, scaleY)

	newW := int(float64(srcW) * scale)
	newH := int(float64(srcH) * scale)

	scaled := resize.Resize(uint(newW), uint(newH), img, resize.Lanczos3)

	cropX := (newW - targetW) / 2
	cropY := (newH - targetH) / 2

	dst := image.NewRGBA(image.Rect(0, 0, targetW, targetH))
	draw.Draw(dst, dst.Bounds(), scaled, image.Point{X: cropX, Y: cropY}, draw.Src)
	return dst
}