// Copyright 2016 The Gogs Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package avatar

import (
	"bytes"
	"image"
	"image/png"
	"os"
	"testing"

	"forgejo.org/modules/setting"
	"forgejo.org/modules/test"

	jpegstructure "code.superseriousbusiness.org/go-jpeg-image-structure/v2"
	"github.com/dsoprea/go-exif/v3"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func Test_RandomImageSize(t *testing.T) {
	_, err := RandomImageSize(0, []byte("gitea@local"))
	require.Error(t, err)

	_, err = RandomImageSize(64, []byte("gitea@local"))
	require.NoError(t, err)
}

func Test_RandomImage(t *testing.T) {
	_, err := RandomImage([]byte("gitea@local"))
	require.NoError(t, err)
}

func Test_ProcessAvatarPNG(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 4096)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 4096)()

	data, err := os.ReadFile("testdata/avatar.png")
	require.NoError(t, err)

	_, err = processAvatarImage(data, 262144)
	require.NoError(t, err)
}

func Test_ProcessAvatarJPEG(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 4096)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 4096)()

	data, err := os.ReadFile("testdata/avatar.jpeg")
	require.NoError(t, err)

	_, err = processAvatarImage(data, 262144)
	require.NoError(t, err)
}

func Test_ProcessAvatarGIF(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 4096)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 4096)()

	data, err := os.ReadFile("testdata/avatar.gif")
	require.NoError(t, err)

	_, err = processAvatarImage(data, 262144)
	require.NoError(t, err)
}

func Test_ProcessAvatarInvalidData(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 5)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 5)()

	_, err := processAvatarImage([]byte{}, 12800)
	assert.EqualError(t, err, "image.DecodeConfig: image: unknown format")
}

func Test_ProcessAvatarInvalidImageSize(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 5)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 5)()

	data, err := os.ReadFile("testdata/avatar.png")
	require.NoError(t, err)

	_, err = processAvatarImage(data, 12800)
	assert.EqualError(t, err, "image width is too large: 10 > 5")
}

func Test_ProcessAvatarImage(t *testing.T) {
	defer test.MockVariableValue(&setting.Avatar.MaxWidth, 4096)()
	defer test.MockVariableValue(&setting.Avatar.MaxHeight, 4096)()
	scaledSize := DefaultAvatarSize * setting.Avatar.RenderedSizeFactor

	newImgData := func(size int, optHeight ...int) []byte {
		width := size
		height := size
		if len(optHeight) == 1 {
			height = optHeight[0]
		}
		img := image.NewRGBA(image.Rect(0, 0, width, height))
		bs := bytes.Buffer{}
		err := png.Encode(&bs, img)
		require.NoError(t, err)
		return bs.Bytes()
	}

	// if origin image canvas is too large, crop and resize it
	origin := newImgData(500, 600)
	result, err := processAvatarImage(origin, 0)
	require.NoError(t, err)
	assert.NotEqual(t, origin, result)
	decoded, err := png.Decode(bytes.NewReader(result))
	require.NoError(t, err)
	assert.Equal(t, scaledSize, decoded.Bounds().Max.X)
	assert.Equal(t, scaledSize, decoded.Bounds().Max.Y)

	// if origin image is smaller than the default size, use the origin image
	origin = newImgData(1)
	result, err = processAvatarImage(origin, 0)
	require.NoError(t, err)
	assert.Equal(t, origin, result)

	// use the origin image if the origin is smaller
	origin = newImgData(scaledSize + 100)
	result, err = processAvatarImage(origin, 0)
	require.NoError(t, err)
	assert.Less(t, len(result), len(origin))

	// still use the origin image if the origin doesn't exceed the max-origin-size
	origin = newImgData(scaledSize + 100)
	result, err = processAvatarImage(origin, 262144)
	require.NoError(t, err)
	assert.Equal(t, origin, result)

	// allow to use known image format (eg: webp) if it is small enough
	origin, err = os.ReadFile("testdata/animated.webp")
	require.NoError(t, err)
	result, err = processAvatarImage(origin, 262144)
	require.NoError(t, err)
	assert.Equal(t, origin, result)

	// do not support unknown image formats, eg: SVG may contain embedded JS
	origin = []byte("<svg></svg>")
	_, err = processAvatarImage(origin, 262144)
	require.ErrorContains(t, err, "image: unknown format")

	// make sure the canvas size limit works
	setting.Avatar.MaxWidth = 5
	setting.Avatar.MaxHeight = 5
	origin = newImgData(10)
	_, err = processAvatarImage(origin, 262144)
	require.ErrorContains(t, err, "image width is too large: 10 > 5")
}

func safeExifJpeg(t *testing.T, jpeg []byte) {
	t.Helper()

	parser := jpegstructure.NewJpegMediaParser()
	mediaContext, err := parser.ParseBytes(jpeg)
	require.NoError(t, err)

	sl := mediaContext.(*jpegstructure.SegmentList)

	rootIfd, _, err := sl.Exif()
	require.NoError(t, err)
	err = rootIfd.EnumerateTagsRecursively(func(ifd *exif.Ifd, ite *exif.IfdTagEntry) error {
		assert.Equal(t, "Orientation", ite.TagName(), "only Orientation EXIF tag expected")
		return nil
	})
	require.NoError(t, err)
}

func Test_ProcessAvatarExif(t *testing.T) {
	t.Run("greater than max origin size", func(t *testing.T) {
		data, err := os.ReadFile("testdata/exif.jpg")
		require.NoError(t, err)

		processedData, err := processAvatarImage(data, 12800)
		require.NoError(t, err)
		safeExifJpeg(t, processedData)
	})
	t.Run("smaller than max origin size", func(t *testing.T) {
		data, err := os.ReadFile("testdata/exif.jpg")
		require.NoError(t, err)

		processedData, err := processAvatarImage(data, 128000)
		require.NoError(t, err)
		safeExifJpeg(t, processedData)
	})
}