/*
 * @Author: lixu lixu@puchigames.com
 * @Date: 2025-09-18 10:05:00
 * @LastEditors: lixu lixu@puchigames.com
 * @LastEditTime: 2025-09-18 10:05:00
 * @FilePath: /go-helper/utils/math.go
 * @Description: 数学工具函数，包含基础数学运算、数值处理等功能
 */

package ixUtils

import (
	"math"
)

// ========== 基础数学函数 ==========

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

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

// MaxInt64 返回两个64位整数中的最大值
func MaxInt64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

// MinInt64 返回两个64位整数中的最小值
func MinInt64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// MaxFloat64 返回两个浮点数中的最大值
func MaxFloat64(a, b float64) float64 {
	return math.Max(a, b)
}

// MinFloat64 返回两个浮点数中的最小值
func MinFloat64(a, b float64) float64 {
	return math.Min(a, b)
}

// Max 泛型版本的最大值函数
func Max[T int | int64 | float64](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// Min 泛型版本的最小值函数
func Min[T int | int64 | float64](a, b T) T {
	if a < b {
		return a
	}
	return b
}

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

// AbsInt64 返回64位整数的绝对值
func AbsInt64(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}

// AbsFloat64 返回浮点数的绝对值
func AbsFloat64(f float64) float64 {
	return math.Abs(f)
}

// Abs 泛型版本的绝对值函数
func Abs[T int | int64 | float64](n T) T {
	if n < 0 {
		return -n
	}
	return n
}

// Round 四舍五入到指定精度
func Round(f float64, precision int) float64 {
	ratio := math.Pow(10, float64(precision))
	return math.Round(f*ratio) / ratio
}

// Ceil 向上取整
func Ceil(f float64) int {
	return int(math.Ceil(f))
}

// Floor 向下取整
func Floor(f float64) int {
	return int(math.Floor(f))
}

// ========== 数值处理函数 ==========

// InRangeInt 检查整数是否在指定范围内（包含边界）
func InRangeInt(value, min, max int) bool {
	return value >= min && value <= max
}

// InRangeFloat64 检查浮点数是否在指定范围内（包含边界）
func InRangeFloat64(value, min, max float64) bool {
	return value >= min && value <= max
}

// InRange 泛型版本的范围检查
func InRange[T int | int64 | float64](value, min, max T) bool {
	return value >= min && value <= max
}

// ClampInt 将整数限制在指定范围内
func ClampInt(value, min, max int) int {
	if value < min {
		return min
	}
	if value > max {
		return max
	}
	return value
}

// ClampFloat64 将浮点数限制在指定范围内
func ClampFloat64(value, min, max float64) float64 {
	if value < min {
		return min
	}
	if value > max {
		return max
	}
	return value
}

// Clamp 泛型版本的数值限制
func Clamp[T int | int64 | float64](value, min, max T) T {
	if value < min {
		return min
	}
	if value > max {
		return max
	}
	return value
}

// PercentageInt 计算整数百分比
func PercentageInt(part, total int) float64 {
	if total == 0 {
		return 0
	}
	return float64(part) / float64(total) * 100
}

// PercentageFloat64 计算浮点数百分比
func PercentageFloat64(part, total float64) float64 {
	if total == 0 {
		return 0
	}
	return part / total * 100
}

// Percentage 泛型版本的百分比计算
func Percentage[T int | int64 | float64](part, total T) float64 {
	if total == 0 {
		return 0
	}
	return float64(part) / float64(total) * 100
}

// AverageInt 计算整数数组的平均值
func AverageInt(numbers []int) float64 {
	if len(numbers) == 0 {
		return 0
	}

	var sum int
	for _, num := range numbers {
		sum += num
	}

	return float64(sum) / float64(len(numbers))
}

// AverageFloat64 计算浮点数数组的平均值
func AverageFloat64(numbers []float64) float64 {
	if len(numbers) == 0 {
		return 0
	}

	var sum float64
	for _, num := range numbers {
		sum += num
	}

	return sum / float64(len(numbers))
}

// Average 泛型版本的平均值计算
func Average[T int | int64 | float64](numbers []T) float64 {
	if len(numbers) == 0 {
		return 0
	}

	var sum T
	for _, num := range numbers {
		sum += num
	}

	return float64(sum) / float64(len(numbers))
}

// ========== 扩展数学函数 ==========

// SumInt 计算整数数组的总和
func SumInt(numbers []int) int {
	var sum int
	for _, num := range numbers {
		sum += num
	}
	return sum
}

// SumFloat64 计算浮点数数组的总和
func SumFloat64(numbers []float64) float64 {
	var sum float64
	for _, num := range numbers {
		sum += num
	}
	return sum
}

// Sum 泛型版本的求和
func Sum[T int | int64 | float64](numbers []T) T {
	var sum T
	for _, num := range numbers {
		sum += num
	}
	return sum
}

// MaxSliceInt 返回整数数组中的最大值
func MaxSliceInt(numbers []int) int {
	if len(numbers) == 0 {
		return 0
	}

	max := numbers[0]
	for _, num := range numbers[1:] {
		if num > max {
			max = num
		}
	}
	return max
}

// MinSliceInt 返回整数数组中的最小值
func MinSliceInt(numbers []int) int {
	if len(numbers) == 0 {
		return 0
	}

	min := numbers[0]
	for _, num := range numbers[1:] {
		if num < min {
			min = num
		}
	}
	return min
}

// MaxSlice 泛型版本的数组最大值
func MaxSlice[T int | int64 | float64](numbers []T) T {
	if len(numbers) == 0 {
		var zero T
		return zero
	}

	max := numbers[0]
	for _, num := range numbers[1:] {
		if num > max {
			max = num
		}
	}
	return max
}

// MinSlice 泛型版本的数组最小值
func MinSlice[T int | int64 | float64](numbers []T) T {
	if len(numbers) == 0 {
		var zero T
		return zero
	}

	min := numbers[0]
	for _, num := range numbers[1:] {
		if num < min {
			min = num
		}
	}
	return min
}

// PowerInt 整数幂运算
func PowerInt(base, exp int) int {
	if exp == 0 {
		return 1
	}
	if exp == 1 {
		return base
	}

	result := 1
	for i := 0; i < exp; i++ {
		result *= base
	}
	return result
}

// PowerFloat64 浮点数幂运算
func PowerFloat64(base, exp float64) float64 {
	return math.Pow(base, exp)
}

// Sqrt 平方根
func Sqrt(f float64) float64 {
	return math.Sqrt(f)
}

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

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

// GCD 计算最大公约数
func GCD(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

// LCM 计算最小公倍数
func LCM(a, b int) int {
	return a * b / GCD(a, b)
}