import scala.compiletime.ops.int.S
import scala.compiletime.ops.string.+
import scala.deriving.Mirror
import scala.annotation.{implicitNotFound}

object genrec {
  /** Fold a tuple just like Tuple.Fold but with typed upper bounds */
  type TupleFold[T <: Tuple, UpperBound, Z <: UpperBound, F[_ <: UpperBound, _ <: UpperBound] <: UpperBound] <: UpperBound = T match
    case EmptyTuple => Z
    case h *: t => F[Z, TupleFold[t, UpperBound, h, F]]

  
  type TupleReduce[Tup <: Tuple, UpperBound, F[_ <: UpperBound, _ <: UpperBound] <: UpperBound] <: UpperBound = Tup match {
    case h *: t => TupleFold[t, UpperBound, h, F]
  }

  /** Map a tuple just like Tuple.Map but with typed upper bounds */
  type TupleMap[T <: Tuple, UpperBound, F[_ <: UpperBound]] <: Tuple = T match
    case EmptyTuple => EmptyTuple
    case h *: t => F[h] *: TupleMap[t, UpperBound, F]


  /*erased*/ trait TypeWitness[N]:
    type T = N
  /*erased*/ given [T]: TypeWitness[T] = null
  object opaques {
    @scala.annotation.showAsInfix
    opaque type @@[S <: String & Singleton, +T] >: T = T

    extension [T <: String & Singleton](t: T) def @@[V](v: V): T @@ V = v
  }
  export opaques.*
  type FieldName[T <: @@[String & Singleton, Any]] <: String = T match {
    case @@[nme, _] => nme
  }
  type FieldNames[T <: Tuple] = TupleMap[T, @@[String & Singleton, Any], FieldName]
  type FieldType[T <: @@[String & Singleton, Any]] = T match {
    case @@[_, tpe] => tpe
  }

  type FieldToString[T <: @@[String & Singleton, Any]] <: String = T match {
    case @@[name, tpe] => name + ": " + tpe
  }

  extension [K <: String & Singleton, T](f: K @@ T) inline def value: T = f.asInstanceOf[T]

  type IndexOf[Rec <: Tuple, Field] <: Int = Rec match {
    case h *: t => h match { //use invariant type comparison by abusing Set trick
      case Field => 0
      case _ => S[IndexOf[t, Field]]
    }
  }
  type FieldToTuple[T <: @@[String & Singleton, Any]] <: Tuple = T match {
    case @@[nme, tpe] => (nme, tpe)
  }

  type IndexOfField[Rec <: Tuple, Field <: @@[String & Singleton, Any]] = IndexOf[Rec, Field]

  type WidenTuple[T <: Tuple] <: Tuple = T match {
    case EmptyTuple => EmptyTuple
    case h *: tail => h *: tail
  }

