/*
 * Copyright 2019 The Android Open Source Project
 *
 * 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.
 */

@file:Suppress("KDocUnresolvedReference", "UnstableApiUsage")

package androidx.build.lint

import com.android.tools.lint.checks.infrastructure.LintDetectorTest
import com.android.tools.lint.checks.infrastructure.ProjectDescription
import com.android.tools.lint.checks.infrastructure.TestFile
import com.android.tools.lint.checks.infrastructure.TestMode
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4

/**
 * Test for [SampledAnnotationDetector]
 *
 * This tests the following module setup:
 *
 * Module 'foo', which lives in foo Module 'foo:samples', which lives in foo/samples, and depends on
 * 'foo'
 */
@RunWith(JUnit4::class)
class SampledAnnotationDetectorTest : LintDetectorTest() {

    override fun getDetector() = SampledAnnotationDetector()

    override fun getIssues() =
        mutableListOf(
            SampledAnnotationDetector.OBSOLETE_SAMPLED_ANNOTATION,
            SampledAnnotationDetector.UNRESOLVED_SAMPLE_LINK,
            SampledAnnotationDetector.MULTIPLE_FUNCTIONS_FOUND,
            SampledAnnotationDetector.INVALID_SAMPLES_LOCATION
        )

    private val fooModuleName = "foo"
    private val sampleModuleName = "samples"

    private val barFilePath = "src/foo/Bar.kt"
    private val sampleFilePath = "samples/src/foo/samples/test.kt"

    private val sampledStub =
        compiled(
            "libs/sampled.jar",
            kotlin(
                    """
            package androidx.annotation

            @Target(AnnotationTarget.FUNCTION)
            @Retention(AnnotationRetention.SOURCE)
            annotation class Sampled
        """
                )
                .to("androidx/annotation/Sampled.kt"),
            0x9dd4162c,
            """
        META-INF/main.kotlin_module:
        H4sIAAAAAAAAAGNgYGBmYGBgBGJWKM3AJcrFnZafr1ecmFuQk1osxBaSWlzi
        XaLEoMUAAClM+YMvAAAA
        """,
            """
        androidx/annotation/Sampled.class:
        H4sIAAAAAAAAAIVSyU4CQRB9NYggbriDuGv0Jki8cXLBSKJiEL1wapmOGWlm
        CNOg3rj5Tx4M8ehHGatdgMNE+1D9qvq96qrqfv94eQWwj01CSrh203Psx7Rw
        XU8L7Xhu+krUG0raERAhfi/aIq2Ee5cu3t7Lqo4gRFjtRwd0Bz0YQZiweFbz
        tHLcQUpZNO+kzhEmhFLeg7S/Az5hK4DdT9jTRU+uL47KheIFYTlAUZJaugYx
        NdwWqiUJO39mHlQMXxWvS0d5wtpZYIOD3O1/KJeecqpPOVNmILHX0UbweV7J
        OmcqPzWkqew8Xz4tHhOmfps5l1rYQgs+tOrtED8oGcNzpxqHHh3jZRjZe4Rk
        txONWQkrZsVT0bdnK9HtZK0MHXY7hpA1Rf7xEfgKEGI/3m5NG8drNavyxFE8
        4GSpxS3X5Y3jO7dK9mfrb3N6DLF4GGZZWP+ya9jgvYow+I8hWgFJjCCGUfbG
        JMYxgclvGGc4ZeAXZxozmGXVXAWhAuYLWGCLhDHJAhaRYpaPJSxXYPlY8bH6
        CeBn7eLsAgAA
        """
        )

    private val emptySampleFile =
        kotlin(
            """
            package foo.samples
        """
        )

    private val unannotatedSampleFile =
        kotlin(
            """
            package foo.samples

            fun sampleBar() {}
        """
        )

    private val multipleMatchingSampleFile =
        kotlin(
            """
            package foo.samples

            import androidx.annotation.Sampled

            @Sampled
            fun sampleBar() {}

            @Sampled
            fun sampleBar(param: Boolean = false) {}
        """
        )

