functions.go

package main

import (
	"strconv"
	"strings"
	"unicode"
)

func convertHex(text string) string {
	words := strings.Fields(text)

	result := []string{}

	i := 0
	for i < len(words) {

		if i+1 < len(words) && strings.EqualFold(words[i+1], "(hex)") {

			// strconv.ParseInt converts a string to an integer.
			val, err := strconv.ParseInt(words[i], 16, 64)
			if err == nil {
				result = append(result, strconv.FormatInt(val, 10))
				i += 2
				continue
			}
		}
		result = append(result, words[i])
		i++
	}
	return strings.Join(result, " ")
}

func convertBin(text string) string {
	words := strings.Fields(text)
	result := []string{}

	i := 0
	for i < len(words) {
		if i+1 < len(words) && strings.EqualFold(words[i+1], "(bin)") {
			val, err := strconv.ParseInt(words[i], 2, 64)
			if err == nil {
				result = append(result, strconv.FormatInt(val, 10))
				i += 2
				continue
			}
		}
		result = append(result, words[i])
		i++
	}
	return strings.Join(result, " ")
}

func convertCase(text string) string {
	words := strings.Fields(text)
	result := []string{}

	i := 0
	for i < len(words) {

		// (up)
		if strings.EqualFold(words[i], "(up)") {
			if len(result) > 0 {
				result[len(result)-1] = strings.ToUpper(result[len(result)-1])
			}
			i++
			continue
		}

		// (low)
		if strings.EqualFold(words[i], "(low)") {
			if len(result) > 0 {
				result[len(result)-1] = strings.ToLower(result[len(result)-1])
			}
			i++
			continue
		}

		// (cap)
		if strings.EqualFold(words[i], "(cap)") {
			if len(result) > 0 {
				w := result[len(result)-1]
				result[len(result)-1] =
					strings.ToUpper(w[:1]) + strings.ToLower(w[1:])
			}
			i++
			continue
		}

		// HANDLE (up, N)
		if i+1 < len(words) && strings.HasPrefix(strings.ToLower(words[i]), "(up,") {
			numStr := strings.TrimSuffix(words[i+1], ")")
			n, err := strconv.Atoi(numStr)

			if err == nil {
				start := len(result) - n
				if start < 0 {
					start = 0
				}

				for j := start; j < len(result); j++ {
					result[j] = strings.ToUpper(result[j])
				}
			}

			i += 2
			continue
		}

		// HANDLE (low, N)
		if i+1 < len(words) && strings.HasPrefix(strings.ToLower(words[i]), "(low,") {
			numStr := strings.TrimSuffix(words[i+1], ")")
			n, err := strconv.Atoi(numStr)

			if err == nil {
				start := len(result) - n
				if start < 0 {
					start = 0
				}

				for j := start; j < len(result); j++ {
					result[j] = strings.ToLower(result[j])
				}
			}

			i += 2
			continue
		}

		// HANDLE (cap, N)
		if i+1 < len(words) && strings.HasPrefix(strings.ToLower(words[i]), "(cap,") {
			numStr := strings.TrimSuffix(words[i+1], ")")
			n, err := strconv.Atoi(numStr)

			if err == nil {
				start := len(result) - n
				if start < 0 {
					start = 0
				}

				for j := start; j < len(result); j++ {
					w := result[j]
					result[j] =
						strings.ToUpper(w[:1]) + strings.ToLower(w[1:])
				}
			}

			i += 2
			continue
		}

		// normal word
		result = append(result, words[i])
		i++
	}

	return strings.Join(result, " ")
}

// isPunct returns true if the byte is one of our six punctuation characters.
func isPunct(c byte) bool {
	return c == '.' || c == ',' || c == '!' || c == '?' || c == ':' || c == ';'
}

func fixPunctuation(text string) string {
	// We'll build the result byte by byte.
	result := []byte{}
	i := 0
	n := len(text)

	for i < n {
		c := text[i]

		if isPunct(c) {
			// ── Remove any spaces we already added before this punctuation ──
			// Walk backwards through result and trim trailing spaces.
			for len(result) > 0 && result[len(result)-1] == ' ' {
				// Shrink the slice by 1 from the right.
				result = result[:len(result)-1]
			}

			// ── Collect all consecutive punctuation chars (e.g. "...") ──
			for i < n && isPunct(text[i]) {
				result = append(result, text[i])
				i++
			}

			// ── Skip any spaces that follow the punctuation group ──
			for i < n && text[i] == ' ' {
				i++
			}

			// ── Add exactly one space after (only if more text follows) ──
			if i < n {
				result = append(result, ' ')
			}
		} else {
			// Normal character — copy it straight through.
			result = append(result, c)
			i++
		}
	}

	// Remove any trailing space that ended up at the very end.
	return strings.TrimRight(string(result), " ")
}

func fixQuotes(text string) string {
	result := []byte{}
	i := 0
	n := len(text)

	for i < n {
		if text[i] == '\'' {
			i++ // move past the opening quote

			// Skip spaces right after the opening quote.
			for i < n && text[i] == ' ' {
				i++
			}

			// Collect everything up to the next single quote.
			inner := []byte{}
			for i < n && text[i] != '\'' {
				inner = append(inner, text[i])
				i++
			}

			// Trim trailing spaces from the inner content.
			// strings.TrimRight removes the specified characters from the right end.
			trimmed := strings.TrimRight(string(inner), " ")

			// Append: opening quote + trimmed content + closing quote.
			result = append(result, '\'')
			result = append(result, []byte(trimmed)...)
			result = append(result, '\'')

			if i < n {
				i++ // move past the closing quote
			}
		} else {
			result = append(result, text[i])
			i++
		}
	}

	return string(result)
}

func startsWithVowelOrH(word string) bool {
	if word == "" {
		return false
	}
	// []rune(word)[0] gets the first character as a rune.
	first := unicode.ToLower([]rune(word)[0])
	return strings.ContainsRune("aeiouh", first)
}

func fixArticles(text string) string {
	words := strings.Fields(text)

	for i := 0; i < len(words)-1; i++ {
		// strings.ToLower for a case-insensitive comparison.
		curr := strings.ToLower(words[i])
		next := words[i+1]

		if curr == "a" && startsWithVowelOrH(next) {
			// "a" → "an", preserving original capitalisation.
			if words[i] == "A" {
				words[i] = "An"
			} else {
				words[i] = "an"
			}
		} else if curr == "an" && !startsWithVowelOrH(next) {
			// "an" → "a", preserving original capitalisation.
			if words[i][0] == 'A' {
				words[i] = "A"
			} else {
				words[i] = "a"
			}
		}
	}

	return strings.Join(words, " ")
}