// Copyright (c) Facebook, Inc. and its affiliates.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.facebook.ktfmt

import com.google.common.truth.FailureMetadata
import com.google.common.truth.Subject
import com.google.common.truth.Truth.assertAbout
import com.google.common.truth.Truth.assertThat
import com.google.googlejavaformat.FormattingError
import org.junit.Ignore
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4

@Suppress("FunctionNaming")
@RunWith(JUnit4::class)
class FormatterKtTest {

  @Test
  fun `first selector stays on same line`() = assertFormatted(
      """
      |fun f() {
      |  ImmutableList.newBuilder()
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .build()
      |
      |  // ... unless it's a function call
      |  ImmutableList()
      |      .newBuilder()
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .add(1)
      |      .build()
      |}
      |""".trimMargin(), 50)

  @Test
  fun `line breaks in function arguments`() = assertFormatted(
      """
      |fun f() {
      |  computeBreaks(
      |      javaOutput.commentsHelper,
      |      maxWidth,
      |      Doc.State(+0, 0))
      |  computeBreaks(
      |      output.commentsHelper, maxWidth, State(0))
      |  doc.computeBreaks(
      |      javaOutput.commentsHelper,
      |      maxWidth,
      |      Doc.State(+0, 0))
      |  doc.computeBreaks(
      |      output.commentsHelper, maxWidth, State(0))
      |}
      |""".trimMargin(), 50)

  @Test
  fun `parameters and return type in function definitions`() = assertFormatted(
      """
      |fun format(
      |    code: String,
      |    maxWidth: Int =
      |        DEFAULT_MAX_WIDTH_VERY_LONG
      |): String {
      |  val a = 0
      |}
      |
      |fun print(
      |    code: String,
      |    maxWidth: Int =
      |        DEFAULT_MAX_WIDTH_VERY_LONG
      |) {
      |  val a = 0
      |}
      |""".trimMargin(), 40)

  @Test
  fun `kitchen sink of tests`() {
    // Don't add more tests here
    val code = """
        |fun
        |f  (
        |a : Int
        | , b: Double , c:String) {           var result = 0
        | val aVeryLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongVar = 43
        |          foo.bar.zed.accept(
        |
        |          )
        |
        |          foo(
        |
        |          )
        |
        |          foo.bar.zed.accept(
        |                DoSomething.bar()
        |          )
        |
        |          bar(
        |          ImmutableList.newBuilder().add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).build())
        |
        |
        |          ImmutableList.newBuilder().add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).add(1).build()
        |     }
        |""".trimMargin()

    val expected = """
        |fun f(a: Int, b: Double, c: String) {
        |  var result = 0
        |  val aVeryLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongVar =
        |      43
        |  foo.bar.zed.accept()
        |
        |  foo()
        |
        |  foo.bar.zed.accept(DoSomething.bar())
        |
        |  bar(
        |      ImmutableList.newBuilder()
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .add(1)
        |          .build())
        |
        |  ImmutableList.newBuilder()
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .add(1)
        |      .build()
        |}
        |""".trimMargin()

    assertThatFormatting(code).isEqualTo(expected)
    // Don't add more tests here
  }

  @Test
  fun `spacing around variable declarations`() = assertFormatted(
      """
      |fun f() {
      |  var x: Int = 4
      |  val y = 0
      |}
      |""".trimMargin())

  @Test
  fun `class without a body nor properties`() = assertFormatted("class Foo\n")

  @Test
  fun `interface without a body nor properties`() = assertFormatted("interface Foo\n")

  @Test
  fun `preserve empty primary constructor`() = assertFormatted("class Foo()\n")

  @Test
  fun `class without a body, with explicit ctor params`() =
      assertFormatted("class Foo(a: Int, var b: Double, val c: String)\n")

  @Test
  fun `class with a body and explicit ctor params`() = assertFormatted(
      """
      |class Foo(a: Int, var b: Double, val c: String) {
      |  val x = 2
      |  fun method() {}
      |  class Bar
      |}
      |""".trimMargin())

  @Test
  fun `properties and fields with modifiers`() = assertFormatted(
      """
      |class Foo(public val p1: Int, private val p2: Int, open val p3: Int, final val p4: Int) {
      |  private var f1 = 0
      |  public var f2 = 0
      |  open var f3 = 0
      |  final var f4 = 0
      |}
      |""".trimMargin())

  @Test
  fun `properties with multiple modifiers`() = assertFormatted(
      """
      |class Foo(public open inner val p1: Int) {
      |  public open inner var f2 = 0
      |}
      |""".trimMargin())

  @Test
  fun `spaces around binary operations`() = assertFormatted(
      """
      |fun foo() {
      |  a = 5
      |  x + 1
      |}
      |""".trimMargin())

  @Test
  fun `breaking long binary operations`() = assertFormatted(
      """
      |fun foo() {
      |  val finalWidth =
      |      value1 +
      |          value2 +
      |          (value3 +
      |              value4 +
      |              value5) +
      |          foo(v) +
      |          (1 + 2) +
      |          function(
      |              value7,
      |              value8) +
      |          value9
      |}
      |""".trimMargin(), 20)

  @Test
  fun `once a binary expression is broken, split on every line`() = assertFormatted(
      """
        |fun foo() {
        |  val sentence =
        |      "The" +
        |          "quick" +
        |          ("brown" + "fox") +
        |          "jumps" +
        |          "over" +
        |          "the" +
        |          "lazy" +
        |          "dog"
        |}
        |""".trimMargin(), 40)

