package bt_tracestore

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/golden/go/types"
)

// TestDigestMapMissingDigest verifies a newly created digest map
// starts off with the mapping for a missing digest and nothing else.
func TestDigestMapMissingDigest(t *testing.T) {
	unittest.SmallTest(t)

	digestMap := newDigestMap(1000)
	assert.Equal(t, 1, digestMap.Len())
	id, err := digestMap.ID(types.MISSING_DIGEST)
	assert.NoError(t, err)
	assert.Equal(t, id, missingDigestID)

	_, err = digestMap.ID(AlphaDigest)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "unable to find")
}

// TestDigestMapAddGet tests the three ways to get data out of the map.
func TestDigestMapAddGet(t *testing.T) {
	unittest.SmallTest(t)

	digestMap := newDigestMap(1)
	err := digestMap.Add(map[types.Digest]digestID{
		AlphaDigest: AlphaID,
		BetaDigest:  BetaID,
		GammaDigest: GammaID,
	})
	assert.NoError(t, err)
	assert.Equal(t, 4, digestMap.Len())

	digests, err := digestMap.DecodeIDs([]digestID{GammaID, AlphaID})
	assert.NoError(t, err)
	assert.Equal(t, digests, []types.Digest{GammaDigest, AlphaDigest})

	d, err := digestMap.Digest(BetaID)
	assert.NoError(t, err)
	assert.Equal(t, BetaDigest, d)

	id, err := digestMap.ID(BetaDigest)
	assert.NoError(t, err)
	assert.Equal(t, BetaID, id)
}

// TestDigestMapAddBadGet tests getting things out of the map that don't exist.
func TestDigestMapAddBadGet(t *testing.T) {
	unittest.SmallTest(t)

	notExistID := digestID(99)
	notExistDigest := types.Digest("fffe39544765f38baab53350aef79966")

	digestMap := newDigestMap(1)
	err := digestMap.Add(map[types.Digest]digestID{
		AlphaDigest: AlphaID,
		BetaDigest:  BetaID,
		GammaDigest: GammaID,
	})
	assert.NoError(t, err)
	_, err = digestMap.DecodeIDs([]digestID{AlphaID, notExistID})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "unable to find id")

	_, err = digestMap.Digest(notExistID)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "unable to find digest")

	_, err = digestMap.ID(notExistDigest)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "unable to find id")
}

// TestDigestMapBadAdd tests some corner cases with adding things to the map.
func TestDigestMapBadAdd(t *testing.T) {
	unittest.SmallTest(t)

	digestMap := newDigestMap(1)
	err := digestMap.Add(map[types.Digest]digestID{AlphaDigest: AlphaID})
	assert.NoError(t, err)
	err = digestMap.Add(map[types.Digest]digestID{BetaDigest: BetaID})
	assert.NoError(t, err)

	// Adding something multiple times is no error
	err = digestMap.Add(map[types.Digest]digestID{BetaDigest: BetaID})
	assert.NoError(t, err)
	err = digestMap.Add(map[types.Digest]digestID{BetaDigest: BetaID})
	assert.NoError(t, err)

	// Can't add something with MISSING_DIGEST as a key ...
	err = digestMap.Add(map[types.Digest]digestID{types.MISSING_DIGEST: 5})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid input id")
	// ... or as a value.
	err = digestMap.Add(map[types.Digest]digestID{BetaDigest: missingDigestID})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid input id")

	// Can't add something that is already in the map as a key
	err = digestMap.Add(map[types.Digest]digestID{BetaDigest: GammaID})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "internal inconsistency")
	// ... or as a value.
	err = digestMap.Add(map[types.Digest]digestID{GammaDigest: BetaID})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "internal inconsistency")

	// Can't mix up data that has already been seen before
	err = digestMap.Add(map[types.Digest]digestID{AlphaDigest: BetaID})
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "inconsistent data")
}

func TestTraceMapCommitIndicesWithData(t *testing.T) {
	unittest.SmallTest(t)

	tm := traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, AlphaDigest,
				AlphaDigest, types.MISSING_DIGEST, BetaDigest,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, types.MISSING_DIGEST, types.MISSING_DIGEST,
				GammaDigest, types.MISSING_DIGEST, GammaDigest,
			},
		},
	}
	assert.Equal(t, []int{0, 2, 3, 5}, tm.CommitIndicesWithData())

	empty := traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
	}
	assert.Nil(t, empty.CommitIndicesWithData())

	assert.Nil(t, traceMap{}.CommitIndicesWithData())
}

func TestTraceMapMakeFromCommitIndexes(t *testing.T) {
	unittest.SmallTest(t)

	tm := traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, AlphaDigest,
				AlphaDigest, types.MISSING_DIGEST, BetaDigest,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, types.MISSING_DIGEST, types.MISSING_DIGEST,
				GammaDigest, types.MISSING_DIGEST, GammaDigest,
			},
		},
	}

	assert.Equal(t, traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, AlphaDigest,
				AlphaDigest, BetaDigest,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, types.MISSING_DIGEST,
				GammaDigest, GammaDigest,
			},
		},
	}, tm.MakeFromCommitIndexes([]int{0, 2, 3, 5}))

	assert.Equal(t, traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
	}, tm.MakeFromCommitIndexes([]int{0, 1, 4}))

	assert.Equal(t, traceMap{}, tm.MakeFromCommitIndexes([]int{}))
	assert.Equal(t, traceMap{}, tm.MakeFromCommitIndexes(nil))
}

func TestTraceMapPrependTraces(t *testing.T) {
	unittest.SmallTest(t)

	tm1 := traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST, AlphaDigest,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
	}

	tm2 := traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, GammaDigest,
			},
		},
		",key=third,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, BetaDigest,
			},
		},
	}

	tm1.PrependTraces(tm2)

	assert.Equal(t, traceMap{
		",key=first,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, GammaDigest,
				types.MISSING_DIGEST, types.MISSING_DIGEST, AlphaDigest,
			},
		},
		",key=second,": &types.GoldenTrace{
			Digests: []types.Digest{
				types.MISSING_DIGEST, types.MISSING_DIGEST,
				GammaDigest, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
		",key=third,": &types.GoldenTrace{
			Digests: []types.Digest{
				GammaDigest, BetaDigest,
				types.MISSING_DIGEST, types.MISSING_DIGEST, types.MISSING_DIGEST,
			},
		},
	}, tm1)
}

const (
	AlphaDigest = types.Digest("aaa6fc936d06e6569788366f1e3fda4e")
	BetaDigest  = types.Digest("bbb15c047d150d961573062854f35a55")
	GammaDigest = types.Digest("cccd42f3ee0b02687f63963adb36a580")

	AlphaID = digestID(1)
	BetaID  = digestID(2)
	GammaID = digestID(3)
)