package services

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

	"github.com/disintegration/imaging"
	_ "golang.org/x/image/webp"
)

// supportedFormats lists formats that imaging.Open() can handle
var supportedFormats = map[string]bool{
	".jpg":  true,
	".jpeg": true,
	".png":  true,
	".gif":  true,
	".bmp":  true,
	".tiff": true,
	".tif":  true,
	".webp": true,
}

func (s *ImageService) checkFormat(filePath string) error {
	ext := strings.ToLower(filepath.Ext(filePath))
	if ext == ".ico" {
		return fmt.Errorf("ICO 格式暂不支持，请先转换为 PNG 或 JPG 格式")
	}
	if !supportedFormats[ext] {
		return fmt.Errorf("不支持的图片格式: %s", ext)
	}
	return nil
}

type ImageService struct{}

func NewImageService() *ImageService {
	return &ImageService{}
}

type ImageInfo struct {
	Width    int    `json:"width"`
	Height   int    `json:"height"`
	Format   string `json:"format"`
	FilePath string `json:"filePath"`
	Size     int64  `json:"size"`
}

func (s *ImageService) GetImageInfo(filePath string) (*ImageInfo, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("打开图片文件失败: %v", err)
	}
	defer file.Close()

	config, format, err := image.DecodeConfig(file)
	if err != nil {
		return nil, fmt.Errorf("解码图片配置失败: %v", err)
	}

	fileInfo, err := os.Stat(filePath)
	if err != nil {
		return nil, fmt.Errorf("获取文件信息失败: %v", err)
	}

	return &ImageInfo{
		Width:    config.Width,
		Height:   config.Height,
		Format:   format,
		FilePath: filePath,
		Size:     fileInfo.Size(),
	}, nil
}

func (s *ImageService) GetImageBase64(filePath string) (string, error) {
	data, err := os.ReadFile(filePath)
	if err != nil {
		return "", err
	}

	ext := strings.ToLower(filepath.Ext(filePath))
	mimeType := "image/png"
	switch ext {
	case ".jpg", ".jpeg":
		mimeType = "image/jpeg"
	case ".gif":
		mimeType = "image/gif"
	case ".bmp":
		mimeType = "image/bmp"
	case ".webp":
		mimeType = "image/webp"
	case ".ico":
		mimeType = "image/x-icon"
	}

	return "data:" + mimeType + ";base64," + base64.StdEncoding.EncodeToString(data), nil
}

