// Operaciones Básicas con el Paquete Slices
// Demostración de las funciones principales del paquete slices: clonado, ordenamiento, compactación y búsqueda
package main
import (
	"fmt"
	"slices"
)
// demonstrateBasicOperations muestra Clone, Sort, Compact y Equal
// Clona un slice, lo ordena, compacta duplicados y compara con el original
func demonstrateBasicOperations() {
	original := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
	fmt.Println("Original:", original)
	// Usar slices.Clone() para crear copias independientes
	cloned := slices.Clone(original)
	slices.Sort(cloned) // Implementar slices.Sort() para ordenamiento type-safe
	fmt.Println("Cloned and Sorted:", cloned)
	// Aplicar slices.Compact() para eliminar duplicados
	compact := slices.Compact(cloned)
	fmt.Println("Compact (duplicates removed):", compact)
	// Mostrar slices.Equal() para comparaciones
	fmt.Println("Original equals cloned?", slices.Equal(original, cloned))
	fmt.Println("Original equals compact?", slices.Equal(original, compact))
}
// demonstrateSearch implementa búsqueda lineal y binaria
// Demuestra slices.Index() y slices.BinarySearch()
func demonstrateSearch() {
	data := []string{"apple", "banana", "cherry", "date", "elderberry"}
	fmt.Println("Data:", data)
	// Búsqueda lineal con slices.Index()
	index := slices.Index(data, "cherry")
	fmt.Println("Index of 'cherry':", index)
	// Ordenar para búsqueda binaria
	sorted := slices.Clone(data)
	slices.Sort(sorted)
	fmt.Println("Sorted:", sorted)
	// Búsqueda binaria con slices.BinarySearch()
	i, found := slices.BinarySearch(sorted, "date")
	fmt.Println("BinarySearch for 'date': index", i, "found:", found)
}
// processUserData caso práctico con datos de usuarios
// Procesa una lista de IDs de usuarios: clona, ordena, compacta y busca
func processUserData() {
	userIDs := []int{101, 203, 101, 405, 304, 203, 506}
	fmt.Println("User IDs original:", userIDs)
	cloned := slices.Clone(userIDs)
	slices.Sort(cloned)
	compact := slices.Compact(cloned)
	fmt.Println("Processed User IDs (sorted and unique):", compact)
	// Búsqueda
	index := slices.Index(compact, 203)
	fmt.Println("Index of user 203:", index)
	i, found := slices.BinarySearch(compact, 405)
	fmt.Println("BinarySearch for user 405: index", i, "found:", found)
	fmt.Println("Original equals processed?", slices.Equal(userIDs, compact))
}
func main() {
	fmt.Println("=== Basic Operations ===")
	demonstrateBasicOperations()
	fmt.Println("\n=== Search Operations ===")
	demonstrateSearch()
	fmt.Println("\n=== User Data Processing ===")
	processUserData()
}
// Output esperado:
// === Basic Operations ===
// Original: [3 1 4 1 5 9 2 6 5 3 5]
// Cloned and Sorted: [1 1 2 3 3 4 5 5 5 6 9]
// Compact (duplicates removed): [1 2 3 4 5 6 9]
// Original equals cloned? false
// Original equals compact? false
//
// === Search Operations ===
// Data: [apple banana cherry date elderberry]
// Index of 'cherry': 2
// Sorted: [apple banana cherry date elderberry]
// BinarySearch for 'date': index 3 found: true
//
// === User Data Processing ===
// User IDs original: [101 203 101 405 304 203 506]
// Processed User IDs (sorted and unique): [101 203 304 405 506]
// Index of user 203: 1
// BinarySearch for user 405: index 3 found: true
// Original equals processed? false

