package helper

import (
	"math/big"
	"strconv"
	"strings"
	"unicode"
	"unsafe"
)

type Str struct {
	value string
}

func NewStr(value string) *Str {
	return &Str{value: value}
}

//设置字符
func (s *Str) Set(v string) *Str {
	if v != "" {
		s.value = v
	} else {
		s.Clear()
	}
	return s
}

//将一个一维切片的值转化为字符串
func (s *Str) Join(glue string, pieces []string) *Str {
	s.value = NewSlice().Implode(glue, pieces)
	return s
}

//移除字符串两侧的空白字符或其他预定义字符
func (s *Str) Trim(characterMask ...string) *Str {
	if len(characterMask) == 0 {
		s.value = strings.TrimSpace(s.value)
	} else {
		s.value = strings.Trim(s.value, characterMask[0])
	}
	return s
}

//移除字符串左侧的空白字符或其他预定义字符
func (s *Str) Ltrim(characterMask ...string) *Str {
	if len(characterMask) == 0 {
		s.value = strings.TrimLeftFunc(s.value, unicode.IsSpace)
	} else {
		s.value = strings.TrimLeft(s.value, characterMask[0])
	}
	return s
}

//移除字符串右侧的空白字符或其他预定义字符
func (s *Str) Rtrim(characterMask ...string) *Str {
	if len(characterMask) == 0 {
		s.value = strings.TrimRightFunc(s.value, unicode.IsSpace)
	} else {
		s.value = strings.TrimRight(s.value, characterMask[0])
	}
	return s
}

//小写字母转大写
func (s *Str) Upper() *Str {
	s.value = strings.ToUpper(s.value)
	return s
}

//大写字母转小写
func (s *Str) Lower() *Str {
	s.value = strings.ToLower(s.value)
	return s
}

//首字符转换为大写
func (s *Str) Ucfirst() *Str {
	for _, v := range s.value {
		u := string(unicode.ToUpper(v))
		s.value = u + s.value[len(u):]
	}
	return s
}

//首字符转换为小写
func (s *Str) Lcfirst() *Str {
	for _, v := range s.value {
		u := string(unicode.ToLower(v))
		s.value = u + s.value[len(u):]
	}
	return s
}

//每个单词的首字符转换为大写
func (s *Str) Ucwords() *Str {
	s.value = strings.Title(s.value)
	return s
}

//查找字符串在另一字符串中第一次出现的位置 对大小写敏感
func (s *Str) Strpos(needle string, offset int) int {
	length := len(s.value)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	if offset < 0 {
		offset += length
	}
	pos := strings.Index(s.value[offset:], needle)
	if pos == -1 {
		return -1
	}
	return pos + offset
}

//查找字符串在另一字符串中第一次出现的位置（不区分大小写）
func (s *Str) Stripos(needle string, offset int) int {
	length := len(s.value)
	if length == 0 || offset > length || -offset > length {
		return -1
	}

	haystack := s.value[offset:]
	if offset < 0 {
		offset += length
	}
	pos := strings.Index(strings.ToLower(haystack), strings.ToLower(needle))
	if pos == -1 {
		return -1
	}
	return pos + offset
}

//查找字符串在另一字符串中最后一次出现的位置（区分大小写）
func (s *Str) Strrpos(needle string, offset int) int {
	pos, length := 0, len(s.value)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	var haystack string
	if offset < 0 {
		haystack = s.value[:offset+length+1]
	} else {
		haystack = s.value[offset:]
	}
	pos = strings.LastIndex(haystack, needle)
	if offset > 0 && pos != -1 {
		pos += offset
	}
	return pos
}

//查找字符串在另一字符串中最后一次出现的位置（不区分大小写）
func (s *Str) Strripos(needle string, offset int) int {
	pos, length := 0, len(s.value)
	if length == 0 || offset > length || -offset > length {
		return -1
	}
	var haystack string
	if offset < 0 {
		haystack = s.value[:offset+length+1]
	} else {
		haystack = s.value[offset:]
	}
	pos = strings.LastIndex(strings.ToLower(haystack), strings.ToLower(needle))
	if offset > 0 && pos != -1 {
		pos += offset
	}
	return pos
}

//字母下划线命名转换驼峰命名
func (s *Str) Camel() *Str {
	data := make([]byte, 0, len(s.value))
	flag, num := true, len(s.value)-1
	for i := 0; i <= num; i++ {
		d := s.value[i]
		if d == '_' {
			flag = true
			continue
		} else if flag {
			if d >= 'a' && d <= 'z' {
				d = d - 32
			}
			flag = false
		}
		data = append(data, d)
	}
	s.value = string(data[:])
	return s
}

