package commands

import (
  "bufio"
  "fmt"
  "os"
  "strings"
)

// ShowMenu simplemente muestra las opciones disponibles.
func ShowMenu() {
  fmt.Println("--- Calculadora de Gastos ---")
  fmt.Println("1. Añadir gastos")
  fmt.Println("2. Mostrar detalles")
  fmt.Println("3. Guardar reporte en archivo")
  fmt.Println("4. Leer reporte de archivo")
  fmt.Println("0. Salir")
  fmt.Println("-----------------------------")
}

// GetUserInput lee una línea de texto del usuario de forma segura.
// Usamos bufio.Scanner porque es más simple y robusto para leer líneas.
func GetUserInput(prompt string) (string, error) {
  fmt.Print(prompt)
  scanner := bufio.NewScanner(os.Stdin)
  if scanner.Scan() {
    return strings.TrimSpace(scanner.Text()), nil
  }
  if err := scanner.Err(); err != nil {
    return "", fmt.Errorf("error leyendo la entrada del usuario: %w", err)
  }
  // Se llega aquí si el usuario presiona Ctrl+D (EOF)
  return "", fmt.Errorf("entrada cancelada")
}

// FileExists comprueba si un archivo existe. Es una función de utilidad muy común.
func FileExists(filename string) bool {
  _, err := os.Stat(filename)
  // La forma idiomática en Go es usar os.IsNotExist para comprobar esto.
  return !os.IsNotExist(err)
}

// ReadFile lee todo el contenido de un archivo. Ahora devuelve un error en lugar de imprimirlo.
// Esto le da el control al que llama (main.go) para decidir qué hacer con el error.
func ReadFile(nameFile string) (string, error) {
  if !FileExists(nameFile) {
    return "", fmt.Errorf("el archivo '%s' no existe", nameFile)
  }

  content, err := os.ReadFile(nameFile)
  if err != nil {
    return "", fmt.Errorf("error al leer el archivo '%s': %w", nameFile, err)
  }

  return string(content), nil
}

// SaveToFile guarda el contenido en un archivo. También devuelve un error.
// Usamos os.WriteFile que es más simple para este caso.
func SaveToFile(content string, nameFile string) error {
  err := os.WriteFile(nameFile, []byte(content), 0644)
  if err != nil {
    return fmt.Errorf("error al crear el archivo '%s': %w", nameFile, err)
  }
  return nil
}

package expenses

import (
  "fmt"
  "Apps/App_cli_calc_expenses/commands"
  "strconv"
  "strings"
)

type Stats struct {
  Total   float64
  Average float64
  Min     float64
  Max     float64
}

// CaptureExpenses se encarga de recibir los gastos del usuario.
func CaptureExpenses() ([]float64, error) {
  var expensesList []float64

  fmt.Println("Introduce los gastos uno por uno. Escribe 'fin' para terminar.")

  for {
    input, err := commands.GetUserInput("Gasto: ")
    if err != nil {
      return nil, err // Propagamos el error hacia arriba
    }

    if strings.ToLower(input) == "fin" {
      fmt.Println("...volviendo al menú.")
      break
    }

    expense, err := strconv.ParseFloat(input, 64)
    if err != nil {
      fmt.Println("Valor inválido. Por favor, introduce un número (ej: 25.50).")
      continue // Pedimos el siguiente valor
    }

    expensesList = append(expensesList, expense)
  }

  return expensesList, nil
}

// GenerateStats calcula todas las estadísticas de una lista de gastos.

func GenerateStats(expenses []float64) (Stats, error) {
  if len(expenses) == 0 {
    return Stats{}, fmt.Errorf("no hay gastos para calcular estadísticas")
  }

  var stats Stats
  stats.Min = expenses[0] // Inicializamos min y max con el primer valor
  stats.Max = expenses[0]

  for _, expense := range expenses {
    stats.Total += expense
    if expense > stats.Max {
      stats.Max = expense
    }
    if expense < stats.Min {
      stats.Min = expense
    }
  }
  stats.Average = stats.Total / float64(len(expenses))

  return stats, nil
}

// FormatDetails crea el string del reporte final.
func FormatDetails(expenses []float64, stats Stats) string {
  var builder strings.Builder

  builder.WriteString("--- Reporte de Gastos ---\n")
  for i, expense := range expenses {
    builder.WriteString(fmt.Sprintf("Gasto #%d: %.2f\n", i+1, expense))
  }
  builder.WriteString("---------------------------\n")
  builder.WriteString(fmt.Sprintf("Total:   %.2f\n", stats.Total))
  builder.WriteString(fmt.Sprintf("Promedio: %.2f\n", stats.Average))
  builder.WriteString(fmt.Sprintf("Mínimo:  %.2f\n", stats.Min))
  builder.WriteString(fmt.Sprintf("Máximo:  %.2f\n", stats.Max))
  builder.WriteString("---------------------------\n")

  return builder.String()
}

package main

import (
  "fmt"
  "Apps/App_cli_calc_expenses/commands"
  "Apps/App_cli_calc_expenses/expenses"
)

func main() {
  var data []float64

  for {
    commands.ShowMenu()
    choice, err := commands.GetUserInput("Elige una opción: ")
    if err != nil {
      fmt.Println("Error: ", err)
      break
    }

    switch choice {
    case "1":
      // Capturamos nuevos gastos. Si hay error, lo mostramos y continuamos.
      newExpenses, err := expenses.CaptureExpenses()
      if err != nil {
        fmt.Printf("No se pudieron capturar los gastos: %v\n", err)
        continue
      }
      data = newExpenses
      if len(data) > 0 {
        fmt.Println("¡Gastos capturados! Usa la opción 2 para ver los detalles.")
      }

    case "2":
      if len(data) == 0 {
        fmt.Println("Aún no has añadido gastos. Usa la opción 1.")
        continue
      }
      stats, err := expenses.GenerateStats(data)
      if err != nil {
        fmt.Println("Error al generar detalles:", err)
        continue
      }
      fmt.Println(expenses.FormatDetails(data, stats))

    case "3":
      if len(data) == 0 {
        fmt.Println("Nada que guardar. Usa la opción 1 para añadir gastos.")
        continue
      }
      fileName, _ := commands.GetUserInput("Nombre del archivo (ej: mis_gastos.txt): ")
      if fileName == "" {
        fileName = "gastos.txt" // Nombre por defecto
        fmt.Println("Nombre vacío, usando 'gastos.txt'")
      }

      stats, _ := expenses.GenerateStats(data)
      content := expenses.FormatDetails(data, stats)

      err := commands.SaveToFile(content, fileName)
      if err != nil {
        fmt.Printf("Error al guardar el archivo: %v\n", err)
      } else {
        fmt.Printf("¡Reporte guardado exitosamente en '%s'!\n", fileName)
      }

    case "4":
      fileName, _ := commands.GetUserInput("Nombre del archivo a leer: ")
      if fileName == "" {
        fmt.Println("Debes ingresar un nombre de archivo.")
        continue
      }

      content, err := commands.ReadFile(fileName)
      if err != nil {
        fmt.Printf("Error al leer el archivo: %v\n", err)
      } else {
        fmt.Println("\n--- Contenido de", fileName, "---")
        fmt.Println(content)
      }

    case "0":
      fmt.Println("Hasta luego!!! Cerrando la aplicación...")
      return // La forma correcta de salir del bucle y terminar main

    default:
      fmt.Println("Opción no válida. Por favor, intenta de nuevo.")
    }
    // Una pausa visual antes de volver a mostrar el menú
    fmt.Println()
  }
}