// Sistema de Análisis de Logs en Tiempo Real
// Pipeline de procesamiento que filtra, ordena y analiza logs de servidor usando el paquete slices
package main
import (
	"fmt"
	"math/rand"
	"runtime"
	"slices"
	"time"
)
// LogEntry struct con timestamp, level y message
type LogEntry struct {
	Timestamp time.Time
	Level     string
	Message   string
}
// Función para generar logs de ejemplo (10k+ entries)
func generateLogs(n int) []LogEntry {
	levels := []string{"INFO", "WARN", "ERROR"}
	logs := make([]LogEntry, n)
	for i := 0; i < n; i++ {
		ts := time.Now().Add(time.Duration(rand.Intn(3600)) * time.Second) // Timestamps aleatorios
		level := levels[rand.Intn(len(levels))]
		msg := fmt.Sprintf("Log message %d from service %d", i, rand.Intn(10))
		logs[i] = LogEntry{Timestamp: ts, Level: level, Message: msg}
	}
	// Introducir duplicados intencionalmente
	for i := 0; i < n/10; i++ {
		dupIndex := rand.Intn(n)
		logs = append(logs, logs[dupIndex])
	}
	return logs
}
// Función comparadora para SortFunc por timestamp
func compareByTimestamp(a, b LogEntry) int {
	if a.Timestamp.Before(b.Timestamp) {
		return -1
	} else if a.Timestamp.After(b.Timestamp) {
		return 1
	}
	return 0
}
// Función para CompactFunc: considera logs iguales si timestamp, level y message coinciden
func equalLogs(a, b LogEntry) bool {
	return a.Timestamp.Equal(b.Timestamp) && a.Level == b.Level && a.Message == b.Message
}
// Función para IndexFunc: busca patrones en message
func matchPattern(entry LogEntry) bool {
	return entry.Level == "ERROR" // Ejemplo: buscar logs de error
}
// processLogs procesa los logs: ordena, compacta, busca y genera métricas
func processLogs(logs []LogEntry) {
	startTime := time.Now()
	var memStats runtime.MemStats
	runtime.ReadMemStats(&memStats)
	startMem := memStats.Alloc
	// Usar slices.SortFunc() con comparador personalizado/por timestamp
	slices.SortFunc(logs, compareByTimestamp)
	// Aplicar slices.CompactFunc() para eliminar logs duplicados
	uniqueLogs := slices.CompactFunc(logs, equalLogs)
	// Implementar búsqueda de patrones con slices.IndexFunc()
	errorIndex := slices.IndexFunc(uniqueLogs, matchPattern)
	if errorIndex != -1 {
		fmt.Println("First error log:", uniqueLogs[errorIndex])
	}
	// Métricas de rendimiento y uso de memoria
	duration := time.Since(startTime)
	runtime.ReadMemStats(&memStats)
	memUsed := memStats.Alloc - startMem
	// Estadísticas de procesamiento
	fmt.Printf("Processed %d logs (unique: %d)\n", len(logs), len(uniqueLogs))
	fmt.Printf("Time taken: %v\n", duration)
	fmt.Printf("Memory used: %d bytes\n", memUsed)
	// Análisis simple: contar niveles
	counts := make(map[string]int)
	for _, log := range uniqueLogs {
		counts[log.Level]++
	}
	fmt.Println("Log level counts:", counts)
}
func main() {
	// Generar grandes volúmenes de datos (10k+ entries)
	logs := generateLogs(10000)
	fmt.Println("=== Processing Logs ===")
	processLogs(logs)
}
// Output esperado (aproximado, ya que incluye randomness):
// === Processing Logs ===
// First error log: {timestamp ERROR some message}
// Processed 11000 logs (unique: ~10000, depending on duplicates)
// Time taken: ~10ms (varies)
// Memory used: ~1MB (varies)
// Log level counts: map[ERROR:~3333 INFO:~3333 WARN:~3333]

