// Package cpu provides CPU stress testing with multiple algorithms and chaos modes.
package cpu

import (
	"context"
	"crypto/md5"
	"crypto/sha256"
	"math"
	"sort"
)

// algorithms.go implements all CPU stress algorithms (prime, matrix, hash, etc.).

func (s *Stresser) stressPrime(ctx context.Context, n int) {
	count := 0
	for i := 2; count < n; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		if isPrime(i) {
			count++
		}
	}
}

func isPrime(n int) bool {
	if n < 2 {
		return false
	}
	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func (s *Stresser) stressMatrix(ctx context.Context, size int) {
	if size < 10 {
		size = 10
	}
	if size > 200 {
		size = 200
	}

	a := make([][]float64, size)
	b := make([][]float64, size)
	for i := range a {
		a[i] = make([]float64, size)
		b[i] = make([]float64, size)
		for j := range a[i] {
			a[i][j] = float64(i+j) * 0.5
			b[i][j] = float64(i*j) * 0.3
		}
	}

	c := make([][]float64, size)
	for i := range c {
		c[i] = make([]float64, size)
		for j := range c[i] {
			select {
			case <-ctx.Done():
				return
			default:
			}
			sum := 0.0
			for k := 0; k < size; k++ {
				sum += a[i][k] * b[k][j]
			}
			c[i][j] = sum
		}
	}
}

func (s *Stresser) stressHash(ctx context.Context, iterations int) {
	data := make([]byte, 1024)
	for i := range data {
		data[i] = byte(i % 256)
	}

	for i := 0; i < iterations; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		sha256.Sum256(data)
		md5.Sum(data)
	}
}

func (s *Stresser) stressBitwise(ctx context.Context, iterations int) {
	var result uint64 = 0
	for i := 0; i < iterations*100; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		result ^= uint64(i) << (i % 64)
		result |= result >> 3
		result &= result << 7
		result += result ^ 0x5555555555555555
		result = (result << 13) | (result >> 51)
	}
	_ = result
}

func (s *Stresser) stressFloat(ctx context.Context, iterations int) {
	x := 1.0
	for i := 0; i < iterations*10; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		x = math.Sin(x) + math.Cos(x*0.5)
		x = math.Sqrt(math.Abs(x)) + math.Exp(x*0.01)
		x = math.Atan(x) + math.Log(math.Abs(x)+1)
	}
	_ = x
}

func (s *Stresser) stressRecurse(ctx context.Context, n int) {
	if n > 35 {
		n = 35
	}
	_ = fibonacci(n)
}

func fibonacci(n int) int {
	if n <= 1 {
		return n
	}
	return fibonacci(n-1) + fibonacci(n-2)
}

func (s *Stresser) stressCompress(ctx context.Context, iterations int) {
	data := make([]byte, 1024)
	for i := range data {
		data[i] = byte((i * 7) % 256)
	}

	for i := 0; i < iterations; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		hash := md5.Sum(data)
		data = append(data, hash[:]...)
		if len(data) > 10240 {
			data = data[:1024]
		}
	}
}

func (s *Stresser) stressEncrypt(ctx context.Context, iterations int) {
	key := make([]byte, 32)
	data := make([]byte, 256)
	for i := range data {
		data[i] = byte(i % 256)
	}

	for i := 0; i < iterations; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		hash := sha256.Sum256(append(key, data...))
		data = hash[:]
	}
}

func (s *Stresser) stressSort(ctx context.Context, size int) {
	if size < 100 {
		size = 100
	}
	if size > 10000 {
		size = 10000
	}

	data := make([]int, size)
	for i := range data {
		data[i] = s.rand.Intn(1000000)
	}

	sort.Ints(data)
}

func (s *Stresser) stressBusy(ctx context.Context, iterations int) {
	var sum int64 = 0
	for i := 0; i < iterations*1000; i++ {
		select {
		case <-ctx.Done():
			return
		default:
		}
		sum += int64(i * i)
		sum = sum % 1000000007
	}
	_ = sum
}