package nkode

import (
	"github.com/stretchr/testify/assert"
	"go-nkode/core/model"
	py_builtin "go-nkode/py-builtin"
	"testing"
)

func TestUserCipherKeys_EncipherSaltHashCode(t *testing.T) {
	keypadSize := model.KeypadSize{AttrsPerKey: 10, NumbOfKeys: 5}
	maxNKodeLen := 10
	customerAttrs, err := NewCustomerAttributes(keypadSize)
	assert.NoError(t, err)
	newUser, err := NewUserCipherKeys(keypadSize, customerAttrs.SetVals, maxNKodeLen)
	assert.NoError(t, err)
	passcodeIdx := []int{0, 1, 2, 3}
	encipher0, err := newUser.EncipherSaltHashCode(passcodeIdx, *customerAttrs)
	assert.NoError(t, err)
	err = newUser.ValidPassword(encipher0, passcodeIdx, *customerAttrs)
	assert.NoError(t, err)
}

func TestUserCipherKeys_EncipherDecipherMask(t *testing.T) {
	keypadSize := model.KeypadSize{AttrsPerKey: 10, NumbOfKeys: 5}
	maxNKodeLen := 10

	customerAttrs, err := NewCustomerAttributes(keypadSize)
	assert.NoError(t, err)
	newUser, err := NewUserCipherKeys(keypadSize, customerAttrs.SetVals, maxNKodeLen)
	assert.NoError(t, err)
	passcodeIdx := []int{0, 1, 2, 3}
	originalSetVals := make([]uint64, len(passcodeIdx))

	for idx, val := range passcodeIdx {
		attr := customerAttrs.AttrVals[val]
		originalSetVals[idx], err = customerAttrs.GetAttrSetVal(attr)
		assert.NoError(t, err)
	}
	encipheredCode, err := newUser.EncipherNKode(passcodeIdx, *customerAttrs)
	assert.NoError(t, err)
	passcodeSetVals, err := newUser.DecipherMask(encipheredCode.Mask, customerAttrs.SetVals, len(passcodeIdx))
	assert.NoError(t, err)

	for idx, setVal := range passcodeSetVals {
		assert.Equal(t, setVal, originalSetVals[idx])
	}
}

func TestUserInterface_RandomShuffle(t *testing.T) {
	keypadSize := model.KeypadSize{
		AttrsPerKey: 10,
		NumbOfKeys:  5,
	}
	userInterface, err := NewUserInterface(keypadSize)
	assert.NoError(t, err)
	userInterfaceCopy := make([]int, len(userInterface.IdxInterface))
	copy(userInterfaceCopy, userInterface.IdxInterface)

	err = userInterface.RandomShuffle()
	assert.NoError(t, err)

	assert.Equal(t, len(userInterface.IdxInterface), len(userInterfaceCopy))
	equalCount := 0
	for idx, val := range userInterface.IdxInterface {
		if val == userInterfaceCopy[idx] {
			equalCount++
		}
	}
	assert.NotEqual(t, equalCount, len(userInterface.IdxInterface))
}

func TestUserInterface_DisperseInterface(t *testing.T) {

	for idx := 0; idx < 10000; idx++ {
		keypadSize := model.KeypadSize{AttrsPerKey: 7, NumbOfKeys: 10}

		userInterface, err := NewUserInterface(keypadSize)
		assert.NoError(t, err)
		preDispersion, err := userInterface.AttributeAdjacencyGraph()
		assert.NoError(t, err)
		err = userInterface.DisperseInterface()
		assert.NoError(t, err)
		postDispersion, err := userInterface.AttributeAdjacencyGraph()
		assert.Equal(t, len(postDispersion), len(preDispersion))
		for attr, adjAttrs := range preDispersion {
			postAdjAttrs := postDispersion[attr]
			assert.Equal(t, adjAttrs.Size(), postAdjAttrs.Size())
			assert.True(t, adjAttrs.IsDisjoint(postAdjAttrs))
		}
	}
}

func TestUserInterface_PartialInterfaceShuffle(t *testing.T) {
	keypadSize := model.KeypadSize{AttrsPerKey: 7, NumbOfKeys: 10}
	userInterface, err := NewUserInterface(keypadSize)
	assert.NoError(t, err)
	preShuffle := userInterface.IdxInterface
	err = userInterface.PartialInterfaceShuffle()
	assert.NoError(t, err)
	postShuffle := userInterface.IdxInterface

	shuffleCompare := make([]bool, len(postShuffle))
	for idx, val := range preShuffle {
		shuffleCompare[idx] = val == postShuffle[idx]
	}

	allTrue := py_builtin.All[bool](shuffleCompare, func(n bool) bool {
		return n == true
	})
	assert.False(t, allTrue)

	allFalse := py_builtin.All[bool](shuffleCompare, func(n bool) bool {
		return n == false
	})

	assert.False(t, allFalse)

}