sleep.go

package ditzy

import "sort"

// detectSleepBuckets finds sleep periods for a given timezone offset (hours).
// Returns the half-hour buckets (UTC) that represent sleep time.
// A rest period is defined as 4+ hours of continuous low activity (0-2 events)
// that preferably occurs at nighttime (21:00-09:00 local time).
func detectSleepBuckets(halfHourly map[float64]int, offsetHours float64) []float64 {
	// Calculate total activity for sparse data detection
	total := 0
	for _, count := range halfHourly {
		total += count
	}
	sparseData := total < 50

	// Find UTC hour for 21:00 (9pm) local time
	utcNightStart := 21.0 - offsetHours
	utcNightStart = normHour(utcNightStart)

	// Build search order: night hours first (21:00-09:00 local), then day
	searchOrder := make([]float64, 0, 48)
	for i := range 48 {
		h := normHour(utcNightStart + float64(i)*0.5)
		searchOrder = append(searchOrder, h)
	}

	// Find all candidate rest periods
	type period struct {
		buckets []float64
		score   float64
	}
	var candidates []period

	startThreshold := 1
	if sparseData {
		startThreshold = 0
	}

	for _, start := range searchOrder {
		// Skip buckets that don't exist in the data (missing != quiet)
		count, exists := halfHourly[start]
		if !exists || count > startThreshold {
			continue
		}

		buckets := findRestPeriod(halfHourly, start, offsetHours, total)
		if len(buckets) < 8 { // Need at least 4 hours
			continue
		}

		score := nighttimeScore(buckets, offsetHours)
		if sparseData && score == 0 {
			continue // Skip daytime periods for sparse data
		}

		candidates = append(candidates, period{buckets: buckets, score: score})
	}

	if len(candidates) == 0 {
		return nil
	}

	// Sort by nighttime score, then length
	sort.Slice(candidates, func(i, j int) bool {
		if candidates[i].score != candidates[j].score {
			return candidates[i].score > candidates[j].score
		}
		return len(candidates[i].buckets) > len(candidates[j].buckets)
	})

	best := candidates[0].buckets
	best = trimActiveEnd(best, halfHourly)
	best = trimActiveStart(best, halfHourly)
	sort.Float64s(best)

	return findLongestContinuous(best)
}

// findRestPeriod builds a continuous quiet period starting from startBucket.
func findRestPeriod(counts map[float64]int, start, offsetHours float64, total int) []float64 {
	var buckets []float64
	bucket := start
	prevCount := -1
	consecutiveLow := 0

	for len(buckets) < 24 { // Max 12 hours
		count, exists := counts[bucket]
		if !exists {
			break // Stop at missing data
		}
		localHour := normHour(bucket + offsetHours)

		// Work hours (9-17 local) with activity means wake up
		isWorkHours := localHour >= 9 && localHour < 17
		if isWorkHours && count >= 3 && len(buckets) >= 8 {
			break
		}

		// High activity breaks the period
		//nolint:nestif // sleep detection requires handling multiple edge cases
		if count > 5 {
			if len(buckets) >= 8 {
				break
			}
			buckets = nil
			prevCount = -1
			consecutiveLow = 0
		} else {
			// Track sustained low activity (2+ events)
			if count >= 2 {
				consecutiveLow++
			} else {
				if consecutiveLow >= 4 {
					trim := min(consecutiveLow, len(buckets))
					buckets = buckets[:len(buckets)-trim]
				}
				consecutiveLow = 0
			}

			// 4+ consecutive buckets with 2+ events = real work
			if consecutiveLow >= 4 && count >= 2 {
				trim := min(consecutiveLow-1, len(buckets))
				buckets = buckets[:len(buckets)-trim]
				break
			}

			// Check halting conditions
			if total < 50 {
				if count > 0 && prevCount >= 0 {
					break
				}
			} else {
				if (prevCount >= 2 && count >= 3) || (prevCount >= 3 && count >= 2) {
					if len(buckets) > 0 && prevCount >= 2 {
						buckets = buckets[:len(buckets)-1]
					}
					break
				}
			}

			buckets = append(buckets, bucket)
			prevCount = count
		}

		bucket = normHour(bucket + 0.5)
		if bucket == start {
			break
		}
	}

	return buckets
}

// nighttimeScore returns 0-1 indicating overlap with night hours (21:00-09:00 local).
func nighttimeScore(buckets []float64, offsetHours float64) float64 {
	nightCount, workCount := 0, 0

	for _, b := range buckets {
		localHour := normHour(b + offsetHours)

		if localHour >= 21 || localHour < 9 {
			nightCount++
		}
		if localHour >= 9 && localHour < 17 {
			workCount++
		}
	}

	// More than 30% during work hours = not sleep
	if float64(workCount)/float64(len(buckets)) > 0.3 {
		return 0
	}

	return float64(nightCount) / float64(len(buckets))
}

// trimActiveEnd removes buckets from the end that have 3+ events.
func trimActiveEnd(buckets []float64, counts map[float64]int) []float64 {
	for len(buckets) > 0 {
		last := buckets[len(buckets)-1]
		if counts[last] < 3 {
			break
		}
		buckets = buckets[:len(buckets)-1]
	}
	return buckets
}

// trimActiveStart removes buckets from the start until we find 2 consecutive quiet ones.
func trimActiveStart(buckets []float64, counts map[float64]int) []float64 {
	for len(buckets) > 1 {
		if counts[buckets[0]] <= 2 && counts[buckets[1]] <= 2 {
			break
		}
		buckets = buckets[1:]
	}
	return buckets
}

// findLongestContinuous extracts the longest continuous period from sorted buckets.
func findLongestContinuous(buckets []float64) []float64 {
	if len(buckets) == 0 {
		return nil
	}

	// Check for wraparound sleep (spans midnight)
	hasEvening := false
	hasMorning := false
	for _, b := range buckets {
		if b >= 22 {
			hasEvening = true
		}
		if b < 8 {
			hasMorning = true
		}
	}
	isWraparound := hasEvening && hasMorning

	var periods [][]float64
	current := []float64{buckets[0]}

	for i := 1; i < len(buckets); i++ {
		diff := buckets[i] - buckets[i-1]
		consecutive := diff <= 0.5

		// For wraparound, large gap (>12h) means we're at the midnight boundary
		if !consecutive && isWraparound && diff > 12 {
			consecutive = true
		}

		if consecutive {
			current = append(current, buckets[i])
		} else {
			if len(current) >= 7 {
				periods = append(periods, current)
			}
			current = []float64{buckets[i]}
		}
	}
	if len(current) >= 7 {
		periods = append(periods, current)
	}

	// Return the longest period
	var longest []float64
	for _, p := range periods {
		if len(p) > len(longest) {
			longest = p
		}
	}
	return longest
}

// normHour normalizes an hour value to the 0-24 range.
func normHour(h float64) float64 {
	for h < 0 {
		h += 24
	}
	for h >= 24 {
		h -= 24
	}
	return h
}