package core

import (
	"go-nkode/hashset"
	"go-nkode/util"
	"log"
)

type UserInterface struct {
	IdxInterface IdxInterface
	SvgId        SvgIdInterface
	Kp           *KeypadDimension
}

func NewUserInterface(kp *KeypadDimension, svgId SvgIdInterface) (*UserInterface, error) {
	idxInterface := util.IdentityArray(kp.TotalAttrs())
	userInterface := UserInterface{
		IdxInterface: idxInterface,
		SvgId:        svgId,
		Kp:           kp,
	}
	if err := userInterface.RandomShuffle(); err != nil {
		return nil, err
	}
	return &userInterface, nil
}

func (u *UserInterface) RandomShuffle() error {
	err := u.shuffleKeys()

	keypadView, err := u.InterfaceMatrix()
	if err != nil {
		return err
	}
	setView, err := util.MatrixTranspose(keypadView)
	if err != nil {
		return err
	}

	for idx, set := range setView {
		err := util.FisherYatesShuffle(&set)
		if err != nil {
			return nil
		}
		setView[idx] = set
	}

	keypadView, err = util.MatrixTranspose(setView)
	if err != nil {
		return err
	}
	u.IdxInterface = util.MatrixToList(keypadView)
	return nil
}

func (u *UserInterface) InterfaceMatrix() ([][]int, error) {
	return util.ListToMatrix(u.IdxInterface, u.Kp.AttrsPerKey)
}

func (u *UserInterface) SetViewMatrix() ([][]int, error) {
	keypadView, err := u.InterfaceMatrix()
	if err != nil {
		return nil, err
	}
	return util.MatrixTranspose(keypadView)
}

func (u *UserInterface) DisperseInterface() error {
	if !u.Kp.IsDispersable() {
		return ErrInterfaceNotDispersible
	}

	err := u.shuffleKeys()
	if err != nil {
		return err
	}
	err = u.randomAttributeRotation()
	if err != nil {
		return err
	}

	return nil
}

func (u *UserInterface) shuffleKeys() error {
	userInterfaceMatrix, err := util.ListToMatrix(u.IdxInterface, u.Kp.AttrsPerKey)
	if err != nil {
		return err
	}
	err = util.FisherYatesShuffle[[]int](&userInterfaceMatrix)
	if err != nil {
		return err
	}
	u.IdxInterface = util.MatrixToList(userInterfaceMatrix)
	return nil
}

func (u *UserInterface) randomAttributeRotation() error {
	userInterface, err := u.InterfaceMatrix()
	if err != nil {
		return err
	}

	transposeUserInterface, err := util.MatrixTranspose(userInterface)

	attrRotation, err := util.RandomPermutation(len(transposeUserInterface))

	if err != nil {
		return err
	}
	for idx, attrSet := range transposeUserInterface {
		rotation := attrRotation[idx]
		transposeUserInterface[idx] = append(attrSet[rotation:], attrSet[:rotation]...)
	}
	userInterface, err = util.MatrixTranspose(transposeUserInterface)
	if err != nil {
		return err
	}
	u.IdxInterface = util.MatrixToList(userInterface)
	return nil
}

func (u *UserInterface) AttributeAdjacencyGraph() (map[int]hashset.Set[int], error) {
	interfaceKeypad, err := u.InterfaceMatrix()
	if err != nil {
		return nil, err
	}
	graph := make(map[int]hashset.Set[int])

	for _, key := range interfaceKeypad {
		keySet := hashset.NewSetFromSlice(key)
		for _, attr := range key {
			attrAdjacency := keySet.Copy()
			attrAdjacency.Remove(attr)
			graph[attr] = attrAdjacency
		}
	}
	return graph, nil
}

func (u *UserInterface) PartialInterfaceShuffle() error {
	err := u.shuffleKeys()
	if err != nil {
		return err
	}
	numbOfSelectedSets := u.Kp.AttrsPerKey / 2
	if u.Kp.AttrsPerKey&1 == 1 {
		numbOfSelectedSets += util.Choice[int]([]int{0, 1})
	}
	setIdxs, err := util.RandomPermutation(u.Kp.AttrsPerKey)
	if err != nil {
		return err
	}
	selectedSets := hashset.NewSetFromSlice[int](setIdxs[:numbOfSelectedSets])

	keypadSetView, err := u.SetViewMatrix()
	if err != nil {
		return err
	}
	interfaceBySet := make([][]int, u.Kp.AttrsPerKey)
	for idx, attrs := range keypadSetView {
		if selectedSets.Contains(idx) {
			err = util.FisherYatesShuffle[int](&attrs)
			if err != nil {
				return err
			}
		}
		interfaceBySet[idx] = attrs
	}
	keypadView, err := util.MatrixTranspose(interfaceBySet)
	if err != nil {
		return err
	}
	u.IdxInterface = util.MatrixToList(keypadView)
	return nil
}

func (u *UserInterface) GetAttrIdxByKeyNumbSetIdx(setIdx int, keyNumb int) (int, error) {
	if keyNumb < 0 || u.Kp.NumbOfKeys <= keyNumb {
		log.Printf("keyNumb %d is out of range 0-%d", keyNumb, u.Kp.NumbOfKeys)
		return -1, ErrKeyIndexOutOfRange
	}

	if setIdx < 0 || u.Kp.AttrsPerKey <= setIdx {
		log.Printf("setIdx %d is out of range 0-%d", setIdx, u.Kp.AttrsPerKey)
		return -1, ErrAttributeIndexOutOfRange
	}
	keypadView, err := u.InterfaceMatrix()
	if err != nil {
		return -1, err
	}
	return keypadView[keyNumb][setIdx], nil
}