//字母驼峰命名转换为下划线命名
func (s *Str) Snake() *Str {
	num := len(s.value)
	data := make([]byte, 0, num*2)
	j := false
	for i := 0; i < num; i++ {
		d := s.value[i]
		if i > 0 && d >= 'A' && d <= 'Z' && j {
			data = append(data, '_')
		}
		if d != '_' {
			j = true
		}
		data = append(data, d)
	}
	s.value = string(data[:])
	return s.Lower()
}

//将字符串转换为切片
func (s *Str) ToBytes() []byte {
	return *(*[]byte)(unsafe.Pointer(
		&struct {
			string
			Cap int
		}{s.value, len(s.value)},
	))
}

//转换为Bool
func (s *Str) ToBool() bool {
	if b, err := strconv.ParseBool(s.String()); err == nil {
		return b
	}
	return false
}

//转换为float32
func (s *Str) ToFloat32() float32 {
	if v, err := strconv.ParseFloat(s.String(), 32); err == nil {
		return float32(v)
	}
	return 0
}

//转换为float64
func (s *Str) ToFloat64() float64 {
	if f, err := strconv.ParseFloat(s.String(), 64); err == nil {
		return f
	}
	return 0
}

//转换为int
func (s *Str) ToInt() int {
	if i, err := strconv.ParseInt(s.String(), 10, 32); err == nil {
		return int(i)
	}
	return 0
}

//转换为int8
func (s *Str) ToInt8() int8 {
	if i, err := strconv.ParseInt(s.String(), 10, 8); err == nil {
		return int8(i)
	}
	return 0
}

//转换为int16
func (s *Str) ToInt16() int16 {
	if i, err := strconv.ParseInt(s.String(), 10, 16); err == nil {
		return int16(i)
	}
	return 0
}

//转换为int32
func (s *Str) ToInt32() int32 {
	if i, err := strconv.ParseInt(s.String(), 10, 32); err == nil {
		return int32(i)
	}
	return 0
}

//转换为int64
func (s *Str) ToInt64() int64 {
	v, err := strconv.ParseInt(s.String(), 10, 64)
	if err != nil {
		i := new(big.Int)
		ni, ok := i.SetString(s.String(), 10)
		if !ok {
			return 0
		}
		return ni.Int64()
	}
	return v
}

//转换为uint
func (s *Str) ToUint() uint {
	if i, err := strconv.ParseUint(s.String(), 10, 32); err == nil {
		return uint(i)
	}
	return 0
}

//转换为uint8
func (s *Str) ToUint8() uint8 {
	if i, err := strconv.ParseUint(s.String(), 10, 8); err == nil {
		return uint8(i)
	}
	return 0
}

//转换为uint16
func (s *Str) ToUint16() uint16 {
	if i, err := strconv.ParseUint(s.String(), 10, 16); err == nil {
		return uint16(i)
	}
	return 0
}

//转换为uint32
func (s *Str) ToUint32() uint32 {
	if i, err := strconv.ParseUint(s.String(), 10, 32); err == nil {
		return uint32(i)
	}
	return 0
}

//Md5
func (s *Str) ToMd5() *HashData {
	return NewHash([]byte(s.value)).Md5()
}

//Sha1
func (s *Str) ToSha1() *HashData {
	return NewHash([]byte(s.value)).Sha1()
}

//Sha256
func (s *Str) ToSha256() *HashData {
	return NewHash([]byte(s.value)).Sha256()
}

//Sha512
func (s *Str) ToSha512() *HashData {
	return NewHash([]byte(s.value)).Sha512()
}

//转换为uint64
func (s *Str) ToUint64() uint64 {
	v, err := strconv.ParseUint(s.String(), 10, 64)
	if err != nil {
		i := new(big.Int)
		ni, ok := i.SetString(s.String(), 10)
		if !ok {
			return 0
		}
		return ni.Uint64()
	}
	return v
}

//判断后缀
func (s *Str) HasSuffix(suffix string) bool {
	return strings.HasSuffix(s.value, suffix)
}

//判断前缀
func (s *Str) HasPrefix(prefix string) bool {
	return strings.HasSuffix(s.value, prefix)
}

//字符串分割
func (s *Str) Explode(delimiter string) []string {
	return strings.Split(s.value, delimiter)
}

func (s *Str) String() string {
	if s.Exist() {
		return s.value
	}
	return ""
}

//清除字符串
func (s *Str) Clear() {
	s.Set(string(0x1E))
}

//检查字符串是否存在
func (s *Str) Exist() bool {
	return s.value != string(0x1E)
}

//字符串组是否包含某字符串
func StringsContains(array []string, val string) (index int) {
	index = -1
	for i := 0; i < len(array); i++ {
		if array[i] == val {
			index = i
			return index
		}
	}
	return index
}