import scala.language.dynamics

class Foo extends scala.Dynamic {
  def selectDynamic(name: String): String = "selectDynamic(" + name + ")"
  def applyDynamic(name: String)(args: Any*): String = "applyDynamic(" + name + ")" + args.mkString("(", ", ", ")")
  def applyDynamicNamed(name: String)(args: (String, Any)*): String = "applyDynamicNamed(" + name + ")" + args.mkString("(", ", ", ")")
  def updateDynamic(name: String)(value: Any): String = "updateDynamic(" + name + ")(" + value + ")"
}

class Bar(self: String) extends scala.Dynamic {
  def selectDynamic(name: String): Bar = new Bar(self + ".selectDynamic(" + name + ")")
  def applyDynamic(name: String)(args: Any*): Bar = new Bar(self + ".applyDynamic(" + name + ")" + args.mkString("(", ", ", ")"))
  def applyDynamicNamed(name: String)(args: (String, Any)*): Bar = new Bar(self + ".applyDynamicNamed(" + name + ")" + args.mkString("(", ", ", ")"))
  def updateDynamic(name: String)(value: Any): Bar = new Bar(self + ".updateDynamic(" + name + ")(" + value + ")")
  def update(key: Int, value: Int): Bar = new Bar(self + ".update(" + key + ", " + value + ")")
  override def toString = self
}

class Baz extends scala.Dynamic {
  def selectDynamic(name: String): String = "selectDynamic(" + name + ")"
  def applyDynamic(name: String)(args: String*): String = "applyDynamic(" + name + ")" + args.mkString("(", ", ", ")")
  def applyDynamicNamed(name: String)(args: (String, Any)*): String = "applyDynamicNamed(" + name + ")" + args.mkString("(", ", ", ")")
  def updateDynamic(name: String)(value: String): String = "updateDynamic(" + name + ")(" + value + ")"
}

class Qux extends scala.Dynamic {
  def selectDynamic[T](name: String): String = "selectDynamic(" + name + ")"
  def applyDynamic[T](name: String)(args: String*): String = "applyDynamic(" + name + ")" + args.mkString("(", ", ", ")")
  def applyDynamicNamed[T](name: String)(args: (String, Any)*): String = "applyDynamicNamed(" + name + ")" + args.mkString("(", ", ", ")")
  def updateDynamic[T](name: String)(value: T): String = "updateDynamic(" + name + ")(" + value + ")"
}

object Test {
  val qux = new Qux

  implicit class StringUpdater(str: String) {
    def update(name: String, v: String) = s"$str.update(" + name + ", " + v + ")"
  }

  var failed = false

  def assertEquals(expected: String, actual: Any): Unit = {
    if (expected != actual.toString) {
      println("Error: expected <" + expected + "> but was <" + actual.toString + ">")
      failed = true
    }
  }

  def main(args: Array[String]): Unit = {
    runFooTests1()
    runFooTests2()
    runBarTests()
    runBazTests()
    runQuxTests()
    assert(!failed)
  }

