import (
    "github.com/tmontdev/collections/maps"
)
// NATO Alphabet standard words is commonly used for accurately radio and telephone communication
// standardRadioAlphabet returns a maps.Map[rune, string]
func standardRadioAlphabet() maps.Map[rune, string] {
	// Note: returning a built-in map is accepted, as the maps.Map is a map type
	return map[rune]string{
		'A': "Alpha", 'B': "Bravo", 'C': "Charlie", 'D': "Delta",
		'E': "Echo", 'F': "Foxtrot", 'K': "Kilo", 'L': "Lima", 'M': "Mike",
		'N': "November", 'O': "Oscar", 'P': "Papa", 'Q': "Quebec", 'R': "Romeu",
		'S': "Sierra", 'T': "Tango", 'U': "Uniform", 'V': "Victor",
		'W': "Whiskey", 'X': "X-Ray", 'Y': "Yankee", 'Z': "Zulu",
	}
}

func main() {
	// built-in map handled here as maps.Map now have super-powers
	// use .Where() to get a new Map with all the key/value pairs which satisfies your predicate
	longSpells := standardRadioAlphabet().Where(func(letter rune, word string) bool {
		return len(word) > 4 // here we want all spelling with length greater than 4
	})
	fmt.Printf("%v", longSpells)
	// note that runes are referenced by numbers
	// outputs only values with length greater than 4
	// map[65(A):Alpha 66(B):Bravo 67(C):Charlie 68(D):Delta 70(F):Foxtrot 78(N):November 79(O):Oscar 81(Q):Quebec 82(R):Romeu 83(S):Sierra 84(T):Tango 85(U):Uniform 86(V):Victor 87(W):Whiskey 88(X):X-Ray 89(Y):Yankee]
}

func standardRadioNumbers() maps.Map[rune, string] {
	return map[rune]string{
		'1': "One",
		'2': "Two",
		'3': "Three",
		'4': "Four",
		'5': "Five",
		'6': "Six",
		'7': "Seven",
		'8': "Eight",
		'9': "Nine",
		'0': "Zero",
	}
}

func preferredRadioSpelling() maps.Map[rune, string] {
	return map[rune]string{
		'9': "Niner", // commonly spelled niner, cause nine and five are easily confused
		'X': "X-Men", // because you may work at Marvel comics now lol
		'A': "Apple",
		'B': "Bingo",
		'?': "What", // not spelled yet on the other maps... lol
	}
}

// now lets mix it up!!
func main() {
	letterSpelling := standardRadioAlphabet()
	numberSpelling := standardRadioNumbers()
	// let's get words and letters together in a single map
	// Note: Complement() method sets key/value pairs from the given map, into itself... on key conflict, keeps original value
	// Note: SetFrom() method sets key/value pairs from the given map, into itself... on key conflict, sets the new value from given map
	// Note: Clone() method create and returns a new map, identical to the original.
	// Note: In order to keep letterSpelling map unaltered, let's merge numberSpelling in its Clone
	standardSpelling := letterSpelling.Clone().Complement(numberSpelling)

	// now we are going to replace our preferred spelling words in the alphabet.
	// Note: In order to replace our preferred spelling words, let's use SetFrom() method instead of Complement()
	// Note: In order to keep standardSpelling map unaltered, let's merge preferredRadioSpelling() result in its Clone
	customSpelling := standardSpelling.Clone().SetFrom(preferredRadioSpelling())

	println(customSpelling.Get('X'))   // "X-men"
	println(standardSpelling.Get('X')) // "X-Ray"
	println(customSpelling.Get('9'))   // "Niner"
	println(standardSpelling.Get('9')) // "Nine"
	println(customSpelling.Get('?'))   // "What"
	println(standardSpelling.Get('?')) // empty string, as it was not mapped
}

import (
    "github.com/tmontdev/collections/maps"
    "github.com/tmontdev/collections/lists"
)

// our official alphabet spelling
func customSpelling() maps.IMap[rune, string] {
	// uses old code here
	return standardRadioAlphabet().Complement(standardRadioNumbers()).SetFrom(preferredRadioSpelling())
}

// returns a list of runes, which is the letters of the given word
func lettersFrom(word string) lists.IList[rune] {
	// creates a list from the slice of runes
	return lists.NewListFrom[rune]([]rune(word))
}

// returns a list of words, which is the spelling of the given word
func spell(word string) lists.IList[string] {
	spelling := lists.NewList[string]()
	spellingReference := customSpelling()
	letters := lettersFrom(word)
	// letters is a List of runes (*[]rune).
	// Note: Elements() method return a built-in slice value, with all elements of the list
	// Note: See Map(), and Reduce() List methods too.
	for _, letter := range letters.Elements() {
		// for each letter, get the spelling reference, and add in the spelling word list
		spelling.Push(spellingReference.Get(unicode.ToUpper(letter)))
	}
	return spelling
}

func main() {
	words := lists.NewList[string]("foo", "bar", "berserk")
	// we may easily add, remove, and filter words
	// lets and some harder words to spell
	words.Push("bumfuzzle", "cattywampus", "Kakorrhaphiophobia")
	// I don't event know what the heck these words mean

	//See Reduce() docs for more information
	spelledWords := words.Reduce(func(acc any, word string, idx int) any {
		return acc.(maps.Map[string, lists.IList[string]]).Set(word, spell(word))
	}, maps.Map[string, lists.IList[string]]{})
	fmt.Printf("%v", spelledWords)
}