package utils

import (
	"bytes"
	"encoding/base64"
	"golang.org/x/image/bmp"
	"golang.org/x/image/tiff"
	"image"
	"image/color"
	"image/jpeg"
	"image/png"
)

func BuffToImage(in []byte) image.Image {
	buff := bytes.NewBuffer(in)
	m, _, _ := image.Decode(buff)
	return m
}

// Clip 图片裁剪
func Clip(in []byte, wi, hi int, equalProportion bool) (out image.Image, imageType string, err error) {
	buff := bytes.NewBuffer(in)
	m, imgType, _ := image.Decode(buff)
	rgbImg := m.(*image.YCbCr)
	if equalProportion {
		w := m.Bounds().Max.X
		h := m.Bounds().Max.Y
		if w > 0 && h > 0 && wi > 0 && hi > 0 {
			wi, hi = fixSize(w, h, wi, hi)
		}
	}
	return rgbImg.SubImage(image.Rect(0, 0, wi, hi)), imgType, nil
}

func fixSize(img1W, img2H, wi, hi int) (new1W, new2W int) {
	var ( //为了方便计算，将图片的宽转为 float64
		imgWidth, imgHeight = float64(img1W), float64(img2H)
		ratio               float64
	)
	if imgWidth >= imgHeight {
		ratio = imgWidth / float64(wi)
		return int(imgWidth * ratio), int(imgHeight * ratio)
	}
	ratio = imgHeight / float64(hi)
	return int(imgWidth * ratio), int(imgHeight * ratio)
}

func Gray(in []byte) (out image.Image, err error) {
	m := BuffToImage(in)
	bounds := m.Bounds()
	dx := bounds.Dx()
	dy := bounds.Dy()
	newRgba := image.NewRGBA(bounds)
	for i := 0; i < dx; i++ {
		for j := 0; j < dy; j++ {
			colorRgb := m.At(i, j)
			_, g, _, a := colorRgb.RGBA()
			gUint8 := uint8(g >> 8)
			aUint8 := uint8(a >> 8)
			newRgba.SetRGBA(i, j, color.RGBA{R: gUint8, G: gUint8, B: gUint8, A: aUint8})
		}
	}
	r := image.Rect(0, 0, dx, dy)
	return newRgba.SubImage(r), nil
}

func Rotate90(in []byte) image.Image {
	m := BuffToImage(in)
	rotate90 := image.NewRGBA(image.Rect(0, 0, m.Bounds().Dy(), m.Bounds().Dx()))
	// 矩阵旋转
	for x := m.Bounds().Min.Y; x < m.Bounds().Max.Y; x++ {
		for y := m.Bounds().Max.X - 1; y >= m.Bounds().Min.X; y-- {
			//  设置像素点
			rotate90.Set(m.Bounds().Max.Y-x, y, m.At(y, x))
		}
	}
	return rotate90
}

// Rotate180 旋转180度
func Rotate180(in []byte) image.Image {
	m := BuffToImage(in)
	rotate180 := image.NewRGBA(image.Rect(0, 0, m.Bounds().Dx(), m.Bounds().Dy()))
	// 矩阵旋转
	for x := m.Bounds().Min.X; x < m.Bounds().Max.X; x++ {
		for y := m.Bounds().Min.Y; y < m.Bounds().Max.Y; y++ {
			//  设置像素点
			rotate180.Set(m.Bounds().Max.X-x, m.Bounds().Max.Y-y, m.At(x, y))
		}
	}
	return rotate180
}

// Rotate270 旋转270度
func Rotate270(in []byte) image.Image {
	m := BuffToImage(in)
	rotate270 := image.NewRGBA(image.Rect(0, 0, m.Bounds().Dy(), m.Bounds().Dx()))
	// 矩阵旋转
	for x := m.Bounds().Min.Y; x < m.Bounds().Max.Y; x++ {
		for y := m.Bounds().Max.X - 1; y >= m.Bounds().Min.X; y-- {
			// 设置像素点
			rotate270.Set(x, m.Bounds().Max.X-y, m.At(y, x))
		}
	}
	return rotate270

}

func ImageToBase64(img image.Image, imgType string) string {
	buff := ImageToBuff(img, imgType)
	return base64.StdEncoding.EncodeToString(buff.Bytes())
}

func ImageToBuff(img image.Image, imgType string) *bytes.Buffer {
	buff := bytes.NewBuffer(nil)
	switch imgType {
	case "bmp":
		imgType = "bmp"
		_ = bmp.Encode(buff, img)
	case "png":
		imgType = "png"
		_ = png.Encode(buff, img)
	case "tiff":
		imgType = "tiff"
		_ = tiff.Encode(buff, img, nil)
	default:
		imgType = "jpeg"
		_ = jpeg.Encode(buff, img, nil)
	}
	return buff
}

func ImgFileToBase64(fn string) string {
	fileByte := ReadFile(fn)
	buff := bytes.NewBuffer(fileByte)
	m, _, _ := image.Decode(buff)
	return "data:image/jpeg;base64," + ImageToBase64(m, "jpeg")

}