package string_utils

import (
	"bytes"
	"encoding/json"
	"fmt"
	"gitlab.bob.co.za/bob-public-utils/bobgroup-go-utils/errors"
	"net/mail"
	"net/url"
	"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
}

// StandardisePhoneNumber standardises phone numbers with +27 instead of 0 prefix
func StandardisePhoneNumber(number string) string {
	number = strings.TrimSpace(number)

	if number == "" {
		return number
	}

	// is the first rune/char of the string a 0
	if []rune(number)[0] == []rune("0")[0] {
		// Add south african country code (hardcoded for now)
		number = "+27" + number[1:]
	}
	return number
}

func FormatPhoneNumber(phoneNumber string) string {
	if len(phoneNumber) > 7 {
		return phoneNumber
	}

	// Format as 076 453 2188
	phoneNumber = insertInto(phoneNumber, 3, " ")
	phoneNumber = insertInto(phoneNumber, 7, " ")
	return phoneNumber
}

func insertInto(s string, index int, characters string) string {
	return s[:index] + characters + s[index:]
}

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 IsValidUsername(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))
}

func UnwrapString(s *string) string {
	if s == nil {
		return ""
	}
	return *s
}

// 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
}

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 StringToInt(stringValue string) (int, error) {
	return strconv.Atoi(stringValue)
}

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 StringToInt64(stringValue string) (int64, error) {
	number, err := strconv.ParseInt(stringValue, 10, 64)
	return number, err
}

func StringToFloat64(stringValue string) (float64, error) {
	number, err := strconv.ParseFloat(stringValue, 64)
	if err != nil {
		return 0, err
	}
	return number, nil
}

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 := StringToInt64(stringValue)
	return err
}

func PtoString(stringPointer *string) string {
	if stringPointer == nil {
		return ""
	}

	return *stringPointer
}

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 ""
}

// RemoveUrlScheme Removes http:// or https:// from a URL
func RemoveUrlScheme(str string) string {
	newStr := strings.Replace(str, "http://", "", 1)
	newStr = strings.Replace(str, "https://", "", 1)
	return newStr
}

// EscapeOpenSearchSearchString See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters
func EscapeOpenSearchSearchString(str string) string {
	searchString := str

	// Reserved characters
	// NOTE: first char must be "\" to prevent replacing it again after replacing other chars with "\\"
	reservedCharacters := []string{"\\", "+", "-", "=", "&&", "||", "!", "(", ")", "{", "}", "[", "]", "^", "\"", "~", "*", "?", ":", "/"}

	// Remove "<" and ">"
	strings.ReplaceAll(searchString, "<", "")
	strings.ReplaceAll(searchString, ">", "")

	// Escape the reserved characters with double backslashes ("\\")
	for _, char := range reservedCharacters {
		if strings.Contains(searchString, char) {
			re := regexp.MustCompile(char)
			searchString = re.ReplaceAllString(searchString, "\\"+char)
		}
	}
	return searchString
}

// 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
}

// IsUrlStrict Returns whether a URL is valid in a strict way (Must have scheme and host)
func IsUrlStrict(str string) bool {
	u, err := url.Parse(str)
	return err == nil && u.Scheme != "" && u.Host != ""
}

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

// StripQueryString - Strips the query parameters from a URL
func StripQueryString(inputUrl string) (string, error) {
	u, err := url.Parse(inputUrl)
	if err != nil {
		return inputUrl, err
	}
	u.RawQuery = ""
	return u.String(), nil
}

func ValidateEmailAddress(email string) (string, error) {
	if email == "" {
		return "", errors.Error("email address is empty")
	}

	cleanEmail := strings.ToLower(strings.TrimSpace(email))
	cleanEmail = RemoveAllWhiteSpaces(cleanEmail)

	// We validate it but still return it since in some cases we don't want to break everything if the email is bad
	_, err := mail.ParseAddress(cleanEmail)
	if err != nil {
		return cleanEmail, errors.Wrap(err, "could not parse email address")
	}

	return cleanEmail, nil
}

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
}