@GraphicsMode(GraphicsMode.Mode.NATIVE)

buildscript {
  dependencies {
    ...
    classpath 'io.github.takahirom.roborazzi:roborazzi-gradle-plugin:[write the latest vesrion]'
  }
}

import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.test.core.app.ActivityScenario
import androidx.test.espresso.Espresso.onView
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.annotation.GraphicsMode

// All you need to do is use the captureRoboImage function in the test!
import com.github.takahirom.roborazzi.captureRoboImage


// Tips: You can use Robolectric while using AndroidJUnit4
@RunWith(AndroidJUnit4::class)
// Enable Robolectric Native Graphics (RNG) 
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class ManualTest { 
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MainActivity>()

    @Test
    fun captureRoboImageSample() {
      // Tips: You can use Robolectric with Espresso API
      // launch
      ActivitySenario.launch(MainActivity::class.java)

      // Capture screen
      onView(ViewMatchers.isRoot())
          // If you don't specify a screenshot file name, Roborazzi will automatically use the method name as the file name for you.
          // The format of the file name will be as follows:
          // build/outputs/roborazzi/com_..._ManualTest_captureRoboImageSample.png
          .captureRoboImage()

      // Capture Jetpack Compose Node
      composeTestRule.onNodeWithTag("MyComposeButton")
          .onParent()
          .captureRoboImage("build/compose.png")

      // Capture small view on window
      onView(withId(R.id.button_first))
          .captureRoboImage("build/button.png")

      // move to next page
      onView(withId(R.id.button_first))
          .perform(click())

      val view: View = composeTestRule.activity.findViewById<View>(R.id.button_second)
      // Capture view on window
      view.captureRoboImage("build/manual_view_on_window.png")

      val textView = TextView(composeTestRule.activity).apply {
        text = "Hello View!"
        setTextColor(android.graphics.Color.RED)
      }
      // Capture view not on window
      textView.captureRoboImage("build/manual_view_without_window.png")

      // Capture Jetpack Compose lambda
      captureRoboImage("build/manual_compose.png") {
        Text("Hello Compose!")
      }

      val bitmap: Bitmap = createBitmap(100, 100, Bitmap.Config.ARGB_8888)
          .apply {
            applyCanvas {
              drawColor(android.graphics.Color.YELLOW)
            }
          }
      // Capture Bitmap
      bitmap.captureRoboImage("build/manual_bitmap.png") 
    }
}

@Test
fun captureRoboGifSample() {
  onView(ViewMatchers.isRoot())
    .captureRoboGif("build/test.gif") {
      // launch
      ActivityScenario.launch(MainActivity::class.java)
      // move to next page
      onView(withId(R.id.button_first))
        .perform(click())
      // back
      pressBack()
      // move to next page
      onView(withId(R.id.button_first))
        .perform(click())
    }
}

@RunWith(AndroidJUnit4::class)
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class RuleTestWithOnlyFail {
  @get:Rule
  val roborazziRule = RoborazziRule(
    captureRoot = onView(isRoot()),
    options = Options(
      onlyFail = true
    )
  )

  @Test
  fun captureRoboLastImageSampleFail() {
    // launch
    ActivityScenario.launch(MainActivity::class.java)
    // move to next page
    onView(withId(R.id.button_first))
      .perform(click())
    // should fail because the button does not exist
    // Due to failure, the gif image will be saved in the outputs folder.
    onView(withId(R.id.button_first))
      .perform(click())
  }
}

@Composable
fun SampleComposableFunction() {
  var count by remember { mutableStateOf(0) }
  Column(
    Modifier
      .size(300.dp)
  ) {
    Box(
      Modifier
        .testTag("MyComposeButton")
        .size(50.dp)
        .clickable {
          count++
        }
    )
    (0..count).forEach {
      Box(
        Modifier
          .size(30.dp)
      )
    }
  }
}

@RunWith(AndroidJUnit4::class)
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class ComposeTest {
  @get:Rule
  val composeTestRule = createAndroidComposeRule<ComponentActivity>()

  @get:Rule
  val roborazziRule = RoborazziRule(
    composeRule = composeTestRule,
    captureRoot = composeTestRule.onRoot(),
    options = RoborazziRule.Options(
      RoborazziRule.CaptureType.Gif
    )
  )

  @Test
  fun composable() {
    composeTestRule.setContent {
      SampleComposableFunction()
    }
    (0 until 3).forEach { _ ->
      composeTestRule
        .onNodeWithTag("MyComposeButton")
        .performClick()
    }
  }
}

class RoborazziRule private constructor(
  ...
) : TestWatcher() {
  /**
   * If you add this annotation to the test, the test will be ignored by roborazzi
   */
  annotation class Ignore

  data class Options(
    val captureType: CaptureType = CaptureType.Gif,
    /**
     * capture only when the test fail
     */
    val onlyFail: Boolean = false,
    /**
     * output directory path
     */
    val outputDirectoryPath: String = DEFAULT_ROBORAZZI_OUTPUT_DIR_PATH,
    val roborazziOptions: RoborazziOptions = RoborazziOptions(),
  )

  enum class CaptureType {
    /**
     * Generate last images for each test
     */
    LastImage,

    /**
     * Generate images for each layout change such as TestClass_method_0.png for each test.
     */
    AllImage,

    /**
     * Generate gif images for each test
     */
    Gif
  }