/*
 * Copyright (C) 2020 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.
 */

package com.android.build.api.apiTest

import com.android.build.api.apiTest.VariantApiBaseTest.ScriptingLanguage

/**
 * repository of Gradle tasks and Android related artifacts like build files or manifest files that
 * can be used to assemble tests.
 */
@Suppress("ClassNameDiffersFromFileName")
class TestingElements(val language: ScriptingLanguage) {

    fun addGitVersionTask(builder: VariantApiBaseTest.GivenBuilder) {
        builder.addSource(
            constructFilePath("GitVersion"),
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.tasks.OutputFile
            import org.gradle.api.tasks.TaskAction
            ${getGitVersionTask()}
            """
        )
    }

    fun addManifestProducerTask(builder: VariantApiBaseTest.GivenBuilder) {
        builder.addSource(
            constructFilePath("ManifestProducerTask"),
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.tasks.InputFile
            import org.gradle.api.tasks.OutputFile
            import org.gradle.api.tasks.TaskAction
            ${getManifestProducerTask()}
            """

        )
    }

    fun addManifestTransformerTask(builder: VariantApiBaseTest.GivenBuilder) {
        builder.addSource(
            constructFilePath("ManifestTransformerTask"),
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.tasks.InputFile 
            import org.gradle.api.tasks.OutputFile
            import org.gradle.api.tasks.TaskAction
            ${getManifestTransformerTask()}
            """
        )
    }

    fun addManifestVerifierTask(builder: VariantApiBaseTest.GivenBuilder) {
        builder.addSource(
            constructFilePath("VerifyManifestTask"),
            getManifestVerifierTask()
        )
    }

    fun addCopyApksTask(builder: VariantApiBaseTest.GivenBuilder) {
        builder.addSource(
            constructFilePath("CopyApksTask"),
            """
            import java.io.Serializable
            import java.io.File
            import javax.inject.Inject
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.file.Directory
            import org.gradle.api.file.DirectoryProperty
            import org.gradle.api.tasks.InputFiles
            import org.gradle.api.tasks.Internal
            import org.gradle.api.tasks.OutputDirectory
            import org.gradle.api.tasks.TaskAction
            import org.gradle.api.provider.Property
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.WorkerExecutor
            import org.gradle.workers.WorkAction
            import com.android.build.api.artifact.ArtifactType
            import com.android.build.api.artifact.ArtifactKind
            import com.android.build.api.artifact.Artifact
            import com.android.build.api.artifact.Artifact.Replaceable
            import com.android.build.api.artifact.Artifact.ContainsMany
            import com.android.build.api.artifact.ArtifactTransformationRequest
            import com.android.build.api.variant.BuiltArtifact

            ${getCopyApksTask()}
            """
        )
    }

    fun addCommonAndroidBuildLogic() =
                """
                compileSdkVersion(29)
                defaultConfig {
                    minSdkVersion(21)
                    targetSdkVersion(29)
                }"""

    fun addManifest(builder: VariantApiBaseTest.GivenBuilder) {
        builder.manifest =
            // language=xml
            """<?xml version="1.0" encoding="utf-8"?>
                <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                    package="com.android.build.example.minimal">
                    <application android:label="Minimal">
                        <activity android:name="MainActivity">
                            <intent-filter>
                                <action android:name="android.intent.action.MAIN" />
                                <category android:name="android.intent.category.LAUNCHER" />
                            </intent-filter>
                        </activity>
                    </application>
                </manifest>
            """.trimIndent()
    }

    fun addMainActivity(builder: VariantApiBaseTest.GivenBuilder) =
        when(language) {
            ScriptingLanguage.Kotlin ->
                builder.addSource(
                    constructFilePath("com/android/build/example/minimal/MainActivity"),
            //language=kotlin
            """
            package com.android.build.example.minimal

            import android.app.Activity
            import android.os.Bundle
            import android.widget.TextView

            class MainActivity : Activity() {
                override fun onCreate(savedInstanceState: Bundle?) {
                    super.onCreate(savedInstanceState)
                    val label = TextView(this)
                    label.setText("Hello world!")
                    setContentView(label)
                }
            }
            """)
            ScriptingLanguage.Groovy ->
                builder.addSource(
                    constructFilePath("com/android/build/example/minimal/MainActivity"),
            // language=java
            """
            package com.android.build.example.minimal;

            import android.app.Activity;
            import android.os.Bundle;
            import android.widget.TextView;

            public class MainActivity extends Activity
            {
                @Override
                public void onCreate(Bundle savedInstanceState) {
                    super.onCreate(savedInstanceState);

                    TextView label = new TextView(this);
                    label.setText("Hello world!");

                    setContentView(label);
                }
            }
            """)
    }

    private fun constructFilePath(relativePath: String) =
        when(language) {
            ScriptingLanguage.Kotlin -> "src/main/kotlin/$relativePath.kt"
            ScriptingLanguage.Groovy -> "src/main/java/$relativePath.groovy"
        }


    fun getGitVersionTask() =
        when(language) {
            ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            abstract class GitVersionTask: DefaultTask() {

                @get:OutputFile
                abstract val gitVersionOutputFile: RegularFileProperty

                @ExperimentalStdlibApi
                @TaskAction
                fun taskAction() {

                    // this would be the code to get the tip of tree version, 
                    // val firstProcess = ProcessBuilder("git","rev-parse --short HEAD").start()
                    // val error = firstProcess.errorStream.readBytes().decodeToString()
                    // if (error.isNotBlank()) {
                    //      System.err.println("Git error : ${'$'}error")
                    // }
                    // var gitVersion = firstProcess.inputStream.readBytes().decodeToString()

                    // but here, we are just hardcoding : 
                    gitVersionOutputFile.get().asFile.writeText("1234")
                }
            }
            """
            ScriptingLanguage.Groovy ->
            // language=groovy
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.tasks.OutputFile
            import org.gradle.api.tasks.TaskAction

            abstract class GitVersionTask extends DefaultTask {

                @OutputFile
                abstract RegularFileProperty getGitVersionOutputFile()

                @TaskAction
                void taskAction() {
                    // this would be the code to get the tip of tree version,
                    // String gitVersion = "git rev-parse --short HEAD".execute().text.trim()
                    // if (gitVersion.isEmpty()) {
                    //    gitVersion="12"
                    //}
                    getGitVersionOutputFile().get().asFile.write("1234")
                }
            }
            """
        }

fun getManifestProducerTask() =
        when(language) {
            ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            abstract class ManifestProducerTask: DefaultTask() {
                @get:InputFile
                abstract val gitInfoFile: RegularFileProperty

                @get:OutputFile
                abstract val outputManifest: RegularFileProperty

                @TaskAction
                fun taskAction() {

                    val gitVersion = gitInfoFile.get().asFile.readText()
                    val manifest = ""${'"'}<?xml version="1.0" encoding="utf-8"?>
                <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                    package="com.android.build.example.minimal"
                    android:versionName="${'$'}{gitVersion}"
                    android:versionCode="1" >
                    <application android:label="Minimal">
                        <activity android:name="MainActivity">
                            <intent-filter>
                                <action android:name="android.intent.action.MAIN" />
                                <category android:name="android.intent.category.LAUNCHER" />
                            </intent-filter>
                        </activity>
                    </application>
                </manifest>
                    ""${'"'}
                    println("Writes to " + outputManifest.get().asFile.absolutePath)
                    outputManifest.get().asFile.writeText(manifest)
                }
            }
            """
            ScriptingLanguage.Groovy ->
            // language=groovy
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.tasks.InputFile
            import org.gradle.api.tasks.OutputFile
            import org.gradle.api.tasks.TaskAction

            abstract class ManifestProducerTask extends DefaultTask {
                @InputFile
                abstract RegularFileProperty getGitInfoFile()

                @OutputFile
                abstract RegularFileProperty getOutputManifest()

                @TaskAction
                void taskAction() {
                    String manifest = '''<?xml version=\"1.0\" encoding=\"utf-8\"?>
                    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                        package="com.android.build.example.minimal"
                        android:versionName="${'$'}{new String(getGitInfoFile().get().asFile.readBytes())}"
                        android:versionCode="1" >

                        <application android:label="Minimal">
                            <activity android:name="MainActivity">
                                <intent-filter>
                                    <action android:name="android.intent.action.MAIN" />
                                    <category android:name="android.intent.category.LAUNCHER" />
                                </intent-filter>
                            </activity>
                        </application>
                    </manifest>
                        '''
                    println("Writes to " + getOutputManifest().get().getAsFile().getAbsolutePath())
                    getOutputManifest().get().getAsFile().write(manifest)
                }
            }
            """
        }

    fun getManifestTransformerTask() =
        when(language) {
            ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            abstract class ManifestTransformerTask: DefaultTask() {

                @get:InputFile
                abstract val gitInfoFile: RegularFileProperty

                @get:InputFile
                abstract val mergedManifest: RegularFileProperty

                @get:OutputFile
                abstract val updatedManifest: RegularFileProperty

                @TaskAction
                fun taskAction() {

                    val gitVersion = gitInfoFile.get().asFile.readText()
                    var manifest = mergedManifest.asFile.get().readText()
                    manifest = manifest.replace("android:versionCode=\"1\"", "android:versionCode=\"${'$'}{gitVersion}\"")
                    println("Writes to " + updatedManifest.get().asFile.getAbsolutePath())
                    updatedManifest.get().asFile.writeText(manifest)
                }
            }
            """
            ScriptingLanguage.Groovy ->
            // language=groovy
            """
            import org.gradle.api.file.RegularFileProperty

            abstract class ManifestTransformerTask extends DefaultTask {

                @InputFile
                abstract RegularFileProperty getGitInfoFile()

                @InputFile
                abstract RegularFileProperty getMergedManifest()

                @OutputFile
                abstract RegularFileProperty getUpdatedManifest()

                @TaskAction
                void taskAction() {
                    String gitVersion = new String(getGitInfoFile().get().asFile.readBytes())
                    String manifest = new String(getMergedManifest().get().asFile.readBytes())
                    manifest = manifest.replace("android:versionCode=\"1\"",
                        "android:versionCode=\""+ gitVersion +"\"")
                    getUpdatedManifest().get().asFile.write(manifest)
                }
            }
            """
        }

    private fun getManifestVerifierTask() =
        when(language) {
            ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.DirectoryProperty
            import org.gradle.api.tasks.InputFiles
            import org.gradle.api.tasks.TaskAction
            import java.io.ByteArrayOutputStream
            import java.io.PrintStream

            import com.android.build.api.variant.BuiltArtifactsLoader
            import org.gradle.api.provider.Property
            import org.gradle.api.tasks.Internal
            import java.io.File

            abstract class VerifyManifestTask: DefaultTask() {

                @get:InputFiles
                abstract val apkFolder: DirectoryProperty

                @get:Internal
                abstract val builtArtifactsLoader: Property<BuiltArtifactsLoader>

                @TaskAction
                fun taskAction() {
                    val builtArtifacts = builtArtifactsLoader.get().load(apkFolder.get())
                        ?: throw RuntimeException("Cannot load APKs")
                    if (builtArtifacts.elements.size != 1)
                        throw RuntimeException("Expected one APK !")
                    val apk = File(builtArtifacts.elements.single().outputFile).toPath()
                    println("Insert code to verify manifest file in ${'$'}{apk}")
                    println("SUCCESS")
                }
            }
            """
            ScriptingLanguage.Groovy ->
                """

                """.trimIndent()
        }

        fun getDisplayApksTask()=
            when(language) {
                ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            abstract class DisplayApksTask: DefaultTask() {

                @get:InputFiles
                abstract val apkFolder: DirectoryProperty

                @get:Internal
                abstract val builtArtifactsLoader: Property<BuiltArtifactsLoader>

                @TaskAction
                fun taskAction() {

                    val builtArtifacts = builtArtifactsLoader.get().load(apkFolder.get())
                        ?: throw RuntimeException("Cannot load APKs")
                    builtArtifacts.elements.forEach {
                        println("Got an APK at ${ '$' }{it.outputFile}")
                    }
                }
            }
            """
                ScriptingLanguage.Groovy ->
            // language=groovy
                    """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.Directory
            import org.gradle.api.file.DirectoryProperty
            import org.gradle.api.tasks.InputFiles
            import org.gradle.api.tasks.TaskAction
            import java.io.ByteArrayOutputStream
            import java.io.PrintStream

            import com.android.build.api.variant.BuiltArtifactsLoader
            import com.android.build.api.artifact.ArtifactType
            import com.android.build.api.variant.BuiltArtifacts
            import org.gradle.api.provider.Property
            import org.gradle.api.tasks.Internal 

            abstract class DisplayApksTask extends DefaultTask {

                @InputFiles
                abstract DirectoryProperty getApkFolder()

                @Internal
                abstract Property<BuiltArtifactsLoader> getBuiltArtifactsLoader()

                @TaskAction
                void taskAction() {

                    BuiltArtifacts artifacts = getBuiltArtifactsLoader().get().load(getApkFolder().get())
                    if (artifacts == null) {
                        throw new RuntimeException("Cannot load APKs")
                    }
                    artifacts.elements.forEach {
                        println("Got an APK at ${'$'}{it.outputFile}")
                    }
                }
            }
            """
            }

    fun getCopyApksTask()=
        when(language) {
            ScriptingLanguage.Groovy ->
                // language=groovy
                """
            import org.gradle.api.DefaultTask
            import org.gradle.api.file.Directory
            import org.gradle.api.file.DirectoryProperty
            import org.gradle.api.file.RegularFileProperty
            import org.gradle.api.provider.Property
            import org.gradle.api.tasks.InputFiles
            import org.gradle.api.tasks.TaskAction
            import org.gradle.workers.WorkerExecutor
            import com.android.build.api.variant.BuiltArtifact
            import com.android.build.api.artifact.ArtifactTransformationRequest
            import org.gradle.api.tasks.Internal

            import java.nio.file.Files

            interface WorkItemParameters extends WorkParameters, Serializable {
                RegularFileProperty getInputApkFile()
                RegularFileProperty getOutputApkFile()
            }

            abstract class WorkItem implements WorkAction<WorkItemParameters> {

                WorkItemParameters workItemParameters

                @Inject
                WorkItem(WorkItemParameters parameters) {
                   this.workItemParameters = parameters
                }

                void execute() {
                    Files.copy(
                        workItemParameters.getInputApkFile().getAsFile().get().toPath(),
                        workItemParameters.getOutputApkFile().get().getAsFile().toPath())
                } 
            }

            abstract class CopyApksTask extends DefaultTask {

                WorkerExecutor workers

                @Inject
                CopyApksTask(WorkerExecutor workerExecutor) {
                    this.workers = workerExecutor
                }

                @InputFiles
                abstract DirectoryProperty getApkFolder()

                @OutputDirectory
                abstract DirectoryProperty getOutFolder()

                @Internal
                abstract Property<ArtifactTransformationRequest<CopyApksTask>> getTransformationRequest()

                @TaskAction
                void taskAction() {

                     transformationRequest.get().submit(
                         this,
                         workers.noIsolation(),
                         WorkItem,
                         WorkItemParameters, {
                             BuiltArtifact builtArtifact,
                             Directory outputLocation,
                             WorkItemParameters param ->
                                File inputFile = new File(builtArtifact.outputFile)
                                param.getInputApkFile().set(inputFile)
                                param.getOutputApkFile().set(new File(outputLocation.asFile, inputFile.name))
                                param.getOutputApkFile().get().getAsFile()
                         }
                    )
                }
            }
            """
            ScriptingLanguage.Kotlin ->
            // language=kotlin
            """
            interface WorkItemParameters: WorkParameters, Serializable {
                val inputApkFile: RegularFileProperty
                val outputApkFile: RegularFileProperty
            }

            abstract class WorkItem @Inject constructor(private val workItemParameters: WorkItemParameters)
                : WorkAction<WorkItemParameters> {
                override fun execute() {
                    workItemParameters.inputApkFile.asFile.get().copyTo(
                        workItemParameters.outputApkFile.get().asFile)
                }
            }
            abstract class CopyApksTask @Inject constructor(private val workers: WorkerExecutor): DefaultTask() {

                @get:InputFiles
                abstract val apkFolder: DirectoryProperty

                @get:OutputDirectory
                abstract val outFolder: DirectoryProperty

                @get:Internal
                abstract val transformationRequest: Property<ArtifactTransformationRequest<CopyApksTask>>

                @TaskAction
                fun taskAction() {

                  transformationRequest.get().submit(
                     this, 
                     workers.noIsolation(),
                     WorkItem::class.java,
                     WorkItemParameters::class.java) {
                         builtArtifact: BuiltArtifact, 
                         outputLocation: Directory, 
                         param: WorkItemParameters -> 
                            val inputFile = File(builtArtifact.outputFile)
                            param.inputApkFile.set(inputFile)
                            param.outputApkFile.set(File(outputLocation.asFile, inputFile.name))
                            param.outputApkFile.get().asFile
                     }
                }
            }
            """
        }
}