package main

import (
	"hash/fnv"
	"strconv"
	"time"
)

func hashCompanyID(companyID string) uint32 {
	h := fnv.New32a()
	h.Write([]byte(companyID))
	return h.Sum32()
}

// parseDate 尝试解析时间字符串，支持 "2006-01-02 15:04:05" 和 "2006-01-02"
func parseDate(v interface{}) *time.Time {
	if str, ok := v.(string); ok && str != "" {
		t, err := time.Parse("2006-01-02 15:04:05", str)
		if err == nil {
			return &t
		}
		t, err = time.Parse("2006-01-02", str)
		if err == nil {
			return &t
		}
	}
	return nil
}

// strVal 返回字符串值，类型不是字符串或为空时返回空字符串
func strVal(v interface{}) string {
	if s, ok := v.(string); ok {
		return s
	}
	return ""
}

func strPtr(v interface{}) *string {
	if s, ok := v.(string); ok && s != "" {
		return &s
	}
	return nil
}

// fallbackNow 如果时间指针非空，返回其值，否则返回当前时间
func fallbackNow(t *time.Time) time.Time {
	if t != nil {
		return *t
	}
	return time.Now()
}

func parseInt16(v interface{}) int16 {
	switch t := v.(type) {
	case int32:
		return int16(t)
	case int:
		return int16(t)
	case float64:
		return int16(t)
	case int64:
		return int16(t)
	case string:
		if i, err := strconv.Atoi(t); err == nil {
			return int16(i)
		}
	}
	return 0
}

func getInt8Ptr(v interface{}) *int8 {
	if v == nil {
		return nil
	}
	switch val := v.(type) {
	case int8:
		return &val
	case int:
		tmp := int8(val)
		return &tmp
	case int32:
		tmp := int8(val)
		return &tmp
	case int64:
		tmp := int8(val)
		return &tmp
	case float64:
		tmp := int8(val)
		return &tmp
	case string:
		if i, err := strconv.Atoi(val); err == nil {
			tmp := int8(i)
			return &tmp
		}
	}
	return nil
}

// getInt8 将多种类型转换为 int8，无法转换时返回 0
func getInt8(v interface{}) int8 {
	switch t := v.(type) {
	case int:
		return int8(t)
	case int32:
		return int8(t)
	case int64:
		return int8(t)
	case float64:
		return int8(t)
	case string:
		if i, err := strconv.Atoi(t); err == nil {
			return int8(i)
		}
	}
	return 0
}

func int16Val(v interface{}) int16 {
	if v == nil {
		return 0
	}
	switch val := v.(type) {
	case int:
		return int16(val)
	case int64:
		return int16(val)
	case float64:
		return int16(val)
	case string:
		if i, err := strconv.Atoi(val); err == nil {
			return int16(i)
		}
	}
	return 0
}

func getIntPtr(v interface{}) *int {
	switch val := v.(type) {
	case int:
		return &val
	case int8:
		x := int(val)
		return &x
	case int16:
		x := int(val)
		return &x
	case int32:
		x := int(val)
		return &x
	case int64:
		x := int(val)
		return &x
	case float32:
		x := int(val)
		return &x
	case float64:
		x := int(val)
		return &x
	case string:
		if i, err := strconv.Atoi(val); err == nil {
			return &i
		}
	}
	return nil
}

func intVal(v interface{}) int {
	switch val := v.(type) {
	case int:
		return val
	case int8:
		return int(val)
	case int16:
		return int(val)
	case int32:
		return int(val)
	case int64:
		return int(val)
	case uint:
		return int(val)
	case uint8:
		return int(val)
	case uint16:
		return int(val)
	case uint32:
		return int(val)
	case uint64:
		return int(val)
	case float32:
		return int(val)
	case float64:
		return int(val)
	case string:
		if i, err := strconv.Atoi(val); err == nil {
			return i
		}
	case []byte:
		if i, err := strconv.Atoi(string(val)); err == nil {
			return i
		}
	case nil:
		return 0
	}
	return 0
}