/*
 * 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")

package androidx.build.lint

import com.android.tools.lint.checks.infrastructure.ProjectDescription
import com.android.tools.lint.checks.infrastructure.TestFile
import com.android.tools.lint.checks.infrastructure.TestFiles.kotlin
import com.android.tools.lint.checks.infrastructure.TestLintResult
import com.android.tools.lint.checks.infrastructure.TestLintTask.lint
import org.junit.Test

/**
 * Test for [SampledAnnotationEnforcer]
 *
 * This tests the following module setup:
 *
 * Module 'foo', which lives in foo
 * Module 'integration-tests:samples', which lives in integration-tests,
 * and depends on 'foo'
 *
 * Unfortunately since we cannot test submodules, we cannot verify the case for
 * foo:integration-tests:samples in this test.
 */
class SampledAnnotationEnforcerTest {
    private val fooModuleName = "foo"
    private val sampleModuleName = "integration-tests"

    private val barFilePath = "foo/src/foo/Bar.kt"

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

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

            fun sampleBar() {}
        """)

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

            fun sampleBar() {}

            fun sampleBar() {}
        """)

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

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

    private fun checkKotlin(
        fooFile: TestFile? = null,
        sampleFile: TestFile? = null
    ): TestLintResult {
        val fooProject = ProjectDescription().apply {
            name = fooModuleName
            fooFile?.let { files = arrayOf(fooFile) }
        }
        val sampleProject = ProjectDescription().apply {
            name = sampleModuleName
            sampleFile?.let {
                // Hack to make it seem that we are in a samples sub-module of integration-tests,
                // since we cannot actually set this up in tests.
                sampleFile.within("samples/src")
                files = arrayOf(sampleFile)
            }
            dependsOn(fooProject)
        }
        return lint()
            .projects(fooProject, sampleProject)
            .allowMissingSdk(true)
            .issues(
                SampledAnnotationEnforcer.MISSING_SAMPLED_ANNOTATION,
                SampledAnnotationEnforcer.OBSOLETE_SAMPLED_ANNOTATION,
                SampledAnnotationEnforcer.MISSING_SAMPLES_DIRECTORY,
                SampledAnnotationEnforcer.UNRESOLVED_SAMPLE_LINK,
                SampledAnnotationEnforcer.MULTIPLE_FUNCTIONS_FOUND,
                SampledAnnotationEnforcer.INVALID_SAMPLES_LOCATION
            )
            .run()
    }

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

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

        val expected =
    "$barFilePath:6: Error: Couldn't find a valid samples directory in this project" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile)
            .expect(expected)
    }

    @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 function matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

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

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

        val sampleFile = unannotatedSampleFile

        val expected =
"foo/src/foo/Bar.kt:6: Error: sampleBar is not annotated with @Sampled, but is linked to from" +
""" the KDoc of bar [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

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

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

        val sampleFile = multipleMatchingSampleFile

        val expected =
"$barFilePath:6: Error: Found multiple functions matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

    @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)
            .expectClean()
    }

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

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

        val expected =
"$barFilePath:5: Error: Couldn't find a valid samples directory in this project" +
""" [EnforceSampledAnnotation]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile)
            .expect(expected)
    }

    @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 function matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

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

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

        val sampleFile = unannotatedSampleFile

        val expected =
"$barFilePath:5: Error: sampleBar is not annotated with @Sampled, but is linked to from" +
""" the KDoc of Bar [EnforceSampledAnnotation]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

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

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

        val sampleFile = multipleMatchingSampleFile

        val expected =
"$barFilePath:5: Error: Found multiple functions matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
             * @sample foo.samples.sampleBar
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

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

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

        val sampleFile = correctlyAnnotatedSampleFile

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expectClean()
    }

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

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

        val expected =
"$barFilePath:6: Error: Couldn't find a valid samples directory in this project" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile)
            .expect(expected)
    }

    @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 function matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(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: sampleBar is not annotated with @Sampled, but is linked to from" +
""" the KDoc of bar [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(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 =
"$barFilePath:6: Error: Found multiple functions matching foo.samples.sampleBar" +
""" [EnforceSampledAnnotation]
               * @sample foo.samples.sampleBar
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 errors, 0 warnings
        """

        checkKotlin(fooFile = fooFile, sampleFile = sampleFile)
            .expect(expected)
    }

    @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)
            .expectClean()
    }
}