// common/common.go
package common

import (
	"crypto/rand"
	"encoding/base64"
	"errors"
	"fmt"
	"math/big"
	"os"
	"reflect"
	"strconv"
	"strings"
	"time"
)

// ---------------------- 环境变量操作 ----------------------
// 项目中最常用的通用能力，适配Docker容器化（环境变量传配置）
// GetEnv 读取环境变量，若不存在则返回默认值
func GetEnv(key, defVal string) string {
	val := os.Getenv(key)
	if val == "" {
		return defVal
	}
	return val
}

// GetEnvInt 读取环境变量并转换为int，转换失败/不存在返回默认值
func GetEnvInt(key string, defVal int) int {
	val := os.Getenv(key)
	if val == "" {
		return defVal
	}
	num, err := strconv.Atoi(val)
	if err != nil {
		return defVal
	}
	return num
}

// GetEnvBool 读取环境变量并转换为bool（支持1/0、true/false、on/off），失败/不存在返回默认值
func GetEnvBool(key string, defVal bool) bool {
	val := strings.ToLower(os.Getenv(key))
	switch val {
	case "1", "true", "on":
		return true
	case "0", "false", "off":
		return false
	default:
		return defVal
	}
}

// ---------------------- 类型转换 ----------------------
// 日常开发中频繁的类型转换，封装后避免重复写err判断
// StrToInt 字符串转int，失败返回0和错误
func StrToInt(s string) (int, error) {
	return strconv.Atoi(s)
}

// StrToInt64 字符串转int64，失败返回0和错误
func StrToInt64(s string) (int64, error) {
	return strconv.ParseInt(s, 10, 64)
}

// IntToStr int转字符串
func IntToStr(i int) string {
	return strconv.Itoa(i)
}

// Int64ToStr int64转字符串
func Int64ToStr(i int64) string {
	return strconv.FormatInt(i, 10)
}

// StrToFloat64 字符串转float64，失败返回0和错误
func StrToFloat64(s string) (float64, error) {
	return strconv.ParseFloat(s, 64)
}

// Float64ToStr float64转字符串，保留n位小数
func Float64ToStr(f float64, n int) string {
	format := fmt.Sprintf("%%.%df", n)
	return fmt.Sprintf(format, f)
}

// ---------------------- 时间通用处理 ----------------------
// 统一项目时间格式，避免各业务自定义格式导致的混乱
const (
	// TimeFormatYmdHms 常规时间格式：2006-01-02 15:04:05（Go诞生时间，固定模板）
	TimeFormatYmdHms = "2006-01-02 15:04:05"
	// TimeFormatYmd 日期格式：2006-01-02
	TimeFormatYmd = "2006-01-02"
	// TimeFormatHms 时间格式：15:04:05
	TimeFormatHms = "15:04:05"
	// TimeFormatYmdHmsS 带毫秒的时间格式：2006-01-02 15:04:05.000
	TimeFormatYmdHmsS = "2006-01-02 15:04:05.000"
)

// TimeToStr 时间转字符串，指定格式（不传则用默认YmdHms）
func TimeToStr(t time.Time, format ...string) string {
	ft := TimeFormatYmdHms
	if len(format) > 0 && format[0] != "" {
		ft = format[0]
	}
	// 转换为本地时区（避免UTC时间偏移）
	return t.In(time.Local).Format(ft)
}

// NowToStr 当前时间转字符串，指定格式（不传则用默认YmdHms）
func NowToStr(format ...string) string {
	return TimeToStr(time.Now(), format...)
}

// StrToTime 字符串转时间，指定格式（不传则用默认YmdHms），失败返回零值和错误
func StrToTime(s string, format ...string) (time.Time, error) {
	ft := TimeFormatYmdHms
	if len(format) > 0 && format[0] != "" {
		ft = format[0]
	}
	return time.ParseInLocation(ft, s, time.Local)
}

// GetDayStart 获取某天的开始时间（如2026-02-06 00:00:00）
func GetDayStart(t time.Time) time.Time {
	year, month, day := t.In(time.Local).Date()
	return time.Date(year, month, day, 0, 0, 0, 0, time.Local)
}

// GetDayEnd 获取某天的结束时间（如2026-02-06 23:59:59.999999999）
func GetDayEnd(t time.Time) time.Time {
	year, month, day := t.In(time.Local).Date()
	return time.Date(year, month, day, 23, 59, 59, 999999999, time.Local)
}

