libraryDependencies ++= Seq(
  "org.gnieh" %% "fs2-data-csv" % "1.11.1",
  "org.gnieh" %% "fs2-data-csv-generic" % "1.11.1", // Para derivación automática
  "co.fs2" %% "fs2-core" % "3.12.2",
  "co.fs2" %% "fs2-io" % "3.12.2"
)

import cats.effect._                      // El motor funcional: gestiona hilos, recursos y ejecución segura.
import fs2.io.file.{Files, Path}          // El sistema de archivos: permite leer y escribir archivos en el disco.
import fs2.data.csv._                     // El parseador: define las reglas para procesar filas y columnas de CSV.
import fs2.data.csv.generic.semiauto._    // El automatizador: mapea automáticamente columnas de CSV a objetos Scala.

case class CovidProvinceStats(provinceId: String, deaths: Int, confirmedCases: Int)

val lojaStats = CovidProvinceStats("11", 1400, 2909)

case class CovidProviceStats(provinceId: String, deaths: Int, confirmedCases: Int)

lojaStats.provinceId

val lojaStats = CovidProvinceStats("11", 1400, 2909)

case Class CovidProvinceStats(pronviceId: String, deaths: Int, confirmedCases: Int)

case Class CovidProvinceStats(pronviceId: String, deaths: Int, confirmedCases: Int)

package bim2.semana11

import cats.effect.{IO, IOApp}
import fs2.text
import fs2.io.file.{Files, Path}
import fs2.data.csv.*
import fs2.data.csv.generic.semiauto.*

// Case class con nombres iguales a los headers del CSV
case class Goleador(
                     JUGADOR: String,
                     CLUB: String,
                     NACIONALIDAD: String,
                     GOLES: Int,
                     AUTOGOL: String
                   )

// Derivación automática del decoder
// Aprende cómo convertir una fila de texto a un objeto de tipo Goleador
given CsvRowDecoder[Goleador, String] = deriveCsvRowDecoder[Goleador]

object LeerGoleadores extends IOApp.Simple:
  val filePath = Path("src/main/resources/data/goleadores.csv")

  val run: IO[Unit] =
    Files[IO]
      .readAll(filePath)
      .through(text.utf8.decode)
      .through(decodeUsingHeaders[Goleador](';'))
      .compile
      .toList
      .flatMap { goleadores =>
        // Estadísticas
        val totalGoleadores = goleadores.length
        val goles = goleadores.map(_.GOLES)
        val promedioGoles = goles.sum / totalGoleadores.toDouble
        val maxGoles = goles.max
        val goleadorMax = goleadores.find(_.GOLES == maxGoles).get

        // Imprimir resultados
        IO.println(s"Total de goleadores: $totalGoleadores") >>
          IO.println(s"Promedio de goles: $promedioGoles") >>
          IO.println(s"Máximo goleador: ${goleadorMax.JUGADOR} con $maxGoles goles")

      }

case class Movies(
                   adult: Boolean,
                   belongs_to_collection: String,
                   budget: Int,
                   ....
                   )
                   

case class Goleador(JUGADOR: String, GOLES: Int)
// Si GOLES está vacío → Error: unable to decode '' as an integer

case class Goleador(JUGADOR: String, GOLES: Option[Int])
// Si GOLES está vacío → None
// Si GOLES tiene valor → Some(10)

given CellDecoder[Option[Int]] = CellDecoder.stringDecoder.map { s =>
  s.trim.toIntOption  // Retorna None si falla, Some(valor) si es válido
}

package bim2.semana11.presentacion

package bim2.semana11

import cats.effect.{IO, IOApp}
import cats.syntax.all.* // <-- Agregar este import
import fs2.text
import fs2.io.file.{Files, Path}
import fs2.data.csv.*
import fs2.data.csv.generic.semiauto.*

// Case class con GOLES como Option[Int]
case class Goleador(
                     JUGADOR: String,
                     CLUB: String,
                     NACIONALIDAD: String,
                     GOLES: Option[Int],
                     AUTOGOL: String
                   )

// CellDecoder personalizado para Option[Int]
given CellDecoder[Option[Int]] = CellDecoder.stringDecoder.map { s =>
  s.trim.toIntOption
}

// Derivación automática del decoder
given CsvRowDecoder[Goleador, String] = deriveCsvRowDecoder[Goleador]

object LeerGoleadoresOption extends IOApp.Simple:
  val filePath = Path("src/main/resources/data/goleadores.csv")

  val run: IO[Unit] =
    Files[IO]
      .readAll(filePath)
      .through(text.utf8.decode)
      .through(decodeUsingHeaders[Goleador](';'))
      .compile
      .toList
      .flatMap { goleadores =>
        val golesValidos = goleadores.flatMap(_.GOLES)
        val goleadoresConDatos = goleadores.filter(_.GOLES.isDefined)
        val goleadoresSinDatos = goleadores.filter(_.GOLES.isEmpty)

        val totalGoleadores = goleadores.length
        val promedioGoles = if (golesValidos.nonEmpty)
          golesValidos.sum / golesValidos.length.toDouble
        else 0.0
        val maxGoles = golesValidos.maxOption.getOrElse(0)
        val goleadorMax = goleadores.find(_.GOLES.contains(maxGoles))

        IO.println(s"Total de goleadores: $totalGoleadores") >>
          IO.println(s"Goleadores con datos válidos: ${goleadoresConDatos.length}") >>
          IO.println(s"Goleadores con datos inválidos: ${goleadoresSinDatos.length}") >>
          IO.println(s"Promedio de goles: $promedioGoles") >>
          goleadorMax.fold(
            IO.println("No se encontró máximo goleador")
          )(g => IO.println(s"Máximo goleador: ${g.JUGADOR} con $maxGoles goles")) >>
          IO.println("\nRegistros con datos inválidos:") >>
          goleadoresSinDatos.traverse_(g =>
            IO.println(s"  - ${g.JUGADOR} (${g.CLUB})")
          )
      }