  /** Test the basics of the transfomation rules. */
  def runFooTests1() = {
    val foo = new Foo

    assertEquals("selectDynamic(bazSelect)", foo.bazSelect)

    assertEquals("applyDynamic(bazApply)()", foo.bazApply())
    assertEquals("applyDynamic(bazApply)(1)", foo.bazApply(1))
    assertEquals("applyDynamic(bazApply)(1, 2, 3)", foo.bazApply(1, 2, 3))
    assertEquals("applyDynamic(bazApply)(1, 2, a)", foo.bazApply(1, 2, "a"))
    assertEquals("applyDynamic(bazApply)(1, 2, a)", foo.bazApply(List(1, 2, "a"): _*))

    assertEquals("applyDynamicNamed(bazApply)((a,1))", foo.bazApply(a = 1))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (b,2))", foo.bazApply(a = 1, b = 2))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (,0))", foo.bazApply(a = 1, 0))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (a,5))", foo.bazApply(a = 1, a = 5))
    assertEquals("applyDynamicNamed(bazApply)((,d), (a,1), (,5), (a,c))", foo.bazApply("d", a = 1, 5, a = 'c'))

    assertEquals("updateDynamic(bazUpdate)(abc)", foo.bazUpdate = "abc")

    assertEquals("selectDynamic(bazSelectUpdate).update(key, value)", foo.bazSelectUpdate("key") = "value")
  }

  /** Test implicit conversions kick in before dynamic calls. */
  def runFooTests2() = {
    implicit class Bar(foo: Foo) {
      def bazSelect: String = "Bar.bazSelect"
      def bazApply(args: Any*): String = args.mkString("Bar.bazApply(", ", ", ")")
      def bazApplyNamed(a: Int = -1, b: String = "-1"): String = "Bar.bazApplyNamed(" + a + ", " + b + ")"
    }

    val foo = new Foo

    assertEquals("Bar.bazSelect", foo.bazSelect)

    assertEquals("Bar.bazApply()", foo.bazApply())
    assertEquals("Bar.bazApply(1)", foo.bazApply(1))
    assertEquals("Bar.bazApply(1, 2, 3)", foo.bazApply(1, 2, 3))
    assertEquals("Bar.bazApply(1, 2, a)", foo.bazApply(1, 2, "a"))

    assertEquals("Bar.bazApplyNamed(1, -1)", foo.bazApplyNamed(a = 1))
    assertEquals("Bar.bazApplyNamed(1, 2)", foo.bazApplyNamed(a = 1, b = "2"))
    assertEquals("Bar.bazApplyNamed(1, abc)", foo.bazApplyNamed(a = 1, "abc"))

    assertEquals("selectDynamic(bazSelectUpdate).update(key, value)", foo.bazSelectUpdate("key") = "value")
  }

  /** Test cains of dynamic calls. */
  def runBarTests() = {
    val bar = new Bar("bar")

    // dynamics combined with themselfs
    assertEquals("bar.selectDynamic(select1).selectDynamic(select2).selectDynamic(select3)",
        bar.select1.select2.select3)
    assertEquals("bar.applyDynamic(apply1)().applyDynamic(apply2)().applyDynamic(apply3)()",
        bar.apply1().apply2().apply3())
    assertEquals("bar.applyDynamic(apply1)(1).applyDynamic(apply2)(1, 2).applyDynamic(apply3)(1, 2, 3)",
        bar.apply1(1).apply2(1, 2).apply3(1, 2, 3))
    assertEquals("bar.applyDynamicNamed(apply1)((a,1)).applyDynamicNamed(apply2)((,1), (b,2))",
        bar.apply1(a = 1).apply2(1, b = 2))
    assertEquals("bar.updateDynamic(update1)(1).updateDynamic(update2)(4)", (bar.update1 = 1).update2 = 4)
    assertEquals("bar.selectDynamic(update1).update(1, 2).selectDynamic(update2).update(3, 4)",
        (bar.update1(1) = 2).update2(3) = 4)

    // selectDynamic combined with every other dynamic
    assertEquals("bar.applyDynamic(apply1)().selectDynamic(select1)", bar.apply1().select1)
    assertEquals("bar.selectDynamic(select1).applyDynamic(apply2)()", bar.select1.apply2())
    assertEquals("bar.applyDynamicNamed(apply1)((a,1)).selectDynamic(select1)", bar.apply1(a = 1).select1)
    assertEquals("bar.selectDynamic(select1).applyDynamicNamed(apply1)((a,1))", bar.select1.apply1(a = 1))
    assertEquals("bar.updateDynamic(update1)(1).selectDynamic(select1)", (bar.update1 = 1).select1)
    assertEquals("bar.selectDynamic(select1).updateDynamic(update1)(1)", bar.select1.update1 = 1)
    assertEquals("bar.selectDynamic(update1).update(0, 1).selectDynamic(select1)", (bar.update1(0) = 1).select1)
    assertEquals("bar.selectDynamic(select1).selectDynamic(update1).update(0, 1)", bar.select1.update1(0) = 1)

    // applyDynamic combined with every remaninig dynamic
    assertEquals("bar.applyDynamic(apply1)().applyDynamicNamed(apply2)((a,1))", bar.apply1().apply2(a = 1))
    assertEquals("bar.applyDynamicNamed(apply1)((a,1)).applyDynamic(apply2)()", bar.apply1(a = 1).apply2())
    assertEquals("bar.applyDynamic(apply1)().updateDynamic(update1)(1)", bar.apply1().update1 = 1)
    assertEquals("bar.updateDynamic(update1)(1).applyDynamic(apply1)()", (bar.update1 = 1).apply1())
    assertEquals("bar.applyDynamic(apply1)().selectDynamic(update1).update(0, 1)", bar.apply1().update1(0) = 1)
    assertEquals("bar.selectDynamic(update1).update(0, 1).applyDynamic(apply1)()", (bar.update1(0) = 1).apply1())

    // applyDynamicNamed combined with every remaninig dynamic
    assertEquals("bar.applyDynamicNamed(apply1)((a,1)).updateDynamic(update1)(1)", bar.apply1(a = 1).update1 = 1)
    assertEquals("bar.updateDynamic(update1)(1).applyDynamicNamed(apply1)((a,1))", (bar.update1 = 1).apply1(a = 1))
    assertEquals("bar.applyDynamicNamed(apply1)((a,1)).selectDynamic(update1).update(0, 1)", bar.apply1(a = 1).update1(0) = 1)
    assertEquals("bar.selectDynamic(update1).update(0, 1).applyDynamicNamed(apply1)((a,1))", (bar.update1(0) = 1).apply1(a = 1))

    // updateDynamic combined selectDynamic(_).update(_, _)
    assertEquals("bar.updateDynamic(update1)(1).selectDynamic(update2).update(0, 1)", (bar.update1 = 1).update2(0) = 1)
    assertEquals("bar.selectDynamic(update1).update(0, 1).updateDynamic(update2)(1)", (bar.update1(0) = 1).update2 = 1)
  }

  /** Test implicit conversion in the arguments of the dynamic call. */
  def runBazTests() = {
    implicit def intToString(n: Int): String = n.toString

    val baz = new Baz

    assertEquals("applyDynamic(bazApply)()", baz.bazApply())
    assertEquals("applyDynamic(bazApply)(1)", baz.bazApply(1))
    assertEquals("applyDynamic(bazApply)(1, 2, 3)", baz.bazApply(1, 2, 3))
    assertEquals("applyDynamic(bazApply)(1, 2, a)", baz.bazApply(1, 2, "a"))

    assertEquals("applyDynamicNamed(bazApply)((a,1))", baz.bazApply(a = 1))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (b,2))", baz.bazApply(a = 1, b = 2))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (,0))", baz.bazApply(a = 1, 0))
    assertEquals("applyDynamicNamed(bazApply)((a,1), (a,5))", baz.bazApply(a = 1, a = 5))
    assertEquals("applyDynamicNamed(bazApply)((,4), (a,1), (,5), (a,9))", baz.bazApply(4, a = 1, 5, a = 9))

    assertEquals("updateDynamic(bazUpdate)(10)", baz.bazUpdate = 10)

    assertEquals("selectDynamic(bazSelectUpdate).update(key, 10)", baz.bazSelectUpdate("key") = 10)
    assertEquals("selectDynamic(bazSelectUpdate).update(7, value)", baz.bazSelectUpdate(7) = "value")
    assertEquals("selectDynamic(bazSelectUpdate).update(7, 10)", baz.bazSelectUpdate(7) = 10)
  }

  /** Test correct lifting of type parameters */
  def runQuxTests() = {
    implicit def intToString(n: Int): String = n.toString

    val qux = new Qux

    assertEquals("selectDynamic(quxSelect)", qux.quxSelect)
    assertEquals("selectDynamic(quxSelect)", qux.quxSelect[Int])

    assertEquals("applyDynamic(quxApply)()", qux.quxApply())
    assertEquals("applyDynamic(quxApply)()", qux.quxApply[Int]())
    assertEquals("applyDynamic(quxApply)(1)", qux.quxApply(1))
    assertEquals("applyDynamic(quxApply)(1)", qux.quxApply[Int](1))
    assertEquals("applyDynamic(quxApply)(1, 2, 3)", qux.quxApply(1, 2, 3))
    assertEquals("applyDynamic(quxApply)(1, 2, 3)", qux.quxApply[Int](1, 2, 3))
    assertEquals("applyDynamic(quxApply)(1, 2, a)", qux.quxApply(1, 2, "a"))
    assertEquals("applyDynamic(quxApply)(1, 2, a)", qux.quxApply[Int](1, 2, "a"))

    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1))", qux.quxApplyNamed(a = 1))
    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1))", qux.quxApplyNamed[Int](a = 1))
    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (b,2))", qux.quxApplyNamed(a = 1, b = "2"))
    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (b,2))", qux.quxApplyNamed[Int](a = 1, b = "2"))
    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (,abc))", qux.quxApplyNamed(a = 1, "abc"))
    assertEquals("applyDynamicNamed(quxApplyNamed)((a,1), (,abc))", qux.quxApplyNamed[Int](a = 1, "abc"))

    assertEquals("updateDynamic(quxUpdate)(abc)", qux.quxUpdate = "abc")

    assertEquals("selectDynamic(quxSelectUpdate).update(key, value)", qux.quxSelectUpdate("key") = "value")
    assertEquals("selectDynamic(quxSelectUpdate).update(key, value)", qux.quxSelectUpdate[Int]("key") = "value")
  }
}