package webutility

  
  import (
  	"fmt"
  	"strings"
  )
  
  // 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) {
  	for i, num := range arr {
  		if i == 0 {
  			s += fmt.Sprintf("%d", num)
  		} else {
  			s += fmt.Sprintf(",%d", num)
  		}
  	}
  
  	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 {
  	s = strings.ToLower(s)
  	if s == "true" {
  		return true
  	}
  	return false
  }
  
  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 SplitStringAfterN(s string, n, count int) (parts []string) {
  	rem := s
  	i := 0
  	for len(rem) > n && (i < count || count < 0) {
  		parts = append(parts, rem[0:n])
  		rem = rem[n:]
  		i++
  	}
  	parts = append(parts, rem)
  	return parts
  }