package go_lib

import (
	"crypto/rand"
	"regexp"
	"strings"
	"unicode"
)

func Explode(delimiter, str string) []string {
	if delimiter == "" {
		return strings.Split(str, "")
	}
	return strings.Split(str, delimiter)
}

func Implode(delimiter string, pieces []string) string {
	return strings.Join(pieces, delimiter)
}

func StrReplace(search, replace, subject string) string {
	return strings.ReplaceAll(subject, search, replace)
}

func StrReplaceArray(search, replace []string, subject string) string {
	result := subject
	for i, s := range search {
		if i < len(replace) {
			result = strings.ReplaceAll(result, s, replace[i])
		}
	}
	return result
}

func Substr(str string, start int, length ...int) string {
	runes := []rune(str)
	l := len(runes)
	
	if start < 0 {
		start = l + start
	}
	
	if start < 0 || start >= l {
		return ""
	}
	
	end := l
	if len(length) > 0 && length[0] > 0 {
		end = start + length[0]
		if end > l {
			end = l
		}
	}
	
	return string(runes[start:end])
}

func Strlen(str string) int {
	return len([]rune(str))
}

func Strpos(haystack, needle string) int {
	return strings.Index(haystack, needle)
}

func Strrpos(haystack, needle string) int {
	return strings.LastIndex(haystack, needle)
}

func Strtolower(str string) string {
	return strings.ToLower(str)
}

func Strtoupper(str string) string {
	return strings.ToUpper(str)
}

func Ucfirst(str string) string {
	if str == "" {
		return str
	}
	runes := []rune(str)
	runes[0] = unicode.ToUpper(runes[0])
	return string(runes)
}

func Ucwords(str string) string {
	return strings.Title(str)
}

func Trim(str string, cutset ...string) string {
	if len(cutset) > 0 {
		return strings.Trim(str, cutset[0])
	}
	return strings.TrimSpace(str)
}

func Ltrim(str string, cutset ...string) string {
	if len(cutset) > 0 {
		return strings.TrimLeft(str, cutset[0])
	}
	return strings.TrimLeftFunc(str, unicode.IsSpace)
}

func Rtrim(str string, cutset ...string) string {
	if len(cutset) > 0 {
		return strings.TrimRight(str, cutset[0])
	}
	return strings.TrimRightFunc(str, unicode.IsSpace)
}

func StrPad(input string, padLength int, padString string, padType int) string {
	const (
		STR_PAD_RIGHT = iota
		STR_PAD_LEFT
		STR_PAD_BOTH
	)
	
	inputLen := len([]rune(input))
	if padLength <= inputLen {
		return input
	}
	
	padLen := padLength - inputLen
	pad := strings.Repeat(padString, (padLen/len([]rune(padString)))+1)
	pad = string([]rune(pad)[:padLen])
	
	switch padType {
	case STR_PAD_LEFT:
		return pad + input
	case STR_PAD_BOTH:
		leftPad := padLen / 2
		rightPad := padLen - leftPad
		return string([]rune(pad)[:leftPad]) + input + string([]rune(pad)[:rightPad])
	default:
		return input + pad
	}
}

func StrRepeat(input string, multiplier int) string {
	if multiplier <= 0 {
		return ""
	}
	return strings.Repeat(input, multiplier)
}

func StrShuffle(str string) string {
	runes := []rune(str)
	for i := len(runes) - 1; i > 0; i-- {
		j := randomInt(i + 1)
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func randomInt(max int) int {
	b := make([]byte, 4)
	rand.Read(b)
	return int(b[0]) % max
}

func StrWordCount(str string) int {
	return len(strings.Fields(str))
}

func Nl2br(str string) string {
	return strings.ReplaceAll(str, "\n", "<br>")
}

func StripTags(str string) string {
	re := regexp.MustCompile(`<[^>]*>`)
	return re.ReplaceAllString(str, "")
}

func Addslashes(str string) string {
	replacer := strings.NewReplacer(
		"\\", "\\\\",
		"'", "\\'",
		"\"", "\\\"",
		"\x00", "\\0",
	)
	return replacer.Replace(str)
}

func Stripslashes(str string) string {
	replacer := strings.NewReplacer(
		"\\\\", "\\",
		"\\'", "'",
		"\\\"", "\"",
		"\\0", "\x00",
	)
	return replacer.Replace(str)
}

func Strstr(haystack, needle string) string {
	pos := strings.Index(haystack, needle)
	if pos == -1 {
		return ""
	}
	return haystack[pos:]
}

func Strrchr(haystack, needle string) string {
	pos := strings.LastIndex(haystack, needle)
	if pos == -1 {
		return ""
	}
	return haystack[pos:]
}