jsonencoder.scala

import scala.deriving.Mirror
import jsonvalue.*

import scala.compiletime.{constValue, erasedValue}

case class Employee ( name: String, age: Int )

trait HelpersLabelledGeneric:

  trait JsonEncoder[A]:
    def encodeField(a: A): JsonValue

  type Row = List[JsonValue]

  trait RowEncoder[A]:
    def encodeRow(a: A): Row

  given JsonEncoder[Int] = JsonInt ( _ ) // when the trait has only one method.

  given JsonEncoder[String] with
    override def encodeField(a: String): JsonValue = JsonString(a)

  given RowEncoder[EmptyTuple] with
    override def encodeRow(a: EmptyTuple): Row = List.empty

  given [H: JsonEncoder, T <: Tuple: RowEncoder]: RowEncoder[ H *: T] with
    override def encodeRow(a: H *: T): Row =
      summon[JsonEncoder[H]].encodeField(a.head) :: summon[RowEncoder[T]].encodeRow(a.tail)

  def tupleToCsv[X : RowEncoder](tuple: X): List[JsonValue] =
    summon[RowEncoder[X]].encodeRow(tuple)

end HelpersLabelledGeneric

@main def hello(): Unit =

  trait Grid1:

    /** * to get the field name */
    inline def getElemLabels[A <: Tuple]: List[String] =
      inline erasedValue[A] match {
        case _: EmptyTuple => Nil
        case _: (head *: tail) =>
          val headElementLabel = constValue[head].toString
          val tailElementLabels = getElemLabels[tail]
          headElementLabel :: tailElementLabels
      }

    /**inline def getElemLabelsHelper[A <: Tuple](using m: Mirror.Of[A]) =
      getElemLabels[m.MirroredElemLabels]*/

    inline def getElemLabelsHelper[A](using m: Mirror.Of[A]) =
      getElemLabels[m.MirroredElemLabels]

    val helpersLabelledGeneric = new HelpersLabelledGeneric {}

    import helpersLabelledGeneric.RowEncoder

    def loadValues2[A: RowEncoder](a: List[A])(using m: Mirror.Of[A]): Unit =
      val nameFields = getElemLabels[m.MirroredElemLabels]
      //val namesFields = a.map( x => getElemLabelsHelper( x ) )
      val valores = a.map(b => summon[RowEncoder[A]].encodeRow(b))
      //val valoresAndFields = valores.map(namesFields.zip)
      //println(valoresAndFields)
    
    
    
    def loadValues[A](a: List[A], namesFields: List[String])(using jsonEncoder: RowEncoder[A]): Unit =
      val valores = a.map(b => helpersLabelledGeneric.tupleToCsv[A](b))
      val valoresAndFields = valores.map(namesFields.zip)
      println(valoresAndFields)
    
  end Grid1

  val helpersLabelledGeneric = new HelpersLabelledGeneric {}

  val grid1 = new Grid1 {}
  //val fields = helpersLabelledGeneric.getElemLabelsHelper[Employee]

  val lstEmployee = List(
    Employee("Bob1", 30),
    Employee("Jcesar", 49)
  )

  val lstEmployeeTuples = lstEmployee.map(Tuple.fromProductTyped)

  //grid1.loadValues(lstEmployeeTuples, fields)

  println("#" * 200)
  println("Esto esta más chingon")
  grid1.loadValues2(lstEmployeeTuples)
  println("#" * 200)