  given ProdOps: AnyRef with {
    extension [P <: Product](p: P)(using gen: Generic[P]) {
      def delField(field: String & Singleton)
          (using /*erased*/ w: TypeWitness[IndexOf[FieldNames[gen.Out], field.type]])
          (using i: ValueOf[w.T]): Tuple.Concat[Tuple.Take[gen.Out, w.T], Tuple.Drop[gen.Out, S[w.T]]] =
        val arr = scala.runtime.Tuples.toIArray(gen.toGen(p))
        val res = new Array[Object](arr.length - 1)
        System.arraycopy(arr, 0, res, 0, i.value)
        System.arraycopy(arr, i.value + 1, res, i.value, arr.length - i.value - 1)
        scala.runtime.Tuples.fromArray(res).asInstanceOf[Tuple.Concat[Tuple.Take[gen.Out, w.T], Tuple.Drop[gen.Out, S[w.T]]]]

      def renameField(field: String & Singleton, to: String & Singleton)
          (using /*erased*/ w: TypeWitness[IndexOf[FieldNames[gen.Out], field.type]])
          (using i: ValueOf[w.T]): Tuple.Concat[Tuple.Take[gen.Out, w.T], (to.type @@ FieldType[Tuple.Elem[gen.Out, w.T]]) *: Tuple.Drop[gen.Out, S[w.T]]] =
        gen.toGen(p).asInstanceOf[Tuple.Concat[Tuple.Take[gen.Out, w.T], (to.type @@ FieldType[Tuple.Elem[gen.Out, w.T]]) *: Tuple.Drop[gen.Out, S[w.T]]]]
      
      def +[K <: String & Singleton, V](field: K @@ V): Tuple.Concat[gen.Out, (K @@ V) *: EmptyTuple] =
        gen.toGen(p) ++ (field *: EmptyTuple)

      def replaceField[NewValueType](field: String & Singleton)
          (using /*erased*/ w: TypeWitness[IndexOf[FieldNames[gen.Out], field.type]])
          (using i: ValueOf[w.T])
          (f: FieldType[Tuple.Elem[gen.Out, w.T]] => NewValueType): Tuple.Concat[Tuple.Take[gen.Out, w.T], (field.type @@ NewValueType) *: Tuple.Drop[gen.Out, S[w.T]]] =
        val res = scala.runtime.Tuples.toArray(gen.toGen(p))
        val prev = res(i.value).asInstanceOf[FieldType[Tuple.Elem[gen.Out, w.T]]]
        val newv = f(prev)
        res(i.value) = newv.asInstanceOf[Object]
        scala.runtime.Tuples.fromArray(res).asInstanceOf[Tuple.Concat[Tuple.Take[gen.Out, w.T], (field.type @@ NewValueType) *: Tuple.Drop[gen.Out, S[w.T]]]]

      def toProd[Prd <: Product](using m: Mirror.ProductOf[Prd]): m.MirroredMonoType = m.fromProduct(gen.toGen(p))

      def select(fieldName: String & Singleton)(using s: SelectByName[fieldName.type, gen.Out]): s.Out = s.apply(gen.toGen(p))[fieldName.type]

      def field(fieldName: String & Singleton)
          (using /*erased*/ w: TypeWitness[IndexOf[FieldNames[gen.Out], fieldName.type]])
          (using i: ValueOf[w.T]): Tuple.Elem[gen.Out, w.T] =
        p.productElement(i.value).asInstanceOf[Tuple.Elem[gen.Out, w.T]]

      def pruneTo[Tup2 <: Tuple](using sr: SubRow[gen.Out, Tup2]): Tup2 = sr.asSubRecord(gen.toGen(p))

      def transmogrify[P2 <: Product](using gen2: Generic[P2], sr: SubRow[gen.Out, gen2.Out], m: Mirror.ProductOf[P2]): P2 = m.fromProduct(sr.asSubRecord(gen.toGen(p)))
    }
  }

  trait Generic[Prod <: Product] {
    type Out <: Tuple
    def toGen(prod: Prod): Out

    extension (prod: Prod) def gen: Out = toGen(prod)
  }
  object Generic extends GenericLowPriority {
    type Aux[Prod <: Product, _Out <: Tuple] = Generic[Prod] { type Out = _Out}

    transparent inline def of[Prod <: Product] = scala.compiletime.summonInline[Generic[Prod]]

    type IsRecord[Rec <: Tuple] = Rec match {
      case EmptyTuple => true
      case a *: tail => a match {
        case @@[?, ?] => IsRecord[tail]
        case _ => false
      }
    }

    private val identityGeneric = new Generic[Tuple] {
      type Out = Tuple
      def toGen(t: Tuple) = t
    }

    given tuplesGeneric[Rec <: Tuple](using IsRecord[Rec] =:= true): Generic.Aux[Rec, Rec] = identityGeneric.asInstanceOf[Generic.Aux[Rec, Rec]]
  }
  trait GenericLowPriority { self: Generic.type =>
    given productsGeneric[Prod <: Product](using m: Mirror.ProductOf[Prod]): Generic.Aux[
      Prod,
      WidenTuple[Tuple.Map[Tuple.Zip[m.MirroredElemLabels, m.MirroredElemTypes], [Entry] =>> Entry match {
        case (nme, tpe) => nme @@ tpe
      }]]
    ] = new Generic[Prod] {
      type Out = WidenTuple[Tuple.Map[Tuple.Zip[m.MirroredElemLabels, m.MirroredElemTypes], [Entry] =>> Entry match {
        case (nme, tpe) => nme @@ tpe
      }]]
      def toGen(prod: Prod): Out =
        val r = prod.productIterator.map(v => ("s" @@ v).asInstanceOf[Object]).toArray
        scala.runtime.Tuples.fromArray(r).asInstanceOf[Out]
    }
  }