func (s *ImageService) ConvertFormat(inputPath, outputPath, format string, quality int) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = ChangeExtension(inputPath, "."+format)
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	switch strings.ToLower(format) {
	case "jpeg", "jpg":
		if quality <= 0 || quality > 100 {
			quality = 85
		}
		err = imaging.Save(img, outputPath, imaging.JPEGQuality(quality))
	case "png":
		err = imaging.Save(img, outputPath, imaging.PNGCompressionLevel(png.BestCompression))
	case "gif":
		err = imaging.Save(img, outputPath, imaging.GIFNumColors(256))
	case "bmp":
		err = imaging.Save(img, outputPath)
	case "tiff":
		err = imaging.Save(img, outputPath)
	case "ico":
		err = s.ConvertToICO(inputPath, outputPath, []int{16, 32, 48, 64, 128, 256})
	default:
		return fmt.Errorf("不支持的图片格式: %s", format)
	}

	if err != nil {
		return fmt.Errorf("保存图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) ConvertToICO(inputPath, outputPath string, sizes []int) error {
	if outputPath == "" {
		outputPath = ChangeExtension(inputPath, ".ico")
	}

	srcImg, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	var images []image.Image
	for _, size := range sizes {
		resized := imaging.Resize(srcImg, size, size, imaging.Lanczos)
		images = append(images, resized)
	}

	return encodeICO(outputPath, images)
}

func encodeICO(outputPath string, images []image.Image) error {
	f, err := os.Create(outputPath)
	if err != nil {
		return err
	}
	defer f.Close()

	var pngDataBuffers [][]byte
	for _, img := range images {
		buf := new(bytes.Buffer)
		if err := png.Encode(buf, img); err != nil {
			return err
		}
		pngDataBuffers = append(pngDataBuffers, buf.Bytes())
	}

	header := make([]byte, 6)
	header[0] = 0
	header[1] = 0
	header[2] = 1
	header[3] = 0
	count := uint16(len(images))
	header[4] = byte(count)
	header[5] = byte(count >> 8)

	if _, err := f.Write(header); err != nil {
		return err
	}

	offset := uint32(6 + len(images)*16)
	for i, img := range images {
		bounds := img.Bounds()
		w := bounds.Dx()
		h := bounds.Dy()
		entry := make([]byte, 16)
		if w > 255 {
			w = 0
		}
		if h > 255 {
			h = 0
		}
		entry[0] = byte(w)
		entry[1] = byte(h)
		entry[2] = 0
		entry[3] = 0
		entry[4] = 1
		entry[5] = 0
		entry[6] = 32
		entry[7] = 0
		dataSize := uint32(len(pngDataBuffers[i]))
		entry[8] = byte(dataSize)
		entry[9] = byte(dataSize >> 8)
		entry[10] = byte(dataSize >> 16)
		entry[11] = byte(dataSize >> 24)
		entry[12] = byte(offset)
		entry[13] = byte(offset >> 8)
		entry[14] = byte(offset >> 16)
		entry[15] = byte(offset >> 24)
		if _, err := f.Write(entry); err != nil {
			return err
		}
		offset += uint32(len(pngDataBuffers[i]))
		_ = i
	}

	for _, data := range pngDataBuffers {
		if _, err := f.Write(data); err != nil {
			return err
		}
	}

	return nil
}

func (s *ImageService) CompressImage(inputPath, outputPath string, quality int, maxWidth, maxHeight int) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if quality < 1 {
		quality = 1
	}
	if quality > 100 {
		quality = 100
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_compressed")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	if maxWidth > 0 || maxHeight > 0 {
		bounds := img.Bounds()
		width := bounds.Dx()
		height := bounds.Dy()

		newWidth := width
		newHeight := height

		if maxWidth > 0 && width > maxWidth {
			newWidth = maxWidth
			newHeight = height * maxWidth / width
		}

		if maxHeight > 0 && newHeight > maxHeight {
			newWidth = newWidth * maxHeight / newHeight
			newHeight = maxHeight
		}

		img = imaging.Resize(img, newWidth, newHeight, imaging.Lanczos)
	}

	ext := strings.ToLower(filepath.Ext(outputPath))

	switch ext {
	case ".jpg", ".jpeg":
		err = imaging.Save(img, outputPath, imaging.JPEGQuality(quality))
	case ".png":
		err = imaging.Save(img, outputPath, imaging.PNGCompressionLevel(png.BestCompression))
	case ".gif":
		err = imaging.Save(img, outputPath, imaging.GIFNumColors(256))
	default:
		err = imaging.Save(img, outputPath, imaging.JPEGQuality(quality))
	}

	if err != nil {
		return fmt.Errorf("保存压缩图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) ResizeImage(inputPath, outputPath string, width, height int, maintainRatio bool) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if width <= 0 || height <= 0 {
		return fmt.Errorf("宽度和高度必须大于 0")
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_resized")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	if maintainRatio {
		img = imaging.Fit(img, width, height, imaging.Lanczos)
	} else {
		img = imaging.Resize(img, width, height, imaging.Lanczos)
	}

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存调整大小后的图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) RotateImage(inputPath, outputPath string, angle float64, bgColor string) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_rotated")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	var fillColor color.Color
	switch bgColor {
	case "white":
		fillColor = color.White
	case "black":
		fillColor = color.Black
	default:
		fillColor = color.Transparent
	}

	img = imaging.Rotate(img, angle, fillColor)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存旋转后的图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) AddGrayscale(inputPath, outputPath string) error {
	return s.AdjustGrayscale(inputPath, outputPath, 100)
}

func (s *ImageService) AdjustGrayscale(inputPath, outputPath string, intensity int) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_grayscale")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	if intensity >= 100 {
		img = imaging.Grayscale(img)
	} else if intensity > 0 {
		gray := imaging.Grayscale(img)
		img = blendImages(img, gray, float64(intensity)/100.0)
	}

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存灰度图片失败: %v", err)
	}

	return nil
}

