// Package wrapper ...
//
// Description : wrapper ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2023-06-11 21:02
package wrapper

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"strings"
)

// ArrayType 数组实例
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 21:03 2023/6/11
func ArrayType(value interface{}) *Array {
	at := &Array{
		value: value,
	}
	_, _ = at.Convert()
	return at
}

// Array ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 21:05 2023/6/11
type Array struct {
	value         interface{}
	convertResult []interface{}
	convertErr    error
	isSimpleSlice bool         // 是否简单list, 即数据的每一项类型相同, 且都是基础内置数据类型
	itemType      reflect.Kind // 简单list场景下, 每一项的数据类型
}

// IsNil 输入是否为nil
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 21:11 2023/6/11
func (at *Array) IsNil() bool {
	return at.value == nil
}

// IsValid 检测是否为数组类型
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 21:06 2023/6/11
func (at *Array) IsValid() bool {
	if at.IsNil() {
		return false
	}
	byteData, err := json.Marshal(at.value)
	if nil != err {
		return false
	}
	return strings.HasPrefix(string(byteData), "[") && strings.HasSuffix(string(byteData), "]")
}

// ItemIsInterface 数组每一项是否为interface
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 21:20 2023/6/11
func (at *Array) ItemIsInterface() bool {
	if !at.IsValid() {
		return false
	}
	if _, ok := at.value.([]interface{}); ok {
		return true
	}
	return false
}

// Convert 类型转换
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 17:59 2023/6/12
func (at *Array) Convert() ([]interface{}, error) {
	if at.IsNil() {
		// 空指针
		at.convertResult = make([]interface{}, 0)
		return at.convertResult, nil
	}
	if !at.IsValid() {
		// 无效slice
		at.convertErr = errors.New("input slice is invalid")
		return nil, at.convertErr
	}
	switch val := at.value.(type) {
	case []int8:
		at.isSimpleSlice = true
		at.itemType = reflect.Int8
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []int16:
		at.isSimpleSlice = true
		at.itemType = reflect.Int16
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []int32:
		at.isSimpleSlice = true
		at.itemType = reflect.Int32
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []int64:
		at.isSimpleSlice = true
		at.itemType = reflect.Int64
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []int:
		at.isSimpleSlice = true
		at.itemType = reflect.Int
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []uint:
		at.isSimpleSlice = true
		at.itemType = reflect.Uint
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []uint8:
		at.isSimpleSlice = true
		at.itemType = reflect.Uint8
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []uint16:
		at.isSimpleSlice = true
		at.itemType = reflect.Uint16
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []uint32:
		at.isSimpleSlice = true
		at.itemType = reflect.Int32
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []uint64:
		at.isSimpleSlice = true
		at.itemType = reflect.Int64
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []float32:
		at.isSimpleSlice = true
		at.itemType = reflect.Float32
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []float64:
		at.isSimpleSlice = true
		at.itemType = reflect.Float64
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []bool:
		at.isSimpleSlice = true
		at.itemType = reflect.Bool
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []string:
		at.isSimpleSlice = true
		at.itemType = reflect.String
		at.convertResult = make([]interface{}, len(val))
		for i := 0; i < len(val); i++ {
			at.convertResult[i] = val[i]
		}
	case []interface{}:
		at.isSimpleSlice = false
		at.itemType = reflect.Interface
		at.convertResult = make([]interface{}, len(val))
		copy(at.convertResult, val)
	}
	return at.convertResult, nil
}

// ConvertIgnoreError 类型转换并忽略异常
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:07 2023/6/26
func (at *Array) ConvertIgnoreError() []interface{} {
	res, _ := at.Convert()
	return res
}

// Unique 对数据结果进行去重
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 17:43 2023/6/12
func (at *Array) Unique() []interface{} {
	result := make([]interface{}, 0)
	if at.isSimpleSlice {
		// 简单数据类型
		dataTable := make(map[string]bool)
		for _, item := range at.convertResult {
			k := fmt.Sprintf("%v", item)
			if _, exist := dataTable[k]; exist {
				continue
			}
			dataTable[k] = true
			result = append(result, item)
		}
		return result
	}
	return []interface{}{}
}

// Has 查询一个值是否在列表里, 在的话, 返回首次出现的索引, 不在返回-1
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:28 2023/7/31
func (at *Array) Has(input interface{}) int {
	for idx := 0; idx < len(at.convertResult); idx++ {
		if nil == input {
			if nil != at.convertResult[idx] {
				continue
			}
			return idx
		}
		if at.convertResult[idx] == nil {
			continue
		}
		if reflect.TypeOf(at.convertResult[idx]).String() != reflect.TypeOf(input).String() {
			// 类型不同
			continue
		}
		sourceByte, _ := json.Marshal(at.convertResult[idx])
		inputByte, _ := json.Marshal(input)
		if string(sourceByte) != string(inputByte) {
			continue
		}
		return idx
	}
	return -1
}