package handler

import (
	"net/http"
	"strings"
	"testing"

	apiErrors "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
	"github.com/stretchr/testify/require"
)

func TestTagsValidity(t *testing.T) {
	sbKey := strings.Builder{}
	for i := 0; i < keyTagMaxLength; i++ {
		sbKey.WriteByte('a')
	}
	sbValue := strings.Builder{}
	for i := 0; i < valueTagMaxLength; i++ {
		sbValue.WriteByte('a')
	}

	for _, tc := range []struct {
		tag   Tag
		valid bool
	}{
		{tag: Tag{}, valid: false},
		{tag: Tag{Key: "", Value: "1"}, valid: false},
		{tag: Tag{Key: "aws:key", Value: "val"}, valid: false},
		{tag: Tag{Key: "key~", Value: "val"}, valid: false},
		{tag: Tag{Key: "key\\", Value: "val"}, valid: false},
		{tag: Tag{Key: "key?", Value: "val"}, valid: false},
		{tag: Tag{Key: sbKey.String() + "b", Value: "val"}, valid: false},
		{tag: Tag{Key: "key", Value: sbValue.String() + "b"}, valid: false},

		{tag: Tag{Key: sbKey.String(), Value: "val"}, valid: true},
		{tag: Tag{Key: "key", Value: sbValue.String()}, valid: true},
		{tag: Tag{Key: "k e y", Value: "v a l"}, valid: true},
		{tag: Tag{Key: "12345", Value: "1234"}, valid: true},
		{tag: Tag{Key: allowedTagChars, Value: allowedTagChars}, valid: true},
	} {
		err := checkTag(tc.tag)
		if tc.valid {
			require.NoError(t, err)
		} else {
			require.Error(t, err)
		}
	}
}

func TestPutObjectTaggingCheckUniqueness(t *testing.T) {
	hc := prepareHandlerContext(t)

	bktName, objName := "bucket-1", "object-1"
	createBucketAndObject(hc, bktName, objName)

	for _, tc := range []struct {
		name  string
		body  *Tagging
		error bool
	}{
		{
			name: "Two tags with unique keys",
			body: &Tagging{
				TagSet: []Tag{
					{
						Key:   "key-1",
						Value: "val-1",
					},
					{
						Key:   "key-2",
						Value: "val-2",
					},
				},
			},
			error: false,
		},
		{
			name: "Two tags with the same keys",
			body: &Tagging{
				TagSet: []Tag{
					{
						Key:   "key-1",
						Value: "val-1",
					},
					{
						Key:   "key-1",
						Value: "val-2",
					},
				},
			},
			error: true,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			w, r := prepareTestRequest(hc, bktName, objName, tc.body)
			hc.Handler().PutObjectTaggingHandler(w, r)
			if tc.error {
				assertS3Error(t, w, apiErrors.GetAPIError(apiErrors.ErrInvalidTagKeyUniqueness))
				return
			}
			assertStatus(t, w, http.StatusOK)

			tagging := getObjectTagging(t, hc, bktName, objName, emptyVersion)
			require.Len(t, tagging.TagSet, 2)
			require.Equal(t, "key-1", tagging.TagSet[0].Key)
			require.Equal(t, "val-1", tagging.TagSet[0].Value)
			require.Equal(t, "key-2", tagging.TagSet[1].Key)
			require.Equal(t, "val-2", tagging.TagSet[1].Value)
		})
	}
}