// ---------------------- 空值判断 ----------------------
// 通用的空值检查，支持所有基础类型和引用类型，避免业务层重复写if判断
// IsEmpty 判断值是否为空（0/""//nil/空切片/空map等）
func IsEmpty(v interface{}) bool {
	if v == nil {
		return true
	}
	val := reflect.ValueOf(v)
	switch val.Kind() {
	case reflect.String:
		return val.String() == ""
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return val.Int() == 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return val.Uint() == 0
	case reflect.Float32, reflect.Float64:
		return val.Float() == 0
	case reflect.Bool:
		return !val.Bool()
	case reflect.Slice, reflect.Array:
		return val.Len() == 0
	case reflect.Map, reflect.Chan:
		return val.Len() == 0 || val.IsNil()
	case reflect.Ptr, reflect.Interface:
		return val.IsNil()
	default:
		return false
	}
}

// IsNotEmpty 判断值是否非空，与IsEmpty相反
func IsNotEmpty(v interface{}) bool {
	return !IsEmpty(v)
}

// ---------------------- 字符串通用处理 ----------------------
// 高频的字符串操作，封装后简化调用
// StrTrim 去除字符串两端的空格/制表符/换行符
func StrTrim(s string) string {
	return strings.TrimSpace(s)
}

// StrToLower 字符串转小写
func StrToLower(s string) string {
	return strings.ToLower(s)
}

// StrToUpper 字符串转大写
func StrToUpper(s string) string {
	return strings.ToUpper(s)
}

// StrIsIn 判断字符串是否在指定的切片中（忽略大小写）
func StrIsIn(s string, list []string) bool {
	s = StrToLower(s)
	for _, v := range list {
		if StrToLower(v) == s {
			return true
		}
	}
	return false
}

// StrJoin 拼接切片为字符串，指定分隔符
func StrJoin(list []string, sep string) string {
	return strings.Join(list, sep)
}

// ---------------------- 随机数/随机字符串 ----------------------
// 生成随机数、随机字符串（用于生成验证码、随机密码、唯一标识等）
// RandInt 生成[min, max]范围内的随机整数，失败返回0和错误
func RandInt(min, max int) (int, error) {
	if min > max {
		return 0, errors.New("min is greater than max")
	}
	// 基于crypto/rand生成安全随机数（比math/rand更安全，适合生产环境）
	num, err := rand.Int(rand.Reader, big.NewInt(int64(max-min+1)))
	if err != nil {
		return 0, err
	}
	return min + int(num.Int64()), nil
}

// RandStr 生成指定长度的随机字符串（数字+大小写字母），失败返回""和错误
func RandStr(length int) (string, error) {
	if length <= 0 {
		return "", errors.New("length must be greater than 0")
	}
	// 随机字符串源（可根据需求添加/移除字符，如去掉大写字母）
	chars := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	charsLen := big.NewInt(int64(len(chars)))
	result := make([]byte, length)
	for i := 0; i < length; i++ {
		// 逐个生成随机字符索引
		idx, err := rand.Int(rand.Reader, charsLen)
		if err != nil {
			return "", err
		}
		result[i] = chars[idx.Int64()]
	}
	return string(result), nil
}

// RandNumStr 生成指定长度的纯数字随机字符串，失败返回""和错误
func RandNumStr(length int) (string, error) {
	if length <= 0 {
		return "", errors.New("length must be greater than 0")
	}
	nums := "0123456789"
	numsLen := big.NewInt(int64(len(nums)))
	result := make([]byte, length)
	for i := 0; i < length; i++ {
		idx, err := rand.Int(rand.Reader, numsLen)
		if err != nil {
			return "", err
		}
		result[i] = nums[idx.Int64()]
	}
	return string(result), nil
}

// ---------------------- 其他通用工具 ----------------------
// GetCurrentDir 获取当前程序运行目录（适配Docker容器化，避免路径问题）
func GetCurrentDir() (string, error) {
	dir, err := os.Getwd()
	if err != nil {
		return "", fmt.Errorf("get current dir failed: %w", err)
	}
	return dir, nil
}

// MkdirIfNotExist 目录不存在则创建（支持多级目录），适配日志/文件存储
func MkdirIfNotExist(path string) error {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		// 0755：所有者读写执行，其他用户读执行，符合Linux/Docker权限规范
		if err := os.MkdirAll(path, 0755); err != nil {
			return fmt.Errorf("mkdir %s failed: %w", path, err)
		}
	}
	return nil
}