package string_utils

import (
	"bytes"
	"encoding/json"
	"fmt"
	"gitlab.bob.co.za/bob-public-utils/bobgroup-go-utils/number_utils"
	"regexp"
	"strconv"
	"strings"
	"unicode"

	"github.com/thoas/go-funk"
	"golang.org/x/text/runes"
	"golang.org/x/text/transform"
	"golang.org/x/text/unicode/norm"
)

const snakeCasePattern = `[a-z]([a-z0-9_]*[a-z0-9])*`

var snakeCaseRegex = regexp.MustCompile("^" + snakeCasePattern + "$")

func IsSnakeCase(name string) bool {
	return snakeCaseRegex.MatchString(name)
}

func SnakeToKebabString(s string) string {
	s = strings.TrimSpace(s)

	re := regexp.MustCompile("(_)")
	s = re.ReplaceAllString(s, "-")

	return s
}

// ReplaceNonSpacingMarks removes diacritics e.g. êžů becomes ezu
func ReplaceNonSpacingMarks(str string) string {
	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC) // Mn: non-spacing marks
	result, _, _ := transform.String(t, str)
	return result
}

func RemoveAllWhiteSpaces(s string) string {
	return strings.ReplaceAll(strings.ReplaceAll(s, " ", ""), "\t", "")
}

func ReplaceCaseInsensitive(string, toReplace, replaceWith string) string {
	regex := regexp.MustCompile("(?i)" + strings.ToLower(toReplace))
	return regex.ReplaceAllString(string, replaceWith)
}

// TrimQuotes - trims quotes from a string (ie: "foo" will return foo)
func TrimQuotes(stringToTrim string) string {
	if len(stringToTrim) >= 2 {
		if stringToTrim[0] == '"' && stringToTrim[len(stringToTrim)-1] == '"' {
			return stringToTrim[1 : len(stringToTrim)-1]
		}
	}

	return stringToTrim
}

// IsNumericString returns true if the string can be converted to a float without error
func IsNumericString(s string) bool {
	_, err := strconv.ParseFloat(s, 64)
	return err == nil
}

func IsAlphaNumeric(str string) bool {
	regex := regexp.MustCompile("^[a-zA-Z0-9]*$")
	return regex.MatchString(str)
}

func IsAlphaNumericOrDash(str string) bool {
	regex := regexp.MustCompile("^[a-zA-Z0-9-]*$")
	return regex.MatchString(str)
}

func Equal(a string, b string) bool {
	return strings.TrimSpace(strings.ToLower(a)) == strings.TrimSpace(strings.ToLower(b))
}

// TrimP trims specified strings, replacing empty string with nil
func TrimP(sp *string) *string {
	if sp == nil {
		return nil
	}
	s := strings.TrimSpace(*sp)
	if s == "" {
		return nil
	}
	return &s
}

// ConcatP concatenates all specified non-empty strings with ", " separators
func ConcatP(args ...*string) string {
	s := ""
	for _, arg := range args {
		if arg != nil && *arg != "" {
			if s != "" {
				s += ", "
			}
			s += *arg
		}
	}
	return s
}

// Concat concatenates all specified non-empty strings with ", " separators
func Concat(args []string, separator string) string {
	s := ""
	for _, arg := range args {
		if arg != "" {
			if s != "" {
				s += separator
			}
			s += arg
		}
	}
	return s
}

func ToJSONString(object interface{}) (string, error) {
	jsonBytes, err := json.Marshal(&object)
	if err != nil {
		return "", err
	}
	return string(jsonBytes), nil
}

func Int64ToString(number int64) string {
	return strconv.FormatInt(number, 10)
}

func IntToString(number int) string {
	return strconv.Itoa(number)
}

func Int64SliceToString(numbers []int64) string {
	numString := fmt.Sprint(numbers)
	numString = strings.Join(strings.Split(numString, " "), ",")
	return numString
}

func Int64SliceToStringSlice(numbers []int64) []string {
	var numStringSlice []string
	for _, number := range numbers {
		numStringSlice = append(numStringSlice, fmt.Sprint(number))
	}
	return numStringSlice
}

func Float64ToString(number float64, precision int) string {
	return strconv.FormatFloat(number, 'f', precision, 64)
}

func Float64ToStringWithPrec(number float64, prec int) string {
	return strconv.FormatFloat(number, 'f', prec, 64)
}

func ValidateStringAsInt64(stringValue string) error {
	_, err := number_utils.StringToInt64(stringValue)
	return err
}

func IsEmpty(sp *string) bool {
	if sp == nil {
		return true
	}

	return len(*sp) == 0
}

// StringTrimQuotes - trims quotes from a string (ie: "foo" will return foo)
func StringTrimQuotes(stringToTrim string) string {
	if len(stringToTrim) >= 2 {
		if stringToTrim[0] == '"' && stringToTrim[len(stringToTrim)-1] == '"' {
			return stringToTrim[1 : len(stringToTrim)-1]
		}
	}

	return stringToTrim
}

func KeyToHumanReadable(s string) string {
	s = strings.TrimSpace(s)

	re := regexp.MustCompile("(_|-)")
	s = re.ReplaceAllString(s, " ")

	return SentenceCase(string(s))
}

func SentenceCase(str string) string {
	if len(str) > 0 {
		str = strings.ToLower(str)
		r := []rune(str)
		return string(append([]rune{unicode.ToUpper(r[0])}, r[1:]...))
	}
	return ""
}

// SplitString separates a string on any character in the list of sep
func SplitString(str string, sep []rune) []string {
	splitStrings := strings.FieldsFunc(str, func(c rune) bool {
		return funk.Contains(sep, c)
	})

	return splitStrings
}

func LimitStringToMaxLength(str string, maxLen int) string {
	if len(str) > maxLen {
		str = str[0:maxLen]
	}
	return str
}

func PascalCaseToSentence(pascal string) string {
	var parts []string
	start := 0
	for end, r := range pascal {
		if end != 0 && unicode.IsUpper(r) {
			parts = append(parts, pascal[start:end])
			start = end
		}
	}
	if start != len(pascal) {
		parts = append(parts, pascal[start:])
	}
	sentence := strings.Join(parts, " ")
	return sentence

}

func PrettyJSON(jsonString string) (validJson bool, prettyString string) {
	var prettyJSON bytes.Buffer
	err := json.Indent(&prettyJSON, []byte(jsonString), "", " ")
	if err != nil {
		validJson = false
		prettyString = jsonString
	} else {
		validJson = true
		prettyString = prettyJSON.String()
	}
	return
}