func blendImages(src, gray image.Image, opacity float64) image.Image {
	if opacity < 0 {
		opacity = 0
	}
	if opacity > 1 {
		opacity = 1
	}
	bounds := src.Bounds()
	dst := image.NewRGBA(bounds)
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r1, g1, b1, a1 := src.At(x, y).RGBA()
			r2, g2, b2, _ := gray.At(x, y).RGBA()
			r := uint8((float64(r1>>8)*(1-opacity) + float64(r2>>8)*opacity))
			g := uint8((float64(g1>>8)*(1-opacity) + float64(g2>>8)*opacity))
			b := uint8((float64(b1>>8)*(1-opacity) + float64(b2>>8)*opacity))
			a := uint8(a1 >> 8)
			dst.Set(x, y, color.RGBA{r, g, b, a})
		}
	}
	return dst
}

func (s *ImageService) AdjustBrightness(inputPath, outputPath string, factor float64) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_bright")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.AdjustBrightness(img, factor)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存调整亮度后的图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) AdjustContrast(inputPath, outputPath string, factor float64) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_contrast")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.AdjustContrast(img, factor)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存调整对比度后的图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) AdjustSaturation(inputPath, outputPath string, factor float64) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_saturation")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.AdjustSaturation(img, factor)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存调整饱和度后的图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) FlipH(inputPath, outputPath string) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_fliph")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.FlipH(img)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存水平翻转图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) FlipV(inputPath, outputPath string) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_flipv")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.FlipV(img)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存垂直翻转图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) SharpenImage(inputPath, outputPath string, amount float64) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_sharpen")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.Sharpen(img, amount)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存锐化图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) BlurImage(inputPath, outputPath string, radius float64) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_blur")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.Blur(img, radius)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存模糊图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) InvertImage(inputPath, outputPath string) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_invert")
	}

	img, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	img = imaging.Invert(img)

	err = imaging.Save(img, outputPath)
	if err != nil {
		return fmt.Errorf("保存反色图片失败: %v", err)
	}

	return nil
}

func (s *ImageService) RemoveBackground(inputPath, outputPath string, threshold int, bgColor *ColorRGB) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_nobg")
	}

	if threshold <= 0 {
		threshold = 30
	}

	srcImg, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	bounds := srcImg.Bounds()
	dst := image.NewRGBA(bounds)

	maxDist := float64(threshold) / 100.0 * 441.67

	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r, g, b, _ := srcImg.At(x, y).RGBA()
			r8 := uint8(r >> 8)
			g8 := uint8(g >> 8)
			b8 := uint8(b >> 8)

			var isBg bool
			if bgColor != nil {
				dr := float64(int(r8) - bgColor.R)
				dg := float64(int(g8) - bgColor.G)
				db := float64(int(b8) - bgColor.B)
				dist := math.Sqrt(dr*dr + dg*dg + db*db)
				isBg = dist <= maxDist
			} else {
				isBg = int(r8) > 255-threshold &&
					int(g8) > 255-threshold &&
					int(b8) > 255-threshold
			}

			if isBg {
				dst.Set(x, y, color.RGBA{0, 0, 0, 0})
			} else {
				dst.Set(x, y, srcImg.At(x, y))
			}
		}
	}

	err = imaging.Save(dst, outputPath, imaging.PNGCompressionLevel(png.BestCompression))
	if err != nil {
		return fmt.Errorf("保存去背景图片失败: %v", err)
	}

	return nil
}

type CropShape struct {
	Type   string  `json:"type"`
	X      int     `json:"x"`
	Y      int     `json:"y"`
	Width  int     `json:"width"`
	Height int     `json:"height"`
	Radius int     `json:"radius"`
	Points []Point `json:"points"`
}

type Point struct {
	X int `json:"x"`
	Y int `json:"y"`
}

type ColorRGB struct {
	R int `json:"r"`
	G int `json:"g"`
	B int `json:"b"`
}

