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: c.universe.Type = 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 = TermName(s"$tpe")



    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}
             )"""
    }

    val result = q"""
       new TestMacro[$tpe] {

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

         def map(row: List[Any]) = {
           row match {
             case List(..$patt) => $companion(..$vals)
             case _ => throw new Exception("Can not map " + row)
           }
         }

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

    """

    c.Expr[TestMacro[T]](result)
  }
}