/*
Package utils 提供一些实用的辅助函数

这是一个示例包，用于演示包的创建和使用。
包含了数学计算、字符串处理、数据验证等常用功能。

使用示例：

	import "your-module/08-packages/utils"

	result := utils.Add(1, 2)
	greeting := utils.GetGreeting("World")
*/
package utils

import (
	"fmt"
	"math"
	"regexp"
	"strings"
	"time"
)

// 包级别的常量
const (
	// MaxRetries 最大重试次数
	MaxRetries = 3

	// DefaultTimeout 默认超时时间
	DefaultTimeout = 30 * time.Second

	// Version 包版本
	Version = "1.0.0"
)

// 包级别的变量
var (
	// PackageVersion 包版本（可修改）
	PackageVersion = "1.0.0"

	// emailRegex 邮箱验证正则表达式
	emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
)

// ========== 数学计算函数 ==========

// Add 计算两个整数的和
// 注意：函数名首字母大写，表示这是一个导出的（公开的）函数
func Add(a, b int) int {
	return a + b
}

// Subtract 计算两个整数的差
func Subtract(a, b int) int {
	return a - b
}

// Multiply 计算两个整数的乘积
func Multiply(a, b int) int {
	return a * b
}

// Divide 计算两个数的商，返回结果和错误
func Divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为零")
	}
	return a / b, nil
}

// Max 返回两个整数中的较大值
func Max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// Min 返回两个整数中的较小值
func Min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// Abs 返回整数的绝对值
func Abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

// Power 计算 base 的 exp 次方
func Power(base, exp int) int {
	result := 1
	for i := 0; i < exp; i++ {
		result *= base
	}
	return result
}

// ========== 字符串处理函数 ==========

// greet 是一个私有函数（首字母小写）
// 只能在包内部使用，外部无法访问
func greet(name string) string {
	return fmt.Sprintf("Hello, %s!", name)
}

// GetGreeting 是一个公开函数，内部调用私有函数
func GetGreeting(name string) string {
	return greet(name)
}

// Capitalize 将字符串首字母大写
func Capitalize(s string) string {
	if len(s) == 0 {
		return s
	}
	return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
}

// Reverse 反转字符串
func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

// IsPalindrome 检查字符串是否为回文
func IsPalindrome(s string) bool {
	s = strings.ToLower(strings.ReplaceAll(s, " ", ""))
	return s == Reverse(s)
}

// WordCount 统计字符串中的单词数量
func WordCount(s string) int {
	words := strings.Fields(s)
	return len(words)
}

// ========== 数据验证函数 ==========

// IsEmail 验证邮箱地址格式
func IsEmail(email string) bool {
	return emailRegex.MatchString(email)
}

// IsEmpty 检查字符串是否为空或只包含空白字符
func IsEmpty(s string) bool {
	return strings.TrimSpace(s) == ""
}

// InRange 检查数字是否在指定范围内
func InRange(value, min, max int) bool {
	return value >= min && value <= max
}

// IsPositive 检查数字是否为正数
func IsPositive(n int) bool {
	return n > 0
}

// IsEven 检查数字是否为偶数
func IsEven(n int) bool {
	return n%2 == 0
}

// IsOdd 检查数字是否为奇数
func IsOdd(n int) bool {
	return n%2 != 0
}

// ========== 切片操作函数 ==========

// Contains 检查切片是否包含指定元素
func Contains(slice []int, item int) bool {
	for _, v := range slice {
		if v == item {
			return true
		}
	}
	return false
}

// ContainsString 检查字符串切片是否包含指定字符串
func ContainsString(slice []string, item string) bool {
	for _, v := range slice {
		if v == item {
			return true
		}
	}
	return false
}

// RemoveDuplicates 移除整数切片中的重复元素
func RemoveDuplicates(slice []int) []int {
	keys := make(map[int]bool)
	var result []int

	for _, item := range slice {
		if !keys[item] {
			keys[item] = true
			result = append(result, item)
		}
	}

	return result
}

// Sum 计算整数切片的总和
func Sum(slice []int) int {
	total := 0
	for _, v := range slice {
		total += v
	}
	return total
}

// Average 计算整数切片的平均值
func Average(slice []int) float64 {
	if len(slice) == 0 {
		return 0
	}
	return float64(Sum(slice)) / float64(len(slice))
}

// ========== 时间处理函数 ==========

// FormatDuration 格式化时间间隔
func FormatDuration(d time.Duration) string {
	if d < time.Minute {
		return fmt.Sprintf("%.1f秒", d.Seconds())
	} else if d < time.Hour {
		return fmt.Sprintf("%.1f分钟", d.Minutes())
	} else if d < 24*time.Hour {
		return fmt.Sprintf("%.1f小时", d.Hours())
	} else {
		return fmt.Sprintf("%.1f天", d.Hours()/24)
	}
}

// IsWeekend 检查给定日期是否为周末
func IsWeekend(t time.Time) bool {
	weekday := t.Weekday()
	return weekday == time.Saturday || weekday == time.Sunday
}

// DaysUntil 计算距离指定日期还有多少天
func DaysUntil(target time.Time) int {
	now := time.Now()
	diff := target.Sub(now)
	return int(math.Ceil(diff.Hours() / 24))
}

// ========== 类型定义 ==========

// Point 表示二维坐标点
type Point struct {
	X, Y float64
}

// Distance 计算两点之间的距离
func (p Point) Distance(other Point) float64 {
	dx := p.X - other.X
	dy := p.Y - other.Y
	return math.Sqrt(dx*dx + dy*dy)
}

// String 实现 Stringer 接口
func (p Point) String() string {
	return fmt.Sprintf("Point(%.2f, %.2f)", p.X, p.Y)
}

// Rectangle 表示矩形
type Rectangle struct {
	Width, Height float64
}

// Area 计算矩形面积
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

// Perimeter 计算矩形周长
func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

// String 实现 Stringer 接口
func (r Rectangle) String() string {
	return fmt.Sprintf("Rectangle(%.2fx%.2f)", r.Width, r.Height)
}

// ========== 错误类型 ==========

// ValidationError 表示验证错误
type ValidationError struct {
	Field   string
	Message string
}

// Error 实现 error 接口
func (e ValidationError) Error() string {
	return fmt.Sprintf("验证错误 [%s]: %s", e.Field, e.Message)
}

// ========== 包初始化函数 ==========

// init 函数在包被导入时自动执行
func init() {
	// 可以在这里进行包的初始化工作
	// 例如：设置默认值、验证环境等
	fmt.Printf("utils 包已加载，版本: %s\n", Version)
}