  @Test
  fun `long binary expressions with ranges in the middle`() = assertFormatted(
      """
        |fun foo() {
        |  val sentence =
        |      "The" +
        |          "quick" +
        |          ("brown".."fox") +
        |          "jumps" +
        |          "over" +
        |          "the".."lazy" + "dog"
        |}
        |""".trimMargin(), 40)

  @Test
  fun `properties with accessors`() = assertFormatted(
      """
      |class Foo {
      |  var x: Int
      |    get() = field
      |  var y: Boolean
      |    get() = x.equals(123)
      |    set(value) {
      |      field = value
      |    }
      |  var z: Boolean
      |    get() {
      |      x.equals(123)
      |    }
      |  var zz = false
      |    private set
      |}
      |""".trimMargin())

  @Test
  fun `a property with a too long name being broken on multiple lines`() = assertFormatted(
      """
      |class Foo {
      |  val thisIsALongName
      |      : String =
      |      "Hello there this is long"
      |    get() = field
      |}
      |""".trimMargin(),
      maxWidth = 20)

  @Test
  fun `multi-character unary and binary operators such as ==`() = assertFormatted(
      """
      |fun f() {
      |  3 == 4
      |  true && false
      |  a++
      |  a === b
      |}
      |""".trimMargin())

  @Test
  fun `package names stay in one line`() {
    val code = """
      | package  com  .example. subexample
      |
      |fun f() = 1
      |""".trimMargin()
    val expected = """
      |package com.example.subexample
      |
      |fun f() = 1
      |""".trimMargin()

    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `safe dot operator expression`() = assertFormatted(
      """
      |fun f() {
      |  node?.name
      |}
      |""".trimMargin())

  @Test
  fun `safe dot operator expression with normal`() = assertFormatted(
      """
      |fun f() {
      |  node?.name.hello
      |}
      |""".trimMargin())

  @Test
  fun `safe dot operator expression chain in expression function`() = assertFormatted(
      """
      |fun f(number: Int) =
      |    Something.doStuff(number)?.size
      |""".trimMargin(), 50)
  
  @Test
  fun `import list`() {
    val code = """
      | import  com .example.common.reality. FooBar
      |  import  com .example.common.reality. FooBar2  as  foosBars
      |   import com .example.common.reality. *
      | import  foo.bar // Test
      |  import  abc.def /*
      |                  test */
      |""".trimMargin()
    val expected = """
      |import com.example.common.reality.FooBar
      |import com.example.common.reality.FooBar2 as foosBars
      |import com.example.common.reality.*
      |import foo.bar // Test
      |import abc.def /*
      |               test */
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `basic annotations`() = assertFormatted(
      """
      |@Fancy
      |class Foo {
      |  @Fancy
      |  fun baz(@Fancy foo: Int) {
      |    @Fancy val a = 1 + foo
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `function calls with multiple arguments`() = assertFormatted(
      """
      |fun f() {
      |  foo(1, 2, 3)
      |
      |  foo(
      |      123456789012345678901234567890,
      |      123456789012345678901234567890,
      |      123456789012345678901234567890)
      |}
      |""".trimMargin())

  @Test
  fun `function calls with multiple named arguments`() = assertFormatted(
      """
      |fun f() {
      |  foo(1, b = 2, c = 3)
      |
      |  foo(
      |      123456789012345678901234567890,
      |      b = 23456789012345678901234567890,
      |      c = 3456789012345678901234567890)
      |}
      |""".trimMargin())

  @Test
  fun `Arguments are blocks`() = assertFormatted(
      """
      |override fun visitProperty(property: KtProperty) {
      |  builder.sync(property)
      |  builder.block(ZERO) {
      |    declareOne(
      |        kind = DeclarationKind.FIELD,
      |        modifiers = property.modifierList,
      |        valOrVarKeyword =
      |            property.valOrVarKeyword.text,
      |        typeParameters =
      |            property.typeParameterList,
      |        receiver = property.receiverTypeReference,
      |        name = property.nameIdentifier?.text,
      |        type = property.typeReference,
      |        typeConstraintList =
      |            property.typeConstraintList,
      |        delegate = property.delegate,
      |        initializer = property.initializer)
      |  }
      |}
      |""".trimMargin(), 50)

  @Test
  fun `anonymous function`() = assertFormatted(
      """
      |fun f() {
      |  setListener(
      |      fun(number: Int) {
      |        println(number)
      |      })
      |}
      |""".trimMargin())

  @Test
  fun `anonymous function with receiver`() = assertFormatted(
      """
      |fun f() {
      |  setListener(
      |      fun View.() {
      |        println(this)
      |      })
      |}
      |""".trimMargin())

  @Test
  fun `when() with a subject expression`() = assertFormatted(
      """
      |fun f(x: Int) {
      |  when (x) {
      |    1 -> print(1)
      |    2 -> print(2)
      |    else -> {
      |      print(3)
      |    }
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `when() expression with complex predicates`() = assertFormatted(
      """
      |fun f(x: Int) {
      |  when {
      |    x == 1 || x == 2 -> print(1)
      |    x == 3 && x != 4 -> print(2)
      |    else -> {
      |      print(3)
      |    }
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `when() expression with several conditions`() = assertFormatted(
      """
      |fun f(x: Int) {
      |  when {
      |    0, 1 -> print(1)
      |    else -> print(0)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `when() expression with is and in`() = assertFormatted(
      """
      |fun f(x: Int) {
      |  when (x) {
      |    is String -> print(1)
      |    !is String -> print(2)
      |    in 1..3 -> print()
      |    in a..b -> print()
      |    in a..3 -> print()
      |    in 1..b -> print()
      |    !in 1..b -> print()
      |    else -> print(3)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `when() expression with enum values`() = assertFormatted(
      """
      |fun f(x: Color) {
      |  when (x) {
      |    is Color.Red -> print(1)
      |    is Color.Green -> print(2)
      |    else -> print(3)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `when() expression with generic matcher and exhaustive`() = assertFormatted(
      """
      |fun f(x: Result) {
      |  when (x) {
      |    is Success<*> -> print(1)
      |    is Failure -> print(2)
      |  }.exhaustive
      |}
      |""".trimMargin())

  @Test
  fun `line breaks inside when expressions and conditions`() = assertFormatted(
      """
      |fun f() {
      |  return Text.create(c)
      |      .onTouch {
      |        when (it.motionEvent.action) {
      |          ACTION_DOWN ->
      |              Toast.makeText(it.view.context, "Down!", Toast.LENGTH_SHORT, blablabla).show()
      |          ACTION_UP -> Toast.makeText(it.view.context, "Up!", Toast.LENGTH_SHORT).show()
      |          ACTION_DOWN ->
      |              Toast.makeText(
      |                  it.view.context, "Down!", Toast.LENGTH_SHORT, blablabla, blablabl, blabla)
      |                  .show()
      |        }
      |      }
      |      .build()
      |}
      |""".trimMargin())

  @Test
  fun `function return types`() = assertFormatted(
      """
      |fun f1(): Int = 0
      |
      |fun f2(): Int {}
      |""".trimMargin())

  @Test
  fun `multi line function without a block body`() = assertFormatted(
      """
      |fun longFunctionNoBlock():
      |    Int =
      |    1234567 + 1234567
      |
      |fun shortFun(): Int =
      |    1234567 + 1234567
      |""".trimMargin(), 25)

  @Test
  fun `return type doesn't fit in one line`() = assertFormatted(
      """
      |interface X {
      |  fun f(
      |      arg1: Arg1Type, arg2: Arg2Type
      |  ): Map<String, Map<String, Double>>? {
      |    //
      |  }
      |
      |  fun functionWithGenericReturnType(
      |      arg1: Arg1Type, arg2: Arg2Type
      |  ): Map<String, Map<String, Double>>? {
      |    //
      |  }
      |}
      |""".trimMargin(), 50)

  @Test
  fun `list of superclasses`() = assertFormatted(
      """
      |class Derived2 : Super1, Super2 {}
      |class Derived1 : Super1, Super2
      |class Derived3(a: Int) : Super1(a)
      |class Derived4 : Super1()
      |class Derived5 : Super3<Int>()
      |""".trimMargin())

  @Test
  fun `list of superclasses over multiple lines`() = assertFormatted(
      """
      |class Derived2 :
      |    Super1,
      |    Super2 {}
      |class Derived1 :
      |    Super1, Super2
      |class Derived3(
      |    a: Int) :
      |    Super1(a)
      |class Derived4 :
      |    Super1()
      |class Derived5 :
      |    Super3<Int>()
      |""".trimMargin(), 20)

  @Test
  fun `annotations with parameters`() = assertFormatted(
      """
      |@AnnWithArrayValue(1, 2, 3)
      |class C
      |""".trimMargin())

  @Test
  fun `method modifiers`() = assertFormatted(
      """
      |override internal fun f() {}
      |""".trimMargin())

  @Test
  fun `class modifiers`() = assertFormatted(
      """
      |abstract class Foo
      |inner class Foo
      |final class Foo
      |open class Foo
      |""".trimMargin())

  @Test
  fun `kdoc comments`() {
    val code = """
      |/**
      | * foo
      | */ class F {
      |
      | }
      |""".trimMargin()
    val expected = """
      |/** foo */
      |class F {}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `formatting kdoc doesn't add p HTML tags`() = assertFormatted(
      """
      |/**
      | * Bla bla bla bla
      | *
      | * This is an inferred paragraph, and as you can see, we don't add a p tag to it, even though bla
      | * bla.
      | *
      | * <p>On the other hand, we respect existing tags, and don't remove them.
      | */
      |""".trimMargin())

  @Test
  fun `formatting kdoc preserves lists`() = assertFormatted(
      """
      |/**
      | * Here are some fruit I like:
      | * - Banana
      | * - Apple
      | *
      | * This is another paragraph
      | */
      |""".trimMargin())

  @Test
  fun `return statement with value`() = assertFormatted(
      """
      |fun random(): Int {
      |  return 4
      |}
      |""".trimMargin())

  @Test
  fun `return statement without value`() = assertFormatted(
      """
      |fun print(b: Boolean) {
      |  print(b)
      |  return
      |}
      |""".trimMargin())

  @Test
  fun `if statement without else`() = assertFormatted(
      """
      |fun maybePrint(b: Boolean) {
      |  if (b) {
      |    println(b)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `if statement with else`() = assertFormatted(
      """
      |fun maybePrint(b: Boolean) {
      |  if (b) {
      |    println(2)
      |  } else {
      |    println(1)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `if expression with else`() = assertFormatted(
      """
      |fun maybePrint(b: Boolean) {
      |  println(if (b) 1 else 2)
      |  println(
      |      if (b) {
      |        val a = 1 + 1
      |        2 * a
      |      } else 2)
      |  return if (b) 1 else 2
      |}
      |""".trimMargin())

  @Test
  fun `if expression with break before else`() = assertFormatted(
      """
      |fun compute(b: Boolean) {
      |  val c =
      |      if (a + b < 20) a + b
      |      else a
      |  return if (a + b < 20) a + b
      |  else c
      |}
      |""".trimMargin(), 30)

  @Test
  fun `assignment expression on multiple lines`() = assertFormatted(
      """
      |fun f() {
      |  var myVariable = 5;
      |  myVariable =
      |      function1(4, 60, 8) + function2(57, 39, 20)
      |}
      |""".trimMargin(), 50)

  @Test
  fun `A program that tickled a bug in KotlinInput`() = assertFormatted(
      """
      |val x = 2
      |""".trimMargin())

  @Test
  fun `a few variations of constructors`() = assertFormatted(
      """
      |class Foo constructor(number: Int) {}
      |class Foo2 private constructor(number: Int) {}
      |class Foo3 @Inject constructor(number: Int) {}
      |class Foo4 @Inject private constructor(number: Int) {}
      |class Foo5
      |    @Inject
      |    private constructor(
      |        number: Int, number2: Int, number3: Int, number4: Int, number5: Int, number6: Int) {}
      |""".trimMargin())

  @Test
  fun `a constructor with many arguments over breaking to next line`() = assertFormatted(
      """
      |data class Foo(
      |    val number: Int, val name: String, val age: Int, val title: String, val offspring2: List<Foo>)
      |""".trimMargin())

  @Test
  fun `a constructor with keyword and many arguments over breaking to next line`() = assertFormatted(
      """
      |data class Foo
      |    constructor(
      |        val name: String, val age: Int, val title: String, val offspring: List<Foo>)
      |""".trimMargin())

  @Test
  fun `a constructor with many arguments over multiple lines`() = assertFormatted(
      """
      |data class Foo
      |    constructor(
      |        val number: Int,
      |        val name: String,
      |        val age: Int,
      |        val title: String,
      |        val offspring: List<Foo>)
      |""".trimMargin(), 50)

  @Test
  fun `handle secondary constructors`() = assertFormatted(
      """
      |class Foo private constructor(number: Int) {
      |  private constructor(n: Float) : this(1)
      |  private constructor(n: Double) : this(1) {
      |    println("built")
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `a secondary constructor with many arguments over multiple lines`() = assertFormatted(
      """
      |data class Foo {
      |  constructor(
      |      val number: Int,
      |      val name: String,
      |      val age: Int,
      |      val title: String,
      |      val offspring: List<Foo>)
      |}
      |""".trimMargin(), 50)

  @Test
  fun `a secondary constructor with many arguments passed to delegate`() = assertFormatted(
      """
      |data class Foo {
      |  constructor(
      |      val number: Int,
      |      val name: String,
      |      val age: Int,
      |      val title: String,
      |      val offspring: List<Foo>) :
      |          this(
      |              number,
      |              name,
      |              age,
      |              title,
      |              offspring,
      |              offspring)
      |}
      |""".trimMargin(), 50)

  @Test
  fun `handle calling super constructor in secondary constructor`() = assertFormatted(
      """
      |class Foo : Bar {
      |  internal constructor(number: Int) : super(number) {}
      |}
      |""".trimMargin())

  @Test
  fun `handle objects`() = assertFormatted(
      """
      |object Foo(n: Int) {}
      |""".trimMargin())

  @Test
  fun `handle object expression`() = assertFormatted(
      """
      |fun f(): Any {
      |  return object : Adapter() {}
      |}
      |""".trimMargin())

  @Test
  fun `handle object expression in parenthesis`() = assertFormatted(
      """
      |fun f(): Any {
      |  return (object : Adapter() {})
      |}
      |""".trimMargin())

  @Test
  fun `handle array indexing operator`() = assertFormatted(
      """
      |fun f(a: Magic) {
      |  a[3]
      |  b[3, 4]
      |}
      |""".trimMargin())

  @Test
  fun `handle destructuring declaration`() = assertFormatted(
      """
      |fun f() {
      |  val (a, b: Int) = listOf(1, 2)
      |}
      |""".trimMargin())

  @Test
  fun `handle ? for nullalble types`() = assertFormatted(
      """
      |fun doItWithNullReturns(a: String, b: String): Int? {
      |  return 5
      |}
      |
      |fun doItWithNulls(a: String, b: String?) {}
      |""".trimMargin())

  @Test
  fun `nullable function type`() = assertFormatted(
      """
      |var listener: ((Boolean) -> Unit)? = null
      |""".trimMargin())

  @Test
  fun `redundant parenthesis in function types`() = assertFormatted(
      """
      |val a: (Int) = 7
      |var listener: ((Boolean) -> Unit) = foo
      |""".trimMargin())

  @Test
  fun `handle string literals`() = assertFormatted(
      """
      |fun doIt(world: String) {
      |  println("Hello world!")
      |  println("Hello! ${'$'}world")
      |  println("Hello! ${'$'}{"wor" + "ld"}")
      |}
      |""".trimMargin())

  @Test
  fun `when there is an expression in a template string it gets formatted accordingly`() {
    val code = """
      |fun doIt() {
      |  println("Hello! ${'$'}{"wor"+"ld"}")
      |}
      |""".trimMargin()
    val expected = """
      |fun doIt() {
      |  println("Hello! ${'$'}{"wor" + "ld"}")
      |}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `handle multiline string literals`() = assertFormatted(
      """
      |fun doIt(world: String) {
      |  println(${"\"".repeat(3)}Hello
      |      world!${"\"".repeat(3)})
      |}
      |""".trimMargin())

  @Test
  fun `handle some basic generics scenarios`() = assertFormatted(
      """
      |fun <T> doIt(a: List<T>): List<Int>? {
      |  val b: List<Int> = convert<Int>(listOf(5, 4))
      |  return b
      |}
      |
      |class Foo<T>
      |""".trimMargin())

  @Test
  fun `handle for loops`() = assertFormatted(
      """
      |fun f(a: List<Int>) {
      |  for (i in a.indices) {
      |    println(i)
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `Qualified type`() = assertFormatted(
      """
      |fun f() {
      |  var plusFour: Indent.Const
      |  var x: Map.Entry<String, Integer>
      |  var x: List<String>.Iterator
      |}
      |""".trimMargin())

  @Test
  fun `handle destructuring declaration in for loop`() = assertFormatted(
      """
      |fun f(a: List<Pair<Int, Int>>) {
      |  for ((x, y: Int) in a) {}
      |}
      |""".trimMargin())

  @Test
  fun `handle scope operator`() = assertFormatted(
      """
      |fun f(a: List<Int>) {
      |  a.forEach(::println)
      |  a.map(Int::toString)
      |}
      |""".trimMargin())

  @Test
  fun `handle escaped identifier`() = assertFormatted(
      """
      |import foo as `foo foo`
      |import org.mockito.Mockito.`when` as `yay yay`
      |
      |fun `spaces in functions`() {
      |  val `when` = NEVER
      |  val (`do not`, `ever write`) = SERIOUSLY
      |  val `a a`: Int
      |}
      |
      |class `more spaces`
      |""".trimMargin())

  @Test
  fun `handle annotations with arguments`() = assertFormatted(
      """
      |@Px fun f(): Int = 5
      |
      |@Dimenstion(unit = DP)
      |fun g(): Int = 5
      |
      |@RunWith(MagicRunner::class)
      |class Test
      |""".trimMargin())

  @Test
  fun `annotations on functions types parameters`() = assertFormatted(
      """
      |val callback: (List<@JvmSuppressWildcards String>) -> Unit = foo
      |""".trimMargin())

  @Test
  fun `Unary expressions`() = assertFormatted(
      """
      |fun f() {
      |  !a
      |  -4
      |  val x = -foo()
      |  +4
      |  ++a
      |  --a
      |}
      |""".trimMargin())

  @Test
  fun `handle wildcard generics`() = assertFormatted(
      """
      |fun f() {
      |  val l: List<*>
      |  val p: Pair<*, *>
      |}
      |""".trimMargin())

  @Test
  fun `handle covariant and contravariant type arguments`() = assertFormatted(
      """
      |val p: Pair<in T, out S>
      |""".trimMargin())

  @Test
  fun `handle covariant and contravariant type parameters`() = assertFormatted(
      """
      |class Foo<in T, out S>
      |""".trimMargin())

  @Test
  fun `handle bounds for type parameters`() = assertFormatted(
      """
      |class Foo<in T : List<*>, out S : Any?>
      |""".trimMargin())

  @Test
  fun `handle compound generic bounds on classes`() = assertFormatted(
      """
      |class Foo<T>(n: Int) where T : Bar, T : FooBar {}
      |""".trimMargin())

  @Test
  fun `handle compound generic bounds on functions`() = assertFormatted(
      """
      |fun <T> foo(n: Int) where T : Bar, T : FooBar {}
      |""".trimMargin())

  @Test
  fun `handle compound generic bounds on properties`() = assertFormatted(
      """
      |val <T> List<T>.twiceSum: Int where T : Int
      |  get() {
      |    return 2 * sum()
      |  }
      |""".trimMargin())

  @Test
  fun `explicit type on property getter`() = assertFormatted(
      """
      |class Foo {
      |  val silly: Int
      |    get(): Int = 1
      |}
      |""".trimMargin())

  @Test
  fun `handle method calls with lambda arg only`() = assertFormatted(
      """
      |fun f() {
      |  val a = g { 1 + 1 }
      |}
      |""".trimMargin())

  @Test
  fun `handle method calls value args and a lambda arg`() = assertFormatted(
      """
      |fun f() {
      |  val a = g(1, 2) { 1 + 1 }
      |}
      |""".trimMargin())

  @Test
  fun `handle top level constants`() = assertFormatted(
      """
      |val a = 5
      |const val b = 6
      |""".trimMargin())

  @Test
  fun `handle lambda arg with named arguments`() = assertFormatted(
      """
      |fun f() {
      |  val b = { x: Int, y: Int -> x + y }
      |}
      |""".trimMargin())

  @Test
  fun `handle labeled this pointer`() = assertFormatted(
      """
      |class Foo {
      |  fun f() {
      |    g { println(this@Foo) }
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle extension and operator functions`() = assertFormatted(
      """
      |operator fun Point.component1() = x
      |""".trimMargin())

  @Test
  fun `handle extension properties`() = assertFormatted(
      """
      |val Int.isPrime: Boolean
      |  get() = runMillerRabinPrimality(this)
      |""".trimMargin())

  @Test
  fun `generic extension property`() = assertFormatted(
      """
      |val <T> List<T>.twiceSize = 2 * size()
      |""".trimMargin())

  @Test
  fun `handle file annotations`() = assertFormatted(
      """
      |@file:JvmName("DifferentName")
      |package com.somecompany.example
      |
      |import com.somecompany.example2
      |
      |class Foo {}
      |""".trimMargin())

  @Test
  fun `handle init block`() = assertFormatted(
      """
      |class Foo {
      |  init {
      |    println("Init!")
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle interface delegation`() = assertFormatted(
      """
      |class MyList(impl: List<Int>) : Collection<Int> by impl
      |""".trimMargin())

  @Test
  fun `handle property delegation`() = assertFormatted(
      """
      |val a by lazy { 1 + 1 }
      |""".trimMargin())

  @Test
  fun `handle lambda types`() = assertFormatted(
      """
      |val listener1: (Boolean) -> Unit = { b -> !b }
      |val listener2: () -> Unit = {}
      |val listener3: (Int, Double) -> Int = { a, b -> a }
      |val listener4: Int.(Int, Boolean) -> Unit
      |""".trimMargin())

  @Test
  fun `handle unicode in string literals`() = assertFormatted(
      """
      |val a = "\uD83D\uDC4D"
      |""".trimMargin())

  @Test
  fun `handle casting`() = assertFormatted(
      """
      |fun castIt(o: Object) {
      |  println(o is Double)
      |  println(o !is Double)
      |  doIt(o as Int)
      |  doIt(o as? Int)
      |}
      |""".trimMargin())

  @Test
  fun `handle colleciton literals in annotations`() = assertFormatted(
      """
      |@Foo(a = [1, 2])
      |fun doIt(o: Object) {}
      |""".trimMargin())

  @Test
  fun `handle try, catch and finally`() = assertFormatted(
      """
      |fun foo() {
      |  try {
      |    bar()
      |  } catch (e: Exception) {
      |    throw e
      |  } finally {
      |    println("finally")
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle infix methods`() = assertFormatted(
      """
      |fun numbers() {
      |  (0 until 100).size
      |}
      |""".trimMargin())

  @Test
  fun `handle while loops`() = assertFormatted(
      """
      |fun numbers() {
      |  while (1 < 2) {
      |    println("Everything is okay")
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle do while loops`() = assertFormatted(
      """
      |fun numbers() {
      |  do {
      |    println("Everything is okay")
      |  } while (1 < 2)
      |}
      |""".trimMargin())

  @Test
  fun `handle break and continue`() = assertFormatted(
      """
      |fun numbers() {
      |  while (1 < 2) {
      |    if (true) {
      |      break
      |    }
      |    if (false) {
      |      continue
      |    }
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle all kinds of labels and jumps`() = assertFormatted(
      """
      |fun f(a: List<Int>) {
      |  a.map {
      |    myloop@ for (i in a) {
      |      if (true) {
      |        break@myloop
      |      } else if (false) {
      |        continue@myloop
      |      } else {
      |        a.map `inner map`@{
      |          return@`inner map`
      |        }
      |      }
      |    }
      |    return@map 2 * it
      |  }
      |}
      |""".trimMargin())

  @Test
  @Ignore("This requires being able to reliably ignore tokens")
  fun `when imports or package have semicolons remove them`() {
    val code = """
      |package org.examples.wow;
      |import org.examples.wow.MuchWow;
      |import org.examples.wow.ManyAmaze
      |""".trimMargin()
    val expected = """
      |package org.examples.wow
      |import org.examples.wow.MuchWow
      |import org.examples.wow.ManyAmaze
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `handle optional semicolons until we can reliably remove them`() = assertFormatted(
      """
      |package com.example.bar;
      |
      |import com.example.Foo;
      |
      |typealias Int2 = Int;
      |
      |fun f() {
      |  val a = 5;
      |  a = 7;
      |  println(1);
      |  return 4;
      |};
      |""".trimMargin())

  @Test
  @Ignore("This requires being able to reliably ignore tokens")
  fun `remove unnecessary semicolons`() {
    val code = """
      |val a = 5;
      |fun foo() {
      |  println(1);
      |  println(2); println(3)
      |}
      |""".trimMargin()
    val expected = """
      |val a = 5
      |fun foo() {
      |  println(1)
      |  println(2)
      |  println(3)
      |}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  @Ignore("This requires being able to reliably ignore tokens")
  fun `remove unnecessary parenthesis in lambda calls`() {
    val code = """
      |fun f() {
      |  a() {
      |    println("a")
      |  }
      |}
      |""".trimMargin()
    val expected = """
      |fun f() {
      |  a {
      |    println("a")
      |  }
      |}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `handle no parenthesis in lambda calls`() = assertFormatted(
      """
      |fun f() {
      |  a { println("a") }
      |}
      |""".trimMargin())

  @Test
  fun `handle multi statement lambdas`() = assertFormatted(
      """
      |fun f() {
      |  a {
      |    println("a")
      |    println("b")
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle multi line one statement lambda`() = assertFormatted(
      """
      |fun f() {
      |  a {
      |    println(foo.bar.boom)
      |  }
      |}
      |""".trimMargin(), 25)

  @Test
  fun `statements are wrapped in blocks`() = assertFormatted(
      """
      |fun f() {
      |  builder.block {
      |    getArgumentName().accept
      |    return
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `properly break fully qualified nested user types`() = assertFormatted(
      """
      |val complicated
      |    : com.example.interesting.SomeType<
      |    com.example.interesting.SomeType<Int, Nothing>,
      |    com.example.interesting.SomeType<
      |        com.example.interesting.SomeType<
      |            Int,
      |            Nothing>,
      |        Nothing>> =
      |    DUMMY
      |""".trimMargin(), 53)

  @Test
  fun `handle multi-line lambdas within lambdas and calling chains`() = assertFormatted(
      """
      |fun f() {
      |  builder.block(ZERO) {
      |    builder.token("when")
      |    expression1.let { subjectExp ->
      |      builder.token(")")
      |      return
      |    }
      |  }
      |  builder.block(ZERO) {
      |    expression2.subjectExpression
      |        .let { subjectExp ->
      |          builder.token(")")
      |          return
      |        }
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle multi line lambdas with explicit args`() = assertFormatted(
      """
      |fun f() {
      |  a { (x, y) ->
      |    x + y
      |  }
      |}
      |""".trimMargin(), 20)

  @Test
  fun `handle parenthesis in lambda calls for now`() = assertFormatted(
      """
      |fun f() {
      |  a() { println("a") }
      |}
      |""".trimMargin())

  @Test
  fun `handle chaining of calls with lambdas`() = assertFormatted(
      """
      |fun f() {
      |  bob.map { x -> x * x }
      |      .map { x -> x * x }
      |      ?.map { x ->
      |        val y = x * x
      |        y
      |      }
      |      .sum
      |}
      |""".trimMargin())

  @Test
  fun `handle reified types`() = assertFormatted(
      """
      |inline fun <reified T> foo(t: T) {
      |  println(t)
      |}
      |
      |inline fun <reified in T> foo2(t: T) {
      |  println(t)
      |}
      |""".trimMargin())

  @Test
  fun `handle simple enum classes`() = assertFormatted(
      """
      |enum class BetterBoolean {
      |  TRUE,
      |  FALSE,
      |  FILE_NOT_FOUND,
      |}
      |""".trimMargin())

  @Test
  fun `handle enum class with functions`() = assertFormatted(
      """
      |enum class BetterBoolean {
      |  TRUE,
      |  FALSE,
      |  FILE_NOT_FOUND;
      |  fun isGood(): Boolean {
      |    return true
      |  }
      |}
      |""".trimMargin())

  @Test
  fun `handle enum with annotations`() = assertFormatted(
      """
      |enum class BetterBoolean {
      |  @True TRUE,
      |  @False @WhatIsTruth FALSE,
      |}
      |""".trimMargin())

  @Test
  fun `handle enum constructor calls`() = assertFormatted(
      """
      |enum class BetterBoolean(val name: String, val value: Boolean = true) {
      |  TRUE("true"),
      |  FALSE("false", false),
      |}
      |""".trimMargin())

  @Test
  fun `handle enum entries with body`() = assertFormatted(
      """
      |enum class Animal(canWalk: Boolean = true) {
      |  DOG {
      |    fun speak() = "woof"
      |  },
      |  FISH(false) {},
      |}
      |""".trimMargin())

  @Test
  fun `handle empty enum`() = assertFormatted(
      """
      |enum class YTho {
      |}
      |""".trimMargin())

  @Test
  fun `enum without trailing comma`() = assertFormatted(
      """
      |enum class Highlander {
      |  ONE
      |}
      |""".trimMargin())

  @Test
  fun `enum comma and semicolon`() = assertFormatted(
      """
      |enum class Highlander {
      |  ONE,;
      |}
      |""".trimMargin())

  @Test
  fun `handle varargs and spread operator`() = assertFormatted(
      """
      |fun foo(vararg args: String) {
      |  foo2(*args)
      |  foo3(options = *args)
      |}
      |""".trimMargin())

  @Test
  fun `handle typealias`() = assertFormatted(
      """
      |private typealias TextChangedListener =
      |    (string: String) -> Unit
      |typealias PairPair<X, Y> = Pair<Pair<X, Y>, X>
      |
      |class Foo
      |""".trimMargin(), 50)

  @Test
  fun `handle class expression with generics`() = assertFormatted(
      """
      |fun f() {
      |  println(Array<String>::class.java)
      |}
      |""".trimMargin())

  @Test
  fun `FormattingError contains correct line and column numbers`() {
    val code = """
      |// Foo
      |fun good() {
      |  //
      |}
      |
      |fn () { }
      |""".trimMargin()
    try {
      format(code)
    } catch (e: FormattingError) {
      assertThat(e.diagnostics()[0].line()).isEqualTo(6)
      assertThat(e.diagnostics()[0].column()).isEqualTo(6)
    }
  }

  @Test
  fun `fail() reports line+column number`() {
    val code = """
      |// Foo
      |fun good() {
      |  return@ 5
      |}
      |""".trimMargin()
    try {
      format(code)
    } catch (e: FormattingError) {
      assertThat(e.diagnostics()[0].line()).isEqualTo(3)
      assertThat(e.diagnostics()[0].column()).isEqualTo(10)
    }
  }

  @Test
  fun `handle annotations with use-site targets`() = assertFormatted(
      """
      |class FooTest {
      |  @get:Rule val exceptionRule: ExpectedException = ExpectedException.none()
      |  @set:Magic(name = "Jane")
      |  var field: String
      |}
      |""".trimMargin())

  @Test
  fun `handle annotations mixed with keywords since we cannot reorder them for now`() = assertFormatted(
      """
      |public @Magic final class Foo
      |public @Magic(1) final class Foo
      |@Magic(1)
      |public final class Foo
      |""".trimMargin())

  @Test
  fun `handle annotations more`() = assertFormatted(
      """
      |@Anno1
      |@Anno2(param = Param1::class)
      |@Anno3
      |@Anno4(param = Param2::class)
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle one line KDoc`() = assertFormatted(
      """
      |/** Hi, I am a one line kdoc */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with Link`() = assertFormatted(
      """
      |/** This links to [AnotherClass] */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with paragraphs`() = assertFormatted(
      """
      |/**
      | * Hi, I am a two paragraphs kdoc
      | *
      | * There's a space line to preserve between them
      | */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with blocks`() = assertFormatted(
      """
      |/**
      | * Hi, I am a two paragraphs kdoc
      | *
      | * @param param1 this is param1
      | * @param[param2] this is param2
      | */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with code examples`() = assertFormatted(
      """
      |/**
      | * This is how you write a simple hello world in Kotlin:
      | *
      | * ```
      | * fun main(args: Array<String>) {
      | *   println("Hello World!")
      | * }
      | * ```
      | *
      | * Amazing ah?
      | */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with link reference`() = assertFormatted(
      """
      |/** Doc line with a reference to [AnotherClass] in the middle of a sentence */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `handle KDoc with links one after another`() = assertFormatted(
      """
      |/** Here are some links [AnotherClass] [AnotherClass2] */
      |class MyClass {}
      |""".trimMargin())

  @Test
  fun `add spaces after links in Kdoc`() {
    val code = """
      |/** Here are some links [AnotherClass][AnotherClass2]hello */
      |class MyClass {}
      |""".trimMargin()
    val expected = """
      |/** Here are some links [AnotherClass] [AnotherClass2] hello */
      |class MyClass {}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  @Test
  fun `handle KDoc with multiple separated param tags, breaking and merging lines and missing asterisk`() {
    val code = """
      |/**
      | * Trims leading whitespace characters followed by [marginPrefix] from every line of a source string and removes
      | * the first and the last lines if they are blank (notice difference blank vs empty).
      | 
      | * Doesn't affect a line if it doesn't contain [marginPrefix] except the first and the last blank lines.
      | *
      | * Doesn't preserve the original line endings.
      | *
      | * @param marginPrefix non-blank string, which is used as a margin delimiter. Default is `|` (pipe character).
      | *
      | * @sample samples.text.Strings.trimMargin
      | * @see trimIndent
      | * @see kotlin.text.isWhitespace
      | */
      |class ThisWasCopiedFromTheTrimMarginMethod {}
      |""".trimMargin()
    val expected = """
      |/**
      | * Trims leading whitespace characters followed by [marginPrefix] from every line of a source string
      | * and removes the first and the last lines if they are blank (notice difference blank vs empty).
      | *
      | * Doesn't affect a line if it doesn't contain [marginPrefix] except the first and the last blank
      | * lines.
      | *
      | * Doesn't preserve the original line endings.
      | *
      | * @param marginPrefix non-blank string, which is used as a margin delimiter. Default is `|` (pipe
      | * character).
      | *
      | * @sample samples.text.Strings.trimMargin
      | * @see trimIndent
      | * @see kotlin.text.isWhitespace
      | */
      |class ThisWasCopiedFromTheTrimMarginMethod {}
      |""".trimMargin()
    assertThatFormatting(code).isEqualTo(expected)
  }

  /** Verifies the given code passes through formatting, and stays the same at the end */
  private fun assertFormatted(code: String, maxWidth: Int = DEFAULT_MAX_WIDTH) {
    assertThatFormatting(code, maxWidth).isEqualTo(code)
  }

  fun assertThatFormatting(code: String, maxWidth: Int = DEFAULT_MAX_WIDTH): FormattedCodeSubject {
    fun codes(): Subject.Factory<FormattedCodeSubject, String> {
      return Subject.Factory { metadata, subject -> FormattedCodeSubject(metadata, subject, maxWidth) }
    }
    return assertAbout(codes()).that(code)
  }

  class FormattedCodeSubject(
      metadata: FailureMetadata,
      subject: String?,
      val maxWidth: Int
  ) :
      Subject<FormattedCodeSubject, String>(metadata, subject) {
    fun isEqualTo(expectedFormatting: String) {
      val code = actual()
      if (expectedFormatting.lines().any { it.endsWith(" ") }) {
        throw RuntimeException(
            "Expected code contains trailing whitespace, which the formatter will never output:\n" +
                expectedFormatting.lines().map { if (it.endsWith(" ")) "[$it]" else it }.joinToString("\n"))
      }
      val actualFormatting: String
      try {
        actualFormatting = format(code, maxWidth)
        if (actualFormatting != expectedFormatting) {
          reportError(code)
          println("# Output: ")
          println("#".repeat(20))
          println(actualFormatting)
          println()
        }
      } catch (e: Error) {
        reportError(code)
        throw e
      }
      assertThat(actualFormatting).isEqualTo(expectedFormatting)
    }

    private fun reportError(code: String) {
      val file = Parser.parse(code)
      println("# Parse tree of input: ")
      println("#".repeat(20))
      file.accept(PrintAstVisitor())
      println()
      println("# Input: ")
      println("#".repeat(20))
      println(code)
      println()
    }
  }
}