package identity

import (
	"math"
	"math/big"
	"reflect"
	"testing"

	"github.com/stretchr/testify/require"
)

func TestToBigBase(t *testing.T) {
	checker := func(value *big.Int, base uint64, expected *[](uint64)) {
		res := ToBigBase(value, base)
		if !reflect.DeepEqual(res, *expected) {
			t.Fatalf("invalid big base conversion %v != %v", res, *expected)
		}
	}

	lengthChecker := func(value *big.Int, base, expectedLength uint64) {
		res := ToBigBase(value, base)
		if len(res) != int(expectedLength) {
			t.Fatalf("invalid big base conversion %d != %d", len(res), expectedLength)
		}
	}

	checker(new(big.Int).SetUint64(15), 16, &[](uint64){15})
	checker(new(big.Int).SetUint64(495), 16, &[](uint64){1, 14, 15})
	checker(new(big.Int).SetUint64(495), 30, &[](uint64){16, 15})
	checker(new(big.Int).SetUint64(495), 1024, &[](uint64){495})
	checker(new(big.Int).SetUint64(2048), 1024, &[](uint64){2, 0})

	base := uint64(math.Pow(2, 7*4))
	checker(ToBigInt(t, "0xFFFFFFFFFFFFFF"), base, &[](uint64){base - 1, base - 1})

	val := ToBigInt(t, "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
	lengthChecker(val, 2757, 14)
	lengthChecker(val, 2756, 15)
}

func TestSlices(t *testing.T) {
	checker := func(compressedKey, charsCutoffA, emojiHash, colorHash, charsCutoffB string) {
		slices, err := Slices(ToBigInt(t, compressedKey).Bytes())
		require.NoError(t, err)

		sliceChecker := func(idx int, value *big.Int) {
			if !reflect.DeepEqual(slices[idx], value.Bytes()) {
				t.Fatalf("invalid slice (%d) %v != %v", idx, slices[idx], value.Bytes())
			}
		}

		sliceChecker(0, ToBigInt(t, charsCutoffA))
		sliceChecker(1, ToBigInt(t, emojiHash))
		sliceChecker(2, ToBigInt(t, colorHash))
		sliceChecker(3, ToBigInt(t, charsCutoffB))
	}

	checker("0x03086138b210f21d41c757ae8a5d2a4cb29c1350f7389517608378ebd9efcf4a55", "0x030", "0x86138b210f21d41c757ae8a5d2a4cb29c1350f73", "0x89517608378ebd9efcf4", "0xa55")
	checker("0x020000000000000000000000000000000000000000100000000000000000000000", "0x020", "0x0000000000000000000000000000000000000001", "0x00000000000000000000", "0x000")
}

func TestSlicesInvalid(t *testing.T) {
	_, err := Slices(ToBigInt(t, "0x01").Bytes())
	require.Error(t, err)
}