  type FieldSet[Rec <: Tuple] = Tuple.Union[Tuple.Map[Rec, FieldToTuple]]
  type MissingFields[Rec <: Tuple, AvailableFields] <: Tuple = Rec match {
    case EmptyTuple => EmptyTuple
    case h *: t => FieldToTuple[h] match {
      case AvailableFields => MissingFields[t, AvailableFields]
      case _ => h *: MissingFields[t, AvailableFields]
    }
  }


  /** Read field [[Field]]  from [[Rec]] */
  @implicitNotFound("Field with name ${Field} is not present in ${Rec}")
  trait SelectByName[Field <: String & Singleton, Rec <: Tuple] {
    type Out
    extension (r: Rec) def apply[F <: Field]: Out
  }
  object SelectByName {
    type Aux[Field <: String & Singleton, Rec <: Tuple, O] = SelectByName[Field, Rec] { type Out = O }

    given [T, Field <: String & Singleton, Rec <: Tuple]
        // (using /*erased*/ w: TypeWitness[IndexOf[TupleMap[Rec, @@[String & Singleton, Any], FieldName], Field]])
        (using /*erased*/ w: TypeWitness[IndexOf[Tuple.Map[Rec, FieldName], Field]])
        (using v: ValueOf[w.T]): Aux[Field, Rec, FieldType[Tuple.Elem[Rec, w.T]]] = new SelectByName[Field, Rec] {
      type Out = FieldType[Tuple.Elem[Rec, w.T]]
      extension (r: Rec) def apply[F <: Field] = r.productElement(v.value).asInstanceOf[@@[Field, Out]].value
    }
  }

  /** Typeclass denoting that [[T]] is a subrow of [[Rec]], this allows to select every field from [[Rec]] in [[T]] */
  @implicitNotFound("can't prove that ${T} is a subrow of ${Rec}")
  trait SubRow[T, Rec <: Tuple] {

    /** Read [[FieldName] value
      * Note: the SelectByName is /*erased*/, it's only there to ensure via the compiler that you're trying to read one of the
      * fields defined in the SubRow
      */
    extension (r: T)
      def apply[FieldName <: String & Singleton](using ValueOf[FieldName])(using /*erased*/ s: SelectByName[FieldName, Rec]): s.Out
      def asSubRecord: Rec
  }
  object SubRow {
    import scala.compiletime.*
    type Of[Rec <: Tuple] = [T] =>> SubRow[T, Rec]

    /** Developer API, don't use directly */
    class SubRowImpl[T <: Product, Rec <: Tuple](val fieldIndices: collection.immutable.SeqMap[String, Int], val recFields: IArray[String]) extends SubRow[T, Rec] {
      extension (r: T)
        def apply[FieldName <: String & Singleton](using ValueOf[FieldName])(using /*erased*/ s: SelectByName[FieldName, Rec]): s.Out =
          val i = fieldIndices(valueOf[FieldName])
          r.productElement(i).asInstanceOf[s.Out]

        def asSubRecord: Rec =
          val resContent = new Array[Object](recFields.size)
          recFields.zipWithIndex `foreach` ((f, i) => resContent(i) = r.productElement(fieldIndices(f)).asInstanceOf[Object])
          scala.runtime.Tuples.fromArray(resContent).asInstanceOf[Rec]
    }

    transparent inline given isSubRow[T <: Product, Rec <: Tuple]
      (using gen: Generic[T]): SubRow[T, Rec] = {
      inline erasedValue[MissingFields[Rec, FieldSet[gen.Out]]] match {
        case t: NonEmptyTuple =>
          inline val mf = valueOf[TupleReduce[FieldNames[t.type], String, [a <: String, b <: String] =>> a + "\n  " + b]]
          error("You have missing fields:\n  " + mf + "\nEnsure that these fields are present and that their types match")
          // error("You have missing fields:\nEnsure that these fields are present and that their types match")
        case _ =>
      }

      val labels = summonAll[TupleMap[gen.Out, @@[String & Singleton, Any], [x <: @@[String & Singleton, Any]] =>> ValueOf[FieldName[x]]]].toArray
      val recFields = summonAll[TupleMap[Rec, @@[String & Singleton, Any], [x <: @@[String & Singleton, Any]] =>> ValueOf[FieldName[x]]]].toIArray.map(_.asInstanceOf[ValueOf[String]].value)
      (SubRowImpl[T, Rec](labels.map(_.asInstanceOf[ValueOf[String]].value).zipWithIndex.to(collection.immutable.TreeSeqMap), recFields): SubRow[T, Rec])
    }

  }
}