    private val correctlyAnnotatedSampleFile =
        kotlin(
            """
            package foo.samples

            import androidx.annotation.Sampled

            @Sampled
            fun sampleBar() {}
        """
        )

    private fun checkKotlin(
        fooFile: TestFile? = null,
        sampleFile: TestFile,
        expectedText: String? = null,
        requiresPartialAnalysis: Boolean = true
    ) {
        val projectDescriptions = mutableListOf<ProjectDescription>()
        val fooProject =
            ProjectDescription().apply {
                name = fooModuleName
                type = ProjectDescription.Type.LIBRARY
                fooFile?.let { addFile(fooFile) }
            }
        projectDescriptions += fooProject

        val sampleProject =
            ProjectDescription().apply {
                name = sampleModuleName
                type = ProjectDescription.Type.LIBRARY
                under = fooProject
                files = arrayOf(sampleFile, sampledStub)
                dependsOn(fooProject)
            }
        projectDescriptions += sampleProject

        lint().run {
            projects(*projectDescriptions.toTypedArray())
            if (requiresPartialAnalysis) {
                // The lint check will only work in partial analysis, so we expect non-partial
                // test modes to have no errors. This has to be called before run().
                expectIdenticalTestModeOutput(false)
            }
            run().run {
                if (expectedText == null) {
                    expectClean()
                } else {
                    if (requiresPartialAnalysis) {
                        // expectClean doesn't accept a testMode param
                        expect("No warnings.", testMode = TestMode.DEFAULT)
                        expect(expectedText, testMode = TestMode.PARTIAL)
                    } else {
                        expect(expectedText)
                    }
                }
            }
        }
    }

