package macros

import scala.language.experimental.macros
import scala.reflect.macros.whitebox.Context

trait TestMacro[T] {
  def check(row: List[Any]): Unit
  def map(row: List[Any]): T
  def unapply(obj: T): List[Any]
}

object TestMacro {

  implicit def method[T]: TestMacro[T] = macro methodImpl[T]

  def methodImpl[T: c.WeakTypeTag](c: Context): c.Expr[TestMacro[T]] = {
    import c.universe._

    val tpe = weakTypeOf[T]
    val decls = tpe.decls
    val ctor = decls.collectFirst { case m: MethodSymbol if m.isPrimaryConstructor => m}.get
    val params = ctor.paramLists.head
    val companion = tpe.typeSymbol.companion


    val typs = params.map(p => p.typeSignature)
    val vals = (1 to typs.length).map(x => TermName(s"v$x"))
    val patt = vals.zip(typs).map { case (v, t) => pq"$v: $t"}


    val unapplyVals = params.map {
      case p =>
        val valName = p.name.toTermName
        q"obj.$valName"
    }

    val check = typs.zipWithIndex.map {
      case (t, i) =>
        val typ = q"row($i).getClass.toString"
        q"""
            if(!row($i).isInstanceOf[$t])
              throw new Exception("Error mapping " + row + ", type: " + $typ +
              ${s", row($i) should be " + t.toString}
              )"""
    }

    c.Expr[TestMacro[T]] {
      q"""
        import scala.reflect.ClassTag
        import scala.reflect.runtime.universe._

        new TestMacro[$tpe] {

          val tt = implicitly[ClassTag[$tpe]]
          val rclass = tt.runtimeClass
          val ctor = rclass.getConstructors()(0)

          def check(row: List[Any]): Unit = {
            ..$check
          }

          def map(row: List[Any]): $tpe = {
            try {
              ctor.newInstance(row.map(_.asInstanceOf[Object]):_*).asInstanceOf[$tpe]
            } catch {
              case e: IllegalArgumentException => throw new Exception("can't map " + row)
            }
          }

          def unapply(obj: $tpe) = $unapplyVals
        }
      """
    }
  }
}