// Ejemplos de Errores Comunes con el Paquete Slices
package main
import (
	"fmt"
	"slices"
)
// Error 1: Modificación accidental de slice original
// Descripción: No usar Clone() antes de modificar un slice compartido
// Consecuencias: Datos modificados inesperadamente en otras partes del código
// Código que demuestra el error
func errorNoClone() {
	original := []int{1, 2, 3}
	shared := original // No es una copia, solo referencia
	shared[0] = 99     // Modifica el original accidentalmente
	fmt.Println("Original after modification:", original) // Output: [99 2 3] - inesperado
}
// Solución: Siempre clonar slices antes de operaciones destructivas
func fixNoClone() {
	original := []int{1, 2, 3}
	cloned := slices.Clone(original) // Crea copia independiente
	cloned[0] = 99
	fmt.Println("Original after cloned modification:", original) // Output: [1 2 3] - correcto
	fmt.Println("Cloned:", cloned)                               // Output: [99 2 3]
}
// Error 2: Búsqueda binaria en slice no ordenado
// Descripción: Aplicar BinarySearch() sin ordenar previamente el slice
// Consecuencias: Resultados incorrectos y elementos no encontrados
// Código que demuestra el error
func errorBinarySearchUnsorted() {
	data := []int{3, 1, 4, 1, 5}
	i, found := slices.BinarySearch(data, 4) // Slice no ordenado
	fmt.Println("Index:", i, "Found:", found) // Output: posiblemente incorrecto, e.g., 0 false
}
// Solución: Verificar que el slice esté ordenado antes de búsqueda binaria
func fixBinarySearchUnsorted() {
	data := []int{3, 1, 4, 1, 5}
	sorted := slices.Clone(data)
	slices.Sort(sorted)                       // Ordenar primero
	i, found := slices.BinarySearch(sorted, 4)
	fmt.Println("Index:", i, "Found:", found) // Output: 3 true - correcto
}
// Error 3: Uso de funciones de comparación con tipos no-comparable
// Descripción: Intentar usar Index() o Equal() con slices de tipos no-comparable
// Consecuencias: Errores de compilación por constraints no satisfechas
// Código que demuestra el error (este no compilará, comentado para ilustrar)
// func errorNonComparable() {
// 	type Custom struct { Name string }
// 	data := []Custom{{Name: "a"}, {Name: "b"}}
// 	index := slices.Index(data, Custom{Name: "b"}) // Error: Custom no es comparable
// 	fmt.Println(index)
// }
// Solución: Usar funciones *Func() con comparadores personalizados para tipos complejos
func fixNonComparable() {
	type Custom struct{ Name string }
	data := []Custom{{Name: "a"}, {Name: "b"}, {Name: "c"}}
	// Comparador personalizado
	equalFunc := func(a, b Custom) bool { return a.Name == b.Name }
	index := slices.IndexFunc(data, func(c Custom) bool { return c.Name == "b" })
	fmt.Println("Index:", index) // Output: 1 - correcto
	another := []Custom{{Name: "a"}, {Name: "b"}}
	equal := slices.EqualFunc(data[:2], another, equalFunc)
	fmt.Println("Equal:", equal) // Output: true
}
func main() {
	fmt.Println("=== Error 1: No Clone ===")
	errorNoClone()
	fmt.Println("\n=== Fix 1: With Clone ===")
	fixNoClone()
	fmt.Println("\n=== Error 2: BinarySearch Unsorted ===")
	errorBinarySearchUnsorted()
	fmt.Println("\n=== Fix 2: Sort Before BinarySearch ===")
	fixBinarySearchUnsorted()
	fmt.Println("\n=== Fix 3: Using *Func for Non-Comparable ===")
	fixNonComparable()
}
// Output esperado:
// === Error 1: No Clone ===
// Original after modification: [99 2 3]
//
// === Fix 1: With Clone ===
// Original after cloned modification: [1 2 3]
// Cloned: [99 2 3]
//
// === Error 2: BinarySearch Unsorted ===
// Index: 0 Found: false  // Posible output incorrecto
//
// === Fix 2: Sort Before BinarySearch ===
// Index: 3 Found: true
//
// === Fix 3: Using *Func for Non-Comparable ===
// Index: 1
// Equal: true