    @Test
    fun unresolvedSampleLink_Function() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              fun bar() {}
            }
        """
            )

        val sampleFile = emptySampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun unannotatedSampleFunction_Function() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              fun bar() {}
            }
        """
            )

        val sampleFile = unannotatedSampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun multipleMatchingSampleFunctions_Function() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              fun bar() {}
            }
        """
            )

        val sampleFile = multipleMatchingSampleFile

        val expected =
            """$sampleFilePath:10: Error: Found multiple functions matching foo.samples.sampleBar [MultipleSampledFunctions]
            fun sampleBar(param: Boolean = false) {}
                ~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(
            fooFile = fooFile,
            sampleFile = sampleFile,
            expectedText = expected,
            // Since this particular is all done inside the same module, partial analysis isn't
            // required so it will still work in global analysis
            requiresPartialAnalysis = false
        )
    }

    @Test
    fun correctlyAnnotatedSampleFunction_Function() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              fun bar() {}
            }
        """
            )

        val sampleFile = correctlyAnnotatedSampleFile

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = null)
    }

    @Test
    fun unresolvedSampleLink_Class() {
        val fooFile =
            kotlin(
                """
            package foo

            /**
             * @sample foo.samples.sampleBar
             */
            class Bar
        """
            )

        val sampleFile = emptySampleFile

        val expected =
            """$barFilePath:5: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun unannotatedSampleFunction_Class() {
        val fooFile =
            kotlin(
                """
            package foo

            /**
             * @sample foo.samples.sampleBar
             */
            class Bar
        """
            )

        val sampleFile = unannotatedSampleFile

        val expected =
            """$barFilePath:5: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun multipleMatchingSampleFunctions_Class() {
        val fooFile =
            kotlin(
                """
            package foo

            /**
             * @sample foo.samples.sampleBar
             */
            class Bar
        """
            )

        val sampleFile = multipleMatchingSampleFile

        val expected =
            """$sampleFilePath:10: Error: Found multiple functions matching foo.samples.sampleBar [MultipleSampledFunctions]
            fun sampleBar(param: Boolean = false) {}
                ~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(
            fooFile = fooFile,
            sampleFile = sampleFile,
            expectedText = expected,
            // Since this particular is all done inside the same module, partial analysis isn't
            // required so it will still work in global analysis
            requiresPartialAnalysis = false
        )
    }

    @Test
    fun correctlyAnnotatedSampleFunction_Class() {
        val fooFile =
            kotlin(
                """
            package foo

            /**
             * @sample foo.samples.sampleBar
             */
            class Bar
        """
            )

        val sampleFile = correctlyAnnotatedSampleFile

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = null)
    }

    @Test
    fun unresolvedSampleLink_Field() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              const val bar = 0
            }
        """
            )

        val sampleFile = emptySampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun unannotatedSampleFunction_Field() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              const val bar = 0
            }
        """
            )

        val sampleFile = unannotatedSampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun multipleMatchingSampleFunctions_Field() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              const val bar = 0
            }
        """
            )

        val sampleFile = multipleMatchingSampleFile

        val expected =
            """$sampleFilePath:10: Error: Found multiple functions matching foo.samples.sampleBar [MultipleSampledFunctions]
            fun sampleBar(param: Boolean = false) {}
                ~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(
            fooFile = fooFile,
            sampleFile = sampleFile,
            expectedText = expected,
            // Since this particular is all done inside the same module, partial analysis isn't
            // required so it will still work in global analysis
            requiresPartialAnalysis = false
        )
    }

    @Test
    fun correctlyAnnotatedSampleFunction_Field() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              const val bar = 0
            }
        """
            )

        val sampleFile = correctlyAnnotatedSampleFile

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = null)
    }

    @Test
    fun unresolvedSampleLink_PropertyWithGetter() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              val bar get() = 0
            }
        """
            )

        val sampleFile = emptySampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun unannotatedSampleFunction_PropertyWithGetter() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              val bar get() = 0
            }
        """
            )

        val sampleFile = unannotatedSampleFile

        val expected =
            """$barFilePath:6: Error: Couldn't find a valid @Sampled function matching foo.samples.sampleBar [UnresolvedSampleLink]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun multipleMatchingSampleFunctions_PropertyWithGetter() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              val bar get() = 0
            }
        """
            )

        val sampleFile = multipleMatchingSampleFile

        val expected =
            """$sampleFilePath:10: Error: Found multiple functions matching foo.samples.sampleBar [MultipleSampledFunctions]
            fun sampleBar(param: Boolean = false) {}
                ~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(
            fooFile = fooFile,
            sampleFile = sampleFile,
            expectedText = expected,
            // Since this particular is all done inside the same module, partial analysis isn't
            // required so it will still work in global analysis
            requiresPartialAnalysis = false
        )
    }

    @Test
    fun correctlyAnnotatedSampleFunction_PropertyWithGetter() {
        val fooFile =
            kotlin(
                """
            package foo

            class Bar {
              /**
               * @sample foo.samples.sampleBar
               */
              val bar get() = 0
            }
        """
            )

        val sampleFile = correctlyAnnotatedSampleFile

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile, expectedText = null)
    }

    @Test
    fun obsoleteSampledFunction() {
        val sampleFile = correctlyAnnotatedSampleFile

        val expected =
            """$sampleFilePath:7: Error: foo.samples.sampleBar is annotated with @Sampled, but is not linked to from a @sample tag. [ObsoleteSampledAnnotation]
            fun sampleBar() {}
                ~~~~~~~~~
1 errors, 0 warnings

        """

        checkKotlin(sampleFile = sampleFile, expectedText = expected)
    }

    @Test
    fun invalidSampleLocation() {
        val sampleFile =
            kotlin(
                """
            package foo.wrong.location

            import androidx.annotation.Sampled

            @Sampled
            fun sampleBar() {}
        """
            )

        val expected =
            """samples/src/foo/wrong/location/test.kt:7: Error: foo.wrong.location.sampleBar is annotated with @Sampled, but is not linked to from a @sample tag. [ObsoleteSampledAnnotation]
            fun sampleBar() {}
                ~~~~~~~~~
1 errors, 0 warnings

        """

        checkKotlin(sampleFile = sampleFile, expectedText = expected)
    }
}