func (s *ImageService) CropImageShape(inputPath, outputPath string, shape CropShape) error {
	if err := s.checkFormat(inputPath); err != nil {
		return err
	}
	if outputPath == "" {
		outputPath = GetOutputPath(inputPath, "_cropped")
	}

	srcImg, err := imaging.Open(inputPath)
	if err != nil {
		return fmt.Errorf("打开图片失败: %v", err)
	}

	switch shape.Type {
	case "rectangle":
		rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
		cropped := imaging.Crop(srcImg, rect)
		return imaging.Save(cropped, outputPath)

	case "circle":
		cx := shape.X + shape.Width/2
		cy := shape.Y + shape.Height/2
		radius := shape.Width / 2
		if shape.Height/2 < radius {
			radius = shape.Height / 2
		}

		size := radius * 2
		result := image.NewRGBA(image.Rect(0, 0, size, size))
		for y := 0; y < size; y++ {
			for x := 0; x < size; x++ {
				if math.Sqrt(float64((x-radius)*(x-radius)+((y-radius)*(y-radius)))) <= float64(radius) {
					result.Set(x, y, srcImg.At(cx-radius+x, cy-radius+y))
				}
			}
		}

		return imaging.Save(result, outputPath)

	case "rounded":
		rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
		cropped := imaging.Crop(srcImg, rect)

		radius := shape.Radius
		if radius <= 0 {
			radius = 20
		}

		size := cropped.Bounds().Size()
		result := image.NewRGBA(image.Rect(0, 0, size.X, size.Y))
		for y := 0; y < size.Y; y++ {
			for x := 0; x < size.X; x++ {
				inCorner := false
				if x < radius && y < radius {
					dx := float64(radius - x)
					dy := float64(radius - y)
					if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
						inCorner = true
					}
				} else if x >= size.X-radius && y < radius {
					dx := float64(x - (size.X - radius - 1))
					dy := float64(radius - y)
					if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
						inCorner = true
					}
				} else if x < radius && y >= size.Y-radius {
					dx := float64(radius - x)
					dy := float64(y - (size.Y - radius - 1))
					if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
						inCorner = true
					}
				} else if x >= size.X-radius && y >= size.Y-radius {
					dx := float64(x - (size.X - radius - 1))
					dy := float64(y - (size.Y - radius - 1))
					if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
						inCorner = true
					}
				}

				if !inCorner {
					result.Set(x, y, cropped.At(cropped.Bounds().Min.X+x, cropped.Bounds().Min.Y+y))
				}
			}
		}

		return imaging.Save(result, outputPath)

	case "polygon":
		if len(shape.Points) < 3 {
			return fmt.Errorf("多边形至少需要3个点")
		}

		minX, minY := shape.Points[0].X, shape.Points[0].Y
		maxX, maxY := shape.Points[0].X, shape.Points[0].Y
		for _, p := range shape.Points {
			if p.X < minX {
				minX = p.X
			}
			if p.Y < minY {
				minY = p.Y
			}
			if p.X > maxX {
				maxX = p.X
			}
			if p.Y > maxY {
				maxY = p.Y
			}
		}

		cropW := maxX - minX
		cropH := maxY - minY
		rect := image.Rect(minX, minY, maxX, maxY)
		cropped := imaging.Crop(srcImg, rect)

		result := image.NewRGBA(image.Rect(0, 0, cropW, cropH))
		for y := 0; y < cropH; y++ {
			for x := 0; x < cropW; x++ {
				if pointInPolygon(x, y, shape.Points, minX, minY) {
					result.Set(x, y, cropped.At(cropped.Bounds().Min.X+x, cropped.Bounds().Min.Y+y))
				}
			}
		}

		return imaging.Save(result, outputPath)

	default:
		rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
		cropped := imaging.Crop(srcImg, rect)
		return imaging.Save(cropped, outputPath)
	}
}

func pointInPolygon(px, py int, points []Point, offsetX, offsetY int) bool {
	n := len(points)
	inside := false
	j := n - 1
	for i := 0; i < n; i++ {
		xi, yi := points[i].X-offsetX, points[i].Y-offsetY
		xj, yj := points[j].X-offsetX, points[j].Y-offsetY
		if yi == yj {
			j = i
			continue
		}
		if ((yi > py) != (yj > py)) && (px < (xj-xi)*(py-yi)/(yj-yi)+xi) {
			inside = !inside
		}
		j = i
	}
	return inside
}