/*
 * Copyright 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 androidx.build

import org.gradle.api.Project

/**
 * LibraryType represents the purpose and type of a library, whether it is a conventional library,
 * a set of samples showing how to use a conventional library, a set of lint rules for using a
 * conventional library, or any other type of published project.
 *
 * LibraryType collects a set of properties together, to make the "why" more clear and to simplify
 * setting these properties for library developers, so that only a single enum inferrable from
 * the purpose of the library needs to be set, rather than a variety of more arcane options.
 *
 * These properties are as follows:
 * LibraryType.publish represents how the library is published to GMaven
 * LibraryType.sourceJars represents whether we publish the source code for the library to GMaven
 *      in a way accessible to download, such as by Android Studio
 * LibraryType.generateDocs represents whether we generate documentation from the library to put on
 *      developer.android.com
 * LibraryType.checkApi represents whether we enforce API compatibility of the library according
 *      to our semantic versioning protocol
 *
 * The possible values of LibraryType are as follows:
 * PUBLISHED_LIBRARY: a conventional library, published, sourced, documented, and versioned
 * SAMPLES: a library of samples, published as additional properties to a conventional library,
 *      including published source. Documented in a special way, not API tracked.
 * LINT: a library of lint rules for using a conventional library. Published through lintPublish as
 *      part of an AAR, not published standalone
 * ANNOTATION_PROCESSOR: a library consisting of an annotation processor. Used only while compiling.
 * UNSET: a library that has not yet been migrated to using LibraryType. Should never be used.
 *
 * TODO: potential future LibraryTypes:
 * KOTLIN_ONLY_LIBRARY: like PUBLISHED_LIBRARY, but not intended for use from java. ktx and compose.
 * INTERNAL_TEST: compilationTarget varies? Everything else is default.
 *
 */
enum class LibraryType(
    val publish: Publish = Publish.NONE,
    val sourceJars: Boolean = false,
    val generateDocs: Boolean = false,
    val checkApi: RunApiTasks = RunApiTasks.No("Unknown Library Type"),
    val compilationTarget: CompilationTarget = CompilationTarget.DEVICE
) {
    PUBLISHED_LIBRARY(
        publish = Publish.SNAPSHOT_AND_RELEASE,
        sourceJars = true,
        generateDocs = true,
        checkApi = RunApiTasks.Yes()
    ),
    SAMPLES(
        publish = Publish.SNAPSHOT_AND_RELEASE,
        sourceJars = true,
        generateDocs = true,
        checkApi = RunApiTasks.No("Sample Library")
    ),
    LINT(
        publish = Publish.NONE,
        sourceJars = false,
        generateDocs = false,
        checkApi = RunApiTasks.No("Lint Library"),
        compilationTarget = CompilationTarget.HOST
    ),
    ANNOTATION_PROCESSOR(
        publish = Publish.SNAPSHOT_AND_RELEASE,
        sourceJars = false,
        generateDocs = true,
        checkApi = RunApiTasks.No("Annotation Processor"),
        compilationTarget = CompilationTarget.HOST
    ),
    UNSET()
}

fun Project.isSamplesProject(): Boolean {
    return project.extensions.findByType(AndroidXExtension::class.java)?.type == LibraryType.SAMPLES
}

enum class CompilationTarget {
    /** This library is meant to run on the host machine (like an annotation processor). */
    HOST,
    /** This library is meant to run on an Android device. */
    DEVICE
}

/**
 * Publish Enum:
 * Publish.NONE -> Generates no aritfacts; does not generate snapshot artifacts
 *                 or releasable maven artifacts
 * Publish.SNAPSHOT_ONLY -> Only generates snapshot artifacts
 * Publish.SNAPSHOT_AND_RELEASE -> Generates both snapshot artifacts and releasable maven artifact
 *
 * TODO: should we introduce a Publish.lintPublish?
 */
enum class Publish {
    NONE, SNAPSHOT_ONLY, SNAPSHOT_AND_RELEASE;

    fun shouldRelease() = this == SNAPSHOT_AND_RELEASE
    fun shouldPublish() = this == SNAPSHOT_ONLY || this == SNAPSHOT_AND_RELEASE
}

sealed class RunApiTasks {
    /** Automatically determine whether API tasks should be run. */
    object Auto : RunApiTasks()
    /** Always run API tasks regardless of other project properties. */
    data class Yes(val reason: String? = null) : RunApiTasks()
    /** Do not run any API tasks. */
    data class No(val reason: String) : RunApiTasks()
}