package webutility

  
  import (
  	"fmt"

  	"strconv"

  	"strings"
  )

  const sanitisationPatern = "\"';&*<>=\\`:"
  
  // SanitiseString removes characters from s found in patern and returns new modified string.
  func SanitiseString(s string) string {
  	return ReplaceAny(s, sanitisationPatern, "")
  }

  // IsWrappedWith ...
  func IsWrappedWith(src, begin, end string) bool {
  	return strings.HasPrefix(src, begin) && strings.HasSuffix(src, end)
  }
  
  // ParseInt64Arr ...
  func ParseInt64Arr(s, sep string) (arr []int64) {
  	s = strings.TrimSpace(s)
  	if s != "" {
  		parts := strings.Split(s, sep)
  		arr = make([]int64, len(parts))
  		for i, p := range parts {
  			num := StringToInt64(p)
  			arr[i] = num
  		}
  	}
  
  	return arr
  }
  
  // Int64SliceToString ...
  func Int64SliceToString(arr []int64) (s string) {

  	if len(arr) == 0 {
  		return ""
  	}
  
  	s += fmt.Sprintf("%d", arr[0])
  	for i := 1; i < len(arr); i++ {
  		s += fmt.Sprintf(",%d", arr[i])

  	}
  
  	return s
  }
  
  // CombineStrings ...
  func CombineStrings(s1, s2, s3 string) string {
  	s1 = strings.TrimSpace(s1)
  	s2 = strings.TrimSpace(s2)
  
  	if s1 != "" && s2 != "" {
  		s1 += s3 + s2
  	} else {
  		s1 += s2
  	}
  
  	return s1
  }
  
  // ReplaceAny replaces any of the characters from patern found in s with r and returns a new resulting string.
  func ReplaceAny(s, patern, r string) (n string) {
  	n = s
  	for _, c := range patern {
  		n = strings.Replace(n, string(c), r, -1)
  	}
  	return n
  }
  
  func StringToBool(s string) bool {

  	res, _ := strconv.ParseBool(s)
  	return res

  }
  
  func BoolToString(b bool) string {
  	return fmt.Sprintf("%b", b)
  }
  
  func StringSliceContains(slice []string, s string) bool {
  	for i := range slice {
  		if slice[i] == s {
  			return true
  		}
  	}
  	return false
  }

  
  func StringAt(s string, index int) string {
  	if len(s)-1 < index || index < 0 {
  		return ""
  	}
  
  	return string(s[index])
  }

  func SplitStringAtWholeWords(s string, maxLen int) (res []string) {
  	parts := strings.Split(s, " ")
  
  	res = append(res, parts[0])

  	i := 0

  	for j := 1; j < len(parts); j++ {
  		p := strings.TrimSpace(parts[j])
  		if len(p) > maxLen {
  			// TODO(marko): check if maxLen is >= 3
  			p = p[0 : maxLen-3]
  			p += "..."
  		}
  		if len(res[i])+len(p)+1 <= maxLen {
  			res[i] += " " + p
  		} else {
  			res = append(res, p)
  			i++
  		}

  	